├── .gitignore
├── .vscode
└── settings.json
├── Readme.md
├── main.css
├── shortcuts.ui
├── adw.py
├── material.py
├── widgets.py
├── main.py
└── LICENSE
/.gitignore:
--------------------------------------------------------------------------------
1 | /.idea/
2 | **/__pycache__
3 |
--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 | "python.formatting.provider": "black"
3 | }
--------------------------------------------------------------------------------
/Readme.md:
--------------------------------------------------------------------------------
1 | ### Misc classes to build Gtk4 Applications in python 3.9
2 |
3 | It takes the hassle away from building Gtk4 application in Python
4 | So you can create a cool application, without all the boilerplate code
5 |
6 | * main.py is a sample application
7 | * widgets.py contains classes to make it easy to create your UI
8 |
9 | ### Requirements (Fedora 34)
10 | * gtk4
11 | * python3-gobject
12 | * Python 3.9 (or later)
13 |
14 | Will properly work fine in other distros, but I have only tested in Fedora 34
15 |
16 | ### Screenshoots
17 | 
18 | 
19 | 
20 | 
21 | 
22 |
--------------------------------------------------------------------------------
/main.css:
--------------------------------------------------------------------------------
1 | /* Style for Gtk.Frame */
2 | frame {
3 | border: 3px solid #0000ff;
4 | border-radius: 20px;
5 | color: #ff0000;
6 | background-color: #606060;
7 |
8 | }
9 |
10 | /* Style for Gtk.Box */
11 | box {
12 | border: 2px solid #ffffff;
13 | border-radius: 10px;
14 | background-color: #000000;
15 | padding: 0px;
16 | margin: 10px;
17 | color: #ffffff;
18 | opacity: 0.8;
19 | }
20 |
21 | box > button {
22 | all: unset;
23 | }
24 |
25 | box > revealer {
26 | border-width: 0px;
27 | }
28 |
29 | revealer > box {
30 | border: 2px solid rgba(0, 255, 255, 0.3);
31 | border-radius: 5px;
32 | background-color: #202020;
33 |
34 | }
35 |
36 | /* Style for Gtk.label in Gtk.Box */
37 | box > label {
38 | color: #00ff00;
39 | margin: 5px;
40 | }
41 |
42 | scale {
43 | /* top | right | bottom | left */
44 | margin: 15px;
45 | }
46 |
47 |
48 | progressbar {
49 | /* top | right | bottom | left */
50 | margin: 20px;
51 | }
52 |
53 | /* Prograss background bar */
54 | progressbar > trough {
55 | min-height: 8px;
56 | background-color: #007070;
57 | }
58 |
59 | /* Prograss */
60 | progressbar > trough > progress {
61 | min-height: 10px;
62 | background-color: #00ffff;
63 | }
64 |
65 | /* Style for Gtk.Paned Separator */
66 | paned > separator {
67 | background-image: linear-gradient(to bottom, #00ffff, #00ffff);
68 | background-size: 2px 2px;
69 | }
70 |
71 | /* Style for Gtk.Separator */
72 |
73 | box > separator {
74 | background-color: rgba(0, 255, 255, 0.3);
75 | min-width: 2px;
76 | min-height: 2px;
77 | margin: 5px;
78 | }
79 |
80 | textview.view {
81 | margin: 10px;
82 | padding: 10px;
83 | border: 2px solid rgba(0, 255, 255, 0.3);
84 | }
85 |
86 | grid {
87 | margin: 10px;
88 | }
89 |
90 | grid > label {
91 | font-size: 12pt;
92 | }
--------------------------------------------------------------------------------
/shortcuts.ui:
--------------------------------------------------------------------------------
1 |
2 |
3 |
87 |
88 |
--------------------------------------------------------------------------------
/adw.py:
--------------------------------------------------------------------------------
1 | # Copyright (C) 2021 Tim Lauridsen < tla[at]rasmil.dk >
2 | #
3 | # This program is free software; you can redistribute it and/or modify
4 | # it under the terms of the GNU General Public License as published by
5 | # the Free Software Foundation; either version 3 of the License, or
6 | # (at your option) any later version.
7 | #
8 | # This program is distributed in the hope that it will be useful,
9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 | # GNU General Public License for more details.
12 | #
13 | # You should have received a copy of the GNU General Public License
14 | # along with this program; if not, write to
15 | # the Free Software Foundation, Inc.,
16 | # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 | #
18 |
19 | """
20 | Sample Python Gtk4 Application
21 | """
22 | import sys
23 | import time
24 | from typing import List
25 |
26 | import gi
27 |
28 | gi.require_version("Gtk", "4.0")
29 | gi.require_version("Adw", "1")
30 |
31 | from gi.repository import Gtk, GObject, Gio, Adw
32 | from widgets import ColumnViewListStore
33 |
34 |
35 | class ColumnElem(GObject.GObject):
36 | """custom data element for a ColumnView model (Must be based on GObject)"""
37 |
38 | def __init__(self, name: str):
39 | super(ColumnElem, self).__init__()
40 | self.name = name
41 |
42 | def __repr__(self):
43 | return f"ColumnElem(name: {self.name})"
44 |
45 |
46 | class MyColumnViewColumn(ColumnViewListStore):
47 | """Custom ColumnViewColumn"""
48 |
49 | def __init__(
50 | self, win: Gtk.ApplicationWindow, col_view: Gtk.ColumnView, data: List
51 | ):
52 | # Init ListView with store model class.
53 | super(MyColumnViewColumn, self).__init__(ColumnElem, col_view)
54 | self.win = win
55 | # put some data into the model
56 | for elem in data:
57 | self.add(ColumnElem(elem))
58 |
59 | def factory_setup(self, widget, item: Gtk.ListItem):
60 | """Gtk.SignalListItemFactory::setup signal callback
61 | Handles the creation widgets to put in the ColumnViewColumn
62 | """
63 | label = Gtk.Label()
64 | label.set_halign(Gtk.Align.START)
65 | label.set_hexpand(True)
66 | label.set_margin_start(10)
67 | item.set_child(label)
68 |
69 | def factory_bind(self, widget, item: Gtk.ListItem):
70 | """Gtk.SignalListItemFactory::bind signal callback
71 | Handles adding data for the model to the widgets created in setup
72 | """
73 | label = item.get_child() # Get the Gtk.Label stored in the ListItem
74 | data = item.get_item() # get the model item, connected to current ListItem
75 | label.set_text(data.name) # Update Gtk.Label with data from model item
76 |
77 |
78 | class MyWindow(Adw.ApplicationWindow):
79 | def __init__(self, title, width, height, **kwargs):
80 | super(MyWindow, self).__init__(**kwargs)
81 | self.set_default_size(width, height)
82 | box = Gtk.Box()
83 | box.props.orientation = Gtk.Orientation.VERTICAL
84 | header = Gtk.HeaderBar()
85 | stack = Adw.ViewStack()
86 | switcher = Adw.ViewSwitcherTitle()
87 | switcher.set_stack(stack)
88 | header.set_title_widget(switcher)
89 | box.append(header)
90 | content = self.setup_content()
91 | page1 = stack.add_titled(content, "page1", "Page 1")
92 | box_p2 = Gtk.Box()
93 | page2 = stack.add_titled(box_p2, "page2", "Page 2")
94 | box.append(stack)
95 | self.set_content(box)
96 |
97 | def setup_content(self):
98 | """Add a page with a text selector to the stack"""
99 | # ColumnView with custom columns
100 | self.columnview = Gtk.ColumnView()
101 | self.columnview.set_show_column_separators(True)
102 | data = [f"Data Row: {row}" for row in range(5000)]
103 | for i in range(4):
104 | column = MyColumnViewColumn(self, self.columnview, data)
105 | column.set_title(f"Column {i}")
106 | self.columnview.append_column(column)
107 | lw_frame = Gtk.Frame()
108 | lw_frame.set_valign(Gtk.Align.FILL)
109 | lw_frame.set_vexpand(True)
110 | lw_frame.set_margin_start(20)
111 | lw_frame.set_margin_end(20)
112 | lw_frame.set_margin_top(10)
113 | lw_frame.set_margin_bottom(10)
114 | sw = Gtk.ScrolledWindow()
115 | sw.set_child(self.columnview)
116 | lw_frame.set_child(sw)
117 | return lw_frame
118 |
119 |
120 | class Application(Adw.Application):
121 | """Main Aplication class"""
122 |
123 | def __init__(self):
124 | super().__init__(
125 | application_id="dk.rasmil.Example", flags=Gio.ApplicationFlags.FLAGS_NONE
126 | )
127 |
128 | def do_activate(self):
129 | win = self.props.active_window
130 | if not win:
131 | win = MyWindow("My Gtk4 Application", 800, 800, application=self)
132 | win.present()
133 |
134 |
135 | def main():
136 | """Run the main application"""
137 | app = Application()
138 | return app.run(sys.argv)
139 |
140 |
141 | if __name__ == "__main__":
142 | main()
143 |
--------------------------------------------------------------------------------
/material.py:
--------------------------------------------------------------------------------
1 | # Copyright (C) 2021 Tim Lauridsen < tla[at]rasmil.dk >
2 | #
3 | # This program is free software; you can redistribute it and/or modify
4 | # it under the terms of the GNU General Public License as published by
5 | # the Free Software Foundation; either version 3 of the License, or
6 | # (at your option) any later version.
7 | #
8 | # This program is distributed in the hope that it will be useful,
9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 | # GNU General Public License for more details.
12 | #
13 | # You should have received a copy of the GNU General Public License
14 | # along with this program; if not, write to
15 | # the Free Software Foundation, Inc.,
16 | # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 | #
18 | """ This module is an implementation of the Material Design color palette """
19 | from typing import List, Dict
20 |
21 | _MATERIAL_COLORS = {
22 | 'Red': {'50': '#FFEBEE', '100': '#FFCDD2', '200': '#EF9A9A', '300': '#E57373', '400': '#EF5350', '500': '#F44336',
23 | '600': '#E53935', '700': '#D32F2F', '800': '#C62828', '900': '#B71C1C',
24 | 'A100': '#FF8A80', 'A200': '#FF5252', 'A400': '#FF1744', 'A700': '#D50000'},
25 | 'Pink': {'50': '#FCE4EC', '100': '#F8BBD0', '200': '#F48FB1', '300': '#F06292', '400': '#EC407A', '500': '#E91E63',
26 | '600': '#D81B60', '700': '#C2185B', '800': '#AD1457', '900': '#880E4F',
27 | 'A100': '#FF80AB', 'A200': '#FF4081', 'A400': '#F50057', 'A700': '#C51162'},
28 | 'Purple': {'50': '#F3E5F5', '100': '#E1BEE7', '200': '#CE93D8', '300': '#BA68C8', '400': '#AB47BC',
29 | '500': '#9C27B0',
30 | '600': '#8E24AA', '700': '#7B1FA2', '800': '#6A1B9A', '900': '#4A148C',
31 | 'A100': '#EA80FC', 'A200': '#E040FB', 'A400': '#D500F9', 'A700': '#AA00FF'},
32 | 'DeepPurple': {'50': '#EDE7F6', '100': '#D1C4E9', '200': '#B39DDB', '300': '#9575CD', '400': '#7E57C2',
33 | '500': '#673AB7',
34 | '600': '#5E35B1', '700': '#512DA8', '800': '#4527A0', '900': '#311B92',
35 | 'A100': '#B388FF', 'A200': '#7C4DFF', 'A400': '#651FFF', 'A700': '#6200EA'},
36 | 'Indigo': {'50': '#E8EAF6', '100': '#C5CAE9', '200': '#9FA8DA', '300': '#7986CB', '400': '#5C6BC0',
37 | '500': '#3F51B5',
38 | '600': '#3949AB', '700': '#303F9F', '800': '#283593', '900': '#1A237E',
39 | 'A100': '#8C9EFF', 'A200': '#536DFE', 'A400': '#3D5AFE', 'A700': '#304FFE'},
40 | 'Blue': {'50': '#E3F2FD', '100': '#BBDEFB', '200': '#90CAF9', '300': '#64B5F6', '400': '#42A5F5', '500': '#2196F3',
41 | '600': '#1E88E5', '700': '#1976D2', '800': '#1565C0', '900': '#0D47A1',
42 | 'A100': '#82B1FF', 'A200': '#448AFF', 'A400': '#2979FF', 'A700': '#2962FF'},
43 | 'LightBlue': {'50': '#E1F5FE', '100': '#B3E5FC', '200': '#81D4FA', '300': '#4FC3F7', '400': '#29B6F6',
44 | '500': '#03A9F4',
45 | '600': '#039BE5', '700': '#0288D1', '800': '#0277BD', '900': '#01579B',
46 | 'A100': '#80D8FF', 'A200': '#40C4FF', 'A400': '#00B0FF', 'A700': '#0091EA'},
47 | 'Cyan': {'50': '#E0F7FA', '100': '#B2EBF2', '200': '#80DEEA', '300': '#4DD0E1', '400': '#26C6DA', '500': '#00BCD4',
48 | '600': '#00ACC1', '700': '#0097A7', '800': '#00838F', '900': '#006064',
49 | 'A100': '#84FFFF', 'A200': '#18FFFF', 'A400': '#00E5FF', 'A700': '#00B8D4'},
50 | 'Teal': {'50': '#E0F2F1', '100': '#B2DFDB', '200': '#80CBC4', '300': '#4DB6AC', '400': '#26A69A', '500': '#009688',
51 | '600': '#00897B', '700': '#00796B', '800': '#00695C', '900': '#004D40',
52 | 'A100': '#A7FFEB', 'A200': '#64FFDA', 'A400': '#1DE9B6', 'A700': '#00BFA5'},
53 | 'Green': {'50': '#E8F5E9', '100': '#C8E6C9', '200': '#A5D6A7', '300': '#81C784', '400': '#66BB6A', '500': '#4CAF50',
54 | '600': '#43A047', '700': '#388E3C', '800': '#2E7D32', '900': '#1B5E20',
55 | 'A100': '#B9F6CA', 'A200': '#69F0AE', 'A400': '#00E676', 'A700': '#00C853'},
56 | 'LightGreen': {'50': '#F1F8E9', '100': '#DCEDC8', '200': '#C5E1A5', '300': '#AED581', '400': '#9CCC65',
57 | '500': '#8BC34A',
58 | '600': '#7CB342', '700': '#689F38', '800': '#558B2F', '900': '#33691E',
59 | 'A100': '#CCFF90', 'A200': '#B2FF59', 'A400': '#76FF03', 'A700': '#64DD17'},
60 | 'Lime': {'50': '#F9FBE7', '100': '#F0F4C3', '200': '#E6EE9C', '300': '#DCE775', '400': '#D4E157', '500': '#CDDC39',
61 | '600': '#C0CA33', '700': '#AFB42B', '800': '#9E9D24', '900': '#827717',
62 | 'A100': '#F4FF81', 'A200': '#EEFF41', 'A400': '#C6FF00', 'A700': '#AEEA00'},
63 | 'Yellow': {'50': '#FFFDE7', '100': '#FFF9C4', '200': '#FFF59D', '300': '#FFF176', '400': '#FFEE58',
64 | '500': '#FFEB3B',
65 | '600': '#FDD835', '700': '#FBC02D', '800': '#F9A825', '900': '#F57F17',
66 | 'A100': '#FFFF8D', 'A200': '#FFFF00', 'A400': '#FFEA00', 'A700': '#FFD600'},
67 | 'Amber': {'50': '#FFF8E1', '100': '#FFECB3', '200': '#FFE082', '300': '#FFD54F', '400': '#FFCA28', '500': '#FFC107',
68 | '600': '#FFB300', '700': '#FFA000', '800': '#FF8F00', '900': '#FF6F00',
69 | 'A100': '#FFE57F', 'A200': '#FFD740', 'A400': '#FFC400', 'A700': '#FFAB00'},
70 | 'Orange': {'50': '#FFF3E0', '100': '#FFE0B2', '200': '#FFCC80', '300': '#FFB74D', '400': '#FFA726',
71 | '500': '#FF9800',
72 | '600': '#FB8C00', '700': '#F57C00', '800': '#EF6C00', '900': '#E65100',
73 | 'A100': '#FFD180', 'A200': '#FFAB40', 'A400': '#FF9100', 'A700': '#FF6D00'},
74 | 'DeepOrange': {'50': '#FBE9E7', '100': '#FFCCBC', '200': '#FFAB91', '300': '#FF8A65', '400': '#FF7043',
75 | '500': '#FF5722',
76 | '600': '#F4511E', '700': '#E64A19', '800': '#D84315', '900': '#BF360C',
77 | 'A100': '#FF9E80', 'A200': '#FF6E40', 'A400': '#FF3D00', 'A700': '#DD2C00'},
78 | 'Brown': {'50': '#EFEBE9', '100': '#D7CCC8', '200': '#BCAAA4', '300': '#A1887F', '400': '#8D6E63', '500': '#795548',
79 | '600': '#6D4C41', '700': '#5D4037', '800': '#4E342E', '900': '#3E2723'},
80 | 'Gray': {'50': '#FAFAFA', '100': '#F5F5F5', '200': '#EEEEEE', '300': '#E0E0E0', '400': '#BDBDBD', '500': '#9E9E9E',
81 | '600': '#757575', '700': '#616161', '800': '#424242', '900': '#212121'},
82 | 'BlueGray': {'50': '#ECEFF1', '100': '#CFD8DC', '200': '#B0BEC5', '300': '#90A4AE', '400': '#78909C',
83 | '500': '#607D8B',
84 | '600': '#546E7A', '700': '#455A64', '800': '#37474F', '900': '#263238'}}
85 |
86 |
87 | class Shade:
88 | def __init__(self, name: str, shades: Dict):
89 | self.name = name.lower()
90 | self._shades: Dict = shades
91 |
92 | def __repr__(self):
93 | return f'Shade({",".join(self._shades.keys())})'
94 |
95 | def __hasattr__(self, name):
96 | name = name[5:]
97 | return name in self._shades
98 |
99 | def __getattr__(self, name):
100 | name = name[5:]
101 | if name in self._shades:
102 | return self._shades[name]
103 | else:
104 | return None
105 |
106 | @property
107 | def shades(self):
108 | return [f'Shade{shade}' for shade in self._shades.keys()]
109 |
110 | @property
111 | def colors(self):
112 | return [shade for shade in self._shades.values()]
113 |
114 |
115 | class Colors:
116 | def __init__(self):
117 | self._colors: Dict = {}
118 | self._pretty_names = []
119 | for name in _MATERIAL_COLORS:
120 | iname = name.lower()
121 | shade = Shade(iname, _MATERIAL_COLORS[name])
122 | self._colors[iname] = shade
123 | self._pretty_names.append(name)
124 |
125 | def __repr__(self):
126 | return f'Colors({",".join(self._colors.keys())})'
127 |
128 | def __hasattr__(self, name):
129 | name = name.lower()
130 | return name in self._colors
131 |
132 | def __getattr__(self, name):
133 | name = name.lower()
134 | if name in self._colors:
135 | return self._colors[name]
136 | else:
137 | return None
138 |
139 | @property
140 | def colors(self):
141 | return self._pretty_names
142 |
143 | def get_palette(self, color_name: str):
144 | color_name = color_name.lower()
145 | if color_name in self._colors.keys():
146 | shade = self._colors[color_name]
147 | return shade.colors
148 | else:
149 | raise ValueError(f"Color: {color_name} is not found")
150 |
151 |
152 | MATERIAL = Colors()
153 |
154 | if __name__ == "__main__":
155 | print(MATERIAL.colors)
156 | print(MATERIAL.Teal.shades)
157 | print(MATERIAL.Green.Shade100)
158 |
--------------------------------------------------------------------------------
/widgets.py:
--------------------------------------------------------------------------------
1 | # Copyright (C) 2021 Tim Lauridsen < tla[at]rasmil.dk >
2 | #
3 | # This program is free software; you can redistribute it and/or modify
4 | # it under the terms of the GNU General Public License as published by
5 | # the Free Software Foundation; either version 3 of the License, or
6 | # (at your option) any later version.
7 | #
8 | # This program is distributed in the hope that it will be useful,
9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 | # GNU General Public License for more details.
12 | #
13 | # You should have received a copy of the GNU General Public License
14 | # along with this program; if not, write to
15 | # the Free Software Foundation, Inc.,
16 | # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 | #
18 | """
19 | Misc classes to build Gtk4 Applications in python 3.9
20 |
21 | It takes some of the hassle away from building Gtk4 application in Python
22 | So you can create an cool application, without all the boilerplate code
23 |
24 | """
25 | import os.path
26 |
27 | from abc import abstractmethod
28 |
29 | import gi
30 |
31 | gi.require_version("Gtk", "4.0")
32 | from gi.repository import Gtk, Gio, GLib, Gdk
33 |
34 | from material import MATERIAL
35 |
36 |
37 | def rgb_to_hex(r, g, b):
38 | if isinstance(r, float):
39 | r *= 255
40 | g *= 255
41 | b *= 255
42 | return "#{0:02X}{1:02X}{2:02X}".format(int(r), int(g), int(b))
43 |
44 |
45 | def color_to_hex(color):
46 | return rgb_to_hex(color.red, color.green, color.blue)
47 |
48 |
49 | def get_font_markup(fontdesc, text):
50 | return f'{text}'
51 |
52 |
53 | class MaterialColorDialog(Gtk.ColorChooserDialog):
54 | """ Color chooser dialog with Material design colors """
55 |
56 | def __init__(self, title, parent):
57 | Gtk.ColorChooserDialog.__init__(self)
58 | self.set_title(title)
59 | self.set_transient_for(parent)
60 | self.set_modal(True)
61 | # build list of material colors in Gdk.RGBA format
62 | color_values = []
63 | for color_name in MATERIAL.colors:
64 | colors = MATERIAL.get_palette(color_name)
65 | for col in colors:
66 | color = Gdk.RGBA()
67 | color.parse(col)
68 | color_values.append(color)
69 | num_colors = 14
70 | self.add_palette(Gtk.Orientation.HORIZONTAL, num_colors, color_values)
71 | self.set_property('show-editor', False)
72 |
73 | def get_color(self):
74 | selected_color = self.get_rgba()
75 | return color_to_hex(selected_color)
76 |
77 |
78 | class ListViewBase(Gtk.ListView):
79 | """ ListView base class, it setup the basic factory, selection model & data model
80 | handlers must be overloaded & implemented in a sub class
81 | """
82 |
83 | def __init__(self, model_cls):
84 | Gtk.ListView.__init__(self)
85 | # Use the signal Factory, so we can connect our own methods to setup
86 | self.factory = Gtk.SignalListItemFactory()
87 | # connect to Gtk.SignalListItemFactory signals
88 | # check https://docs.gtk.org/gtk4/class.SignalListItemFactory.html for details
89 | self.factory.connect('setup', self.on_factory_setup)
90 | self.factory.connect('bind', self.on_factory_bind)
91 | self.factory.connect('unbind', self.on_factory_unbind)
92 | self.factory.connect('teardown', self.on_factory_teardown)
93 | # Create data model, use our own class as elements
94 | self.set_factory(self.factory)
95 | self.store = self.setup_store(model_cls)
96 | # create a selection model containing our data model
97 | self.model = self.setup_model(self.store)
98 | self.model.connect('selection-changed', self.on_selection_changed)
99 | # set the selection model to the view
100 | self.set_model(self.model)
101 |
102 | def setup_model(self, store: Gio.ListModel) -> Gtk.SelectionModel:
103 | """ Setup the selection model to use in Gtk.ListView
104 | Can be overloaded in subclass to use another Gtk.SelectModel model
105 | """
106 | return Gtk.SingleSelection.new(store)
107 |
108 | @abstractmethod
109 | def setup_store(self, model_cls) -> Gio.ListModel:
110 | """ Setup the data model
111 | must be overloaded in subclass to use another Gio.ListModel
112 | """
113 | raise NotImplemented
114 |
115 | def add(self, elem):
116 | """ add element to the data model """
117 | self.store.append(elem)
118 |
119 | # Gtk.SignalListItemFactory signal callbacks
120 | # transfer to some some callback stubs, there can be overloaded in
121 | # a subclass.
122 |
123 | def on_factory_setup(self, widget, item: Gtk.ListItem):
124 | """ GtkSignalListItemFactory::setup signal callback
125 |
126 | Setup the widgets to go into the ListView """
127 |
128 | self.factory_setup(widget, item)
129 |
130 | def on_factory_bind(self, widget: Gtk.ListView, item: Gtk.ListItem):
131 | """ GtkSignalListItemFactory::bind signal callback
132 |
133 | apply data from model to widgets set in setup"""
134 | self.factory_bind(widget, item)
135 |
136 | def on_factory_unbind(self, widget, item: Gtk.ListItem):
137 | """ GtkSignalListItemFactory::unbind signal callback
138 |
139 | Undo the the binding done in ::bind if needed
140 | """
141 | self.factory_unbind(widget, item)
142 |
143 | def on_factory_teardown(self, widget, item: Gtk.ListItem):
144 | """ GtkSignalListItemFactory::setup signal callback
145 |
146 | Undo the creation done in ::setup if needed
147 | """
148 | self.factory_teardown(widget, item)
149 |
150 | def on_selection_changed(self, widget, position, n_items):
151 | # get the current selection (GtkBitset)
152 | selection = widget.get_selection()
153 | # the the first value in the GtkBitset, that contain the index of the selection in the data model
154 | # as we use Gtk.SingleSelection, there can only be one ;-)
155 | ndx = selection.get_nth(0)
156 | self.selection_changed(widget, ndx)
157 |
158 | # --------------------> abstract callback methods <--------------------------------
159 | # Implement these methods in your subclass
160 |
161 | @abstractmethod
162 | def factory_setup(self, widget: Gtk.ListView, item: Gtk.ListItem):
163 | """ Setup the widgets to go into the ListView (Overload in subclass) """
164 | pass
165 |
166 | @abstractmethod
167 | def factory_bind(self, widget: Gtk.ListView, item: Gtk.ListItem):
168 | """ apply data from model to widgets set in setup (Overload in subclass)"""
169 | pass
170 |
171 | @abstractmethod
172 | def factory_unbind(self, widget: Gtk.ListView, item: Gtk.ListItem):
173 | pass
174 |
175 | @abstractmethod
176 | def factory_teardown(self, widget: Gtk.ListView, item: Gtk.ListItem):
177 | pass
178 |
179 | @abstractmethod
180 | def selection_changed(self, widget, ndx):
181 | """ trigged when selecting in listview is changed
182 | ndx: is the index in the data store model that is selected
183 | """
184 | pass
185 |
186 |
187 | class ListViewListStore(ListViewBase):
188 | """ ListView base with an Gio.ListStore as data model
189 | It can contain misc objects derived from GObject
190 | """
191 |
192 | def __init__(self, model_cls):
193 | super(ListViewListStore, self).__init__(model_cls)
194 |
195 | def setup_store(self, model_cls) -> Gio.ListModel:
196 | """ Setup the data model """
197 | return Gio.ListStore.new(model_cls)
198 |
199 |
200 | class ListViewStrings(ListViewBase):
201 | """ Add ListView with only strings """
202 |
203 | def __init__(self):
204 | super(ListViewStrings, self).__init__(Gtk.StringObject)
205 |
206 | def setup_store(self, model_cls) -> Gio.ListModel:
207 | """ Setup the data model
208 | Can be overloaded in subclass to use another Gio.ListModel
209 | """
210 | return Gtk.StringList()
211 |
212 |
213 | class SelectorBase(Gtk.ListBox):
214 | """ Selector base class """
215 |
216 | def __init__(self):
217 | Gtk.ListBox.__init__(self)
218 | # Setup the listbox
219 | self.set_selection_mode(Gtk.SelectionMode.SINGLE)
220 | self.connect('row-selected', self.on_row_changes)
221 | self._rows = {}
222 | self.ndx = 0
223 | self.callback = None
224 |
225 | def add_row(self, name, markup):
226 | """ Overload this in a subclass"""
227 | raise NotImplemented
228 |
229 | def on_row_changes(self, widget, row):
230 | ndx = row.get_index()
231 | if self.callback:
232 | self.callback(self._rows[ndx])
233 | else:
234 | print(f'Row Selected : {self._rows[ndx]}')
235 |
236 | def set_callback(self, callback):
237 | self.callback = callback
238 |
239 |
240 | class TextSelector(SelectorBase):
241 | """ Vertical Selector Widget that contains a number of strings where one can be selected """
242 |
243 | def add_row(self, name: str, markup: str):
244 | """ Add a named row to the selector with at given icon name"""
245 | # get the image
246 | label = Gtk.Label()
247 | label.set_markup(markup)
248 | # set the widget size request to 32x32 px, so we get some margins
249 | # label.set_size_request(100, 24)
250 | label.set_single_line_mode(True)
251 | label.set_halign(Gtk.Align.START)
252 | label.set_hexpand(True)
253 | label.set_xalign(0)
254 | label.set_margin_start(5)
255 | label.set_margin_end(10)
256 | row = self.append(label)
257 | # store the index names, so we can find it on selection
258 | self._rows[self.ndx] = name
259 | self.ndx += 1
260 |
261 |
262 | class IconSelector(SelectorBase):
263 | """ Vertical Selector Widget that contains a number of icons where one can be selected """
264 |
265 | def add_row(self, name, icon_name):
266 | """ Add a named row to the selector with at given icon name"""
267 | # get the image
268 | pix = Gtk.Image.new_from_icon_name(icon_name)
269 | # set the widget size request to 32x32 px, so we get some margins
270 | pix.set_size_request(32, 32)
271 | row = self.append(pix)
272 | # store the index names, so we can find it on selection
273 | self._rows[self.ndx] = name
274 | self.ndx += 1
275 |
276 |
277 | class ViewColumnBase(Gtk.ColumnViewColumn):
278 | """ ColumnViewColumn base class, it setup the basic factory, selection model & data model
279 | handlers must be overloaded & implemented in a sub class
280 | """
281 |
282 | def __init__(self, model_cls, col_view):
283 | Gtk.ColumnViewColumn.__init__(self)
284 | self.col_view = col_view
285 | # Use the signal Factory, so we can connect our own methods to setup
286 | self.factory = Gtk.SignalListItemFactory()
287 | # connect to Gtk.SignalListItemFactory signals
288 | # check https://docs.gtk.org/gtk4/class.SignalListItemFactory.html for details
289 | self.factory.connect('setup', self.on_factory_setup)
290 | self.factory.connect('bind', self.on_factory_bind)
291 | self.factory.connect('unbind', self.on_factory_unbind)
292 | self.factory.connect('teardown', self.on_factory_teardown)
293 | # Create data model, use our own class as elements
294 | self.set_factory(self.factory)
295 | self.store = self.setup_store(model_cls)
296 | # create a selection model containing our data model
297 | self.model = self.setup_model(self.store)
298 | self.model.connect('selection-changed', self.on_selection_changed)
299 | # add model to the ColumnView
300 | self.col_view.set_model(self.model)
301 |
302 | def setup_model(self, store: Gio.ListModel) -> Gtk.SelectionModel:
303 | """ Setup the selection model to use in Gtk.ListView
304 | Can be overloaded in subclass to use another Gtk.SelectModel model
305 | """
306 | return Gtk.SingleSelection.new(store)
307 |
308 | @abstractmethod
309 | def setup_store(self, model_cls) -> Gio.ListModel:
310 | """ Setup the data model
311 | must be overloaded in subclass to use another Gio.ListModel
312 | """
313 | raise NotImplemented
314 |
315 | def add(self, elem):
316 | """ add element to the data model """
317 | self.store.append(elem)
318 |
319 | # Gtk.SignalListItemFactory signal callbacks
320 | # transfer to some some callback stubs, there can be overloaded in
321 | # a subclass.
322 |
323 | def on_factory_setup(self, widget, item: Gtk.ListItem):
324 | """ GtkSignalListItemFactory::setup signal callback
325 |
326 | Setup the widgets to go into the ListView """
327 |
328 | self.factory_setup(widget, item)
329 |
330 | def on_factory_bind(self, widget: Gtk.ListView, item: Gtk.ListItem):
331 | """ GtkSignalListItemFactory::bind signal callback
332 |
333 | apply data from model to widgets set in setup"""
334 | self.factory_bind(widget, item)
335 |
336 | def on_factory_unbind(self, widget, item: Gtk.ListItem):
337 | """ GtkSignalListItemFactory::unbind signal callback
338 |
339 | Undo the the binding done in ::bind if needed
340 | """
341 | self.factory_unbind(widget, item)
342 |
343 | def on_factory_teardown(self, widget, item: Gtk.ListItem):
344 | """ GtkSignalListItemFactory::setup signal callback
345 |
346 | Undo the creation done in ::setup if needed
347 | """
348 | self.factory_teardown(widget, item)
349 |
350 | def on_selection_changed(self, widget, position, n_items):
351 | # get the current selection (GtkBitset)
352 | selection = widget.get_selection()
353 | # the the first value in the GtkBitset, that contain the index of the selection in the data model
354 | # as we use Gtk.SingleSelection, there can only be one ;-)
355 | ndx = selection.get_nth(0)
356 | self.selection_changed(widget, ndx)
357 |
358 | # --------------------> abstract callback methods <--------------------------------
359 | # Implement these methods in your subclass
360 |
361 | @abstractmethod
362 | def factory_setup(self, widget: Gtk.ColumnViewColumn, item: Gtk.ListItem):
363 | """ Setup the widgets to go into the ColumnViewColumn (Overload in subclass) """
364 | pass
365 |
366 | @abstractmethod
367 | def factory_bind(self, widget: Gtk.ColumnViewColumn, item: Gtk.ListItem):
368 | """ apply data from model to widgets set in setup (Overload in subclass)"""
369 | pass
370 |
371 | @abstractmethod
372 | def factory_unbind(self, widget: Gtk.ColumnViewColumn, item: Gtk.ListItem):
373 | pass
374 |
375 | @abstractmethod
376 | def factory_teardown(self, widget: Gtk.ColumnViewColumn, item: Gtk.ListItem):
377 | pass
378 |
379 | @abstractmethod
380 | def selection_changed(self, widget, ndx):
381 | """ trigged when selecting in listview is changed
382 | ndx: is the index in the data store model that is selected
383 | """
384 | pass
385 |
386 |
387 | class ColumnViewListStore(ViewColumnBase):
388 | """ ColumnViewColumn base with an Gio.ListStore as data model
389 | It can contain misc objects derived from GObject
390 | """
391 |
392 | def __init__(self, model_cls, col_view):
393 | super(ColumnViewListStore, self).__init__(model_cls, col_view)
394 |
395 | def setup_store(self, model_cls) -> Gio.ListModel:
396 | """ Setup the data model """
397 | return Gio.ListStore.new(model_cls)
398 |
399 |
400 | class SearchBar(Gtk.SearchBar):
401 | """ Wrapper for Gtk.Searchbar Gtk.SearchEntry"""
402 |
403 | def __init__(self, win=None):
404 | super(SearchBar, self).__init__()
405 | box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
406 | box.set_spacing(10)
407 | # Add SearchEntry
408 | self.entry = Gtk.SearchEntry()
409 | self.entry.set_hexpand(True)
410 | box.append(self.entry)
411 | # Add Search Options button (Menu content need to be added)
412 | btn = Gtk.MenuButton()
413 | btn.set_icon_name('preferences-other-symbolic')
414 | self.search_options = btn
415 | box.append(btn)
416 | self.set_child(box)
417 | # connect search entry to seach bar
418 | self.connect_entry(self.entry)
419 | if win:
420 | # set key capture from main window, it will show searchbar, when you start typing
421 | self.set_key_capture_widget(win)
422 | # show close button in search bar
423 | self.set_show_close_button(True)
424 | # Set search mode to off by default
425 | self.set_search_mode(False)
426 |
427 | def set_callback(self, callback):
428 | """ Connect the search entry activate to an callback handler"""
429 | self.entry.connect('activate', callback)
430 |
431 |
432 | class ButtonRow(Gtk.Box):
433 | """ Row of button"""
434 |
435 | def __init__(self, btn_list: list, callback):
436 | super(ButtonRow, self).__init__(orientation=Gtk.Orientation.HORIZONTAL)
437 | # self.set_halign(Gtk.Align.CENTER)
438 | self.set_margin_start(20)
439 | self.set_margin_top(20)
440 | self.set_spacing(10)
441 | for title in btn_list:
442 | btn = Gtk.Button()
443 | btn.set_label(f'{title}')
444 | btn.connect('clicked', callback)
445 | self.append(btn)
446 |
447 |
448 | class SwitchRow(Gtk.Box):
449 | def __init__(self, text):
450 | super(SwitchRow, self).__init__(orientation=Gtk.Orientation.HORIZONTAL)
451 | # Switch to control overlay visibility
452 | self.label = Gtk.Label.new(text)
453 | self.label.set_halign(Gtk.Align.FILL)
454 | self.label.set_valign(Gtk.Align.CENTER)
455 | self.label.set_hexpand(True)
456 | self.label.set_xalign(0.0)
457 | self.label.set_margin_start(20)
458 | self.label.set_margin_bottom(20)
459 | self.append(self.label)
460 | self.switch = Gtk.Switch()
461 | self.switch.set_halign(Gtk.Align.END)
462 | self.switch.set_margin_end(20)
463 | self.switch.set_margin_bottom(20)
464 | self.append(self.switch)
465 |
466 | def connect(self, signal, callback):
467 | self.switch.connect(signal, callback)
468 |
469 | def set_state(self, state):
470 | self.switch.set_state(state)
471 |
472 |
473 | class MenuButton(Gtk.MenuButton):
474 | """
475 | Wrapper class for at Gtk.Menubutton with a menu defined
476 | in a Gtk.Builder xml string
477 | """
478 |
479 | def __init__(self, xml, name, icon_name='open-menu-symbolic'):
480 | super(MenuButton, self).__init__()
481 | builder = Gtk.Builder()
482 | builder.add_from_string(xml)
483 | menu = builder.get_object(name)
484 | self.set_menu_model(menu)
485 | self.set_icon_name(icon_name)
486 |
487 |
488 | class Stack(Gtk.Stack):
489 | """ Wrapper for Gtk.Stack with with a StackSwitcher """
490 |
491 | def __init__(self):
492 | super(Stack, self).__init__()
493 | self.switcher = Gtk.StackSwitcher()
494 | self.switcher.set_stack(self)
495 | self._pages = {}
496 |
497 | def add_page(self, name, title, widget):
498 | page = self.add_child(widget)
499 | page.set_name(name)
500 | page.set_title(title)
501 | self._pages[name] = page
502 | return page
503 |
504 |
505 | class Window(Gtk.ApplicationWindow):
506 | """ custom Gtk.ApplicationWindow with a headerbar"""
507 |
508 | def __init__(self, title, width, height, **kwargs):
509 | super(Window, self).__init__(**kwargs)
510 | self.set_default_size(width, height)
511 | self.headerbar = Gtk.HeaderBar()
512 | self.set_titlebar(self.headerbar)
513 | label = Gtk.Label()
514 | label.set_text(title)
515 | self.headerbar.set_title_widget(label)
516 | # custom CSS provider
517 | self.css_provider = None
518 |
519 | def load_css(self, css_fn):
520 | """create a provider for custom styling"""
521 | if css_fn and os.path.exists(css_fn):
522 | css_provider = Gtk.CssProvider()
523 | try:
524 | css_provider.load_from_path(css_fn)
525 | except GLib.Error as e:
526 | print(f"Error loading CSS : {e} ")
527 | return None
528 | print(f'loading custom styling : {css_fn}')
529 | self.css_provider = css_provider
530 |
531 | def _add_widget_styling(self, widget):
532 | if self.css_provider:
533 | context = widget.get_style_context()
534 | context.add_provider(
535 | self.css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER)
536 |
537 | def add_custom_styling(self, widget):
538 | self._add_widget_styling(widget)
539 | # iterate children recursive
540 | for child in widget:
541 | self.add_custom_styling(child)
542 |
543 | def create_action(self, name, callback):
544 | """ Add an Action and connect to a callback """
545 | action = Gio.SimpleAction.new(name, None)
546 | action.connect("activate", callback)
547 | self.add_action(action)
548 |
--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------
1 | # Copyright (C) 2021 Tim Lauridsen < tla[at]rasmil.dk >
2 | #
3 | # This program is free software; you can redistribute it and/or modify
4 | # it under the terms of the GNU General Public License as published by
5 | # the Free Software Foundation; either version 3 of the License, or
6 | # (at your option) any later version.
7 | #
8 | # This program is distributed in the hope that it will be useful,
9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 | # GNU General Public License for more details.
12 | #
13 | # You should have received a copy of the GNU General Public License
14 | # along with this program; if not, write to
15 | # the Free Software Foundation, Inc.,
16 | # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 | #
18 |
19 | """
20 | Sample Python Gtk4 Application
21 | """
22 | import sys
23 | import time
24 | from typing import List
25 |
26 | import gi
27 |
28 | gi.require_version("Gtk", "4.0")
29 | gi.require_version('Polkit', '1.0')
30 |
31 | from gi.repository import Gtk, Polkit, GObject, Gio
32 | from widgets import Window, Stack, MenuButton, get_font_markup, SearchBar, \
33 | IconSelector, TextSelector, ListViewStrings, ListViewListStore, SwitchRow, ButtonRow, MaterialColorDialog, ColumnViewListStore
34 |
35 |
36 | def get_permision(action_id='org.freedesktop.accounts.user-administration'):
37 | """
38 | Get an GPermission object from PolKit to use with Gtk.LockButton
39 | @param action_id: is just an example there exist on at Fedora 34 workstation
40 | """
41 | prem = Polkit.Permission.new_sync(action_id, None, None)
42 | # print(prem.acquire())
43 | return prem
44 |
45 |
46 | # Gtk.Builder xml for the application menu
47 | APP_MENU = """
48 |
49 |
50 |
70 |
71 | """
72 |
73 |
74 | class ColumnElem(GObject.GObject):
75 | """ custom data element for a ColumnView model (Must be based on GObject) """
76 |
77 | def __init__(self, name: str):
78 | super(ColumnElem, self).__init__()
79 | self.name = name
80 |
81 | def __repr__(self):
82 | return f'ColumnElem(name: {self.name})'
83 |
84 |
85 | class ListElem(GObject.GObject):
86 | """ custom data element for a ListView model (Must be based on GObject) """
87 |
88 | def __init__(self, name: str, state: bool):
89 | super(ListElem, self).__init__()
90 | self.name = name
91 | self.state = state
92 |
93 | def __repr__(self):
94 | return f'ListElem(name: {self.name} state: {self.state})'
95 |
96 |
97 | class MyListViewStrings(ListViewStrings):
98 | """ Custom ListView """
99 |
100 | def __init__(self, win: Gtk.ApplicationWindow):
101 | # Init ListView with store model class.
102 | super(MyListViewStrings, self).__init__()
103 | self.win = win
104 | self.set_vexpand(True)
105 | # put some data into the model
106 | for i in range(1000):
107 | self.add(f'Item {i}')
108 |
109 | def factory_setup(self, widget: Gtk.ListView, item: Gtk.ListItem):
110 | """ Gtk.SignalListItemFactory::setup signal callback (overloaded from parent class)
111 |
112 | Handles the creation widgets to put in the ListView
113 | """
114 | label = Gtk.Label()
115 | label.set_halign(Gtk.Align.START)
116 | label.set_hexpand(True)
117 | label.set_margin_start(10)
118 | item.set_child(label)
119 |
120 | def factory_bind(self, widget: Gtk.ListView, item: Gtk.ListItem):
121 | """ Gtk.SignalListItemFactory::bind signal callback (overloaded from parent class)
122 |
123 | Handles adding data for the model to the widgets created in setup
124 | """
125 | # get the Gtk.Label
126 | label = item.get_child()
127 | # get the model item, connected to current ListItem
128 | data = item.get_item()
129 | # Update Gtk.Label with data from model item
130 | label.set_text(data.get_string())
131 | # Update Gtk.Switch with data from model item
132 | item.set_child(label)
133 |
134 | def selection_changed(self, widget, ndx: int):
135 | """ trigged when selecting in listview is changed"""
136 | markup = self.win._get_text_markup(
137 | f'Row {ndx} was selected ( {self.store[ndx].get_string()} )')
138 | self.win.page4_label.set_markup(markup)
139 |
140 |
141 | class MyListView(ListViewListStore):
142 | """ Custom ListView """
143 |
144 | def __init__(self, win: Gtk.ApplicationWindow):
145 | # Init ListView with store model class.
146 | super(MyListView, self).__init__(ListElem)
147 | self.win = win
148 | self.set_valign(Gtk.Align.FILL)
149 | # self.set_vexpand(True)
150 | # put some data into the model
151 | self.add(ListElem("One", True))
152 | self.add(ListElem("Two", False))
153 | self.add(ListElem("Three", True))
154 | self.add(ListElem("Four", False))
155 |
156 | def factory_setup(self, widget: Gtk.ListView, item: Gtk.ListItem):
157 | """ Gtk.SignalListItemFactory::setup signal callback (overloaded from parent class)
158 |
159 | Handles the creation widgets to put in the ListView
160 | """
161 | box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
162 | label = Gtk.Label()
163 | label.set_halign(Gtk.Align.START)
164 | label.set_hexpand(True)
165 | label.set_margin_start(10)
166 | switch = Gtk.Switch()
167 | switch.set_halign(Gtk.Align.END)
168 | switch.set_margin_end(10)
169 | box.append(label)
170 | box.append(switch)
171 | item.set_child(box)
172 |
173 | def factory_bind(self, widget: Gtk.ListView, item: Gtk.ListItem):
174 | """ Gtk.SignalListItemFactory::bind signal callback (overloaded from parent class)
175 |
176 | Handles adding data for the model to the widgets created in setup
177 | """
178 | # get the Gtk.Box stored in the ListItem
179 | box = item.get_child()
180 | # get the model item, connected to current ListItem
181 | data = item.get_item()
182 | # get the Gtk.Label (first item in box)
183 | label = box.get_first_child()
184 | # get the Gtk.Switch (next sibling to the Label)
185 | switch = label.get_next_sibling()
186 | # Update Gtk.Label with data from model item
187 | label.set_text(data.name)
188 | # Update Gtk.Switch with data from model item
189 | switch.set_state(data.state)
190 | # connect switch to handler, so we can handle changes
191 | switch.connect('state-set', self.switch_changed, item.get_position())
192 | item.set_child(box)
193 |
194 | def factory_unbind(self, widget: Gtk.ListView, item: Gtk.ListItem):
195 | """ Gtk.SignalListItemFactory::unbind signal callback (overloaded from parent class) """
196 | pass
197 |
198 | def factory_teardown(self, widget: Gtk.ListView, item: Gtk.ListItem):
199 | """ Gtk.SignalListItemFactory::teardown signal callback (overloaded from parent class """
200 | pass
201 |
202 | def selection_changed(self, widget, ndx: int):
203 | """ trigged when selecting in listview is changed"""
204 | markup = self.win._get_text_markup(
205 | f'Row {ndx} was selected ( {self.store[ndx]} )')
206 | self.win.page4_label.set_markup(markup)
207 |
208 | def switch_changed(self, widget, state: bool, pos: int):
209 | # update the data model, with current state
210 | elem = self.store[pos]
211 | elem.state = state
212 | markup = self.win._get_text_markup(
213 | f'switch in row {pos}, changed to {state}')
214 | self.win.page4_label.set_markup(markup)
215 |
216 |
217 | class MyColumnViewColumn (ColumnViewListStore):
218 | """ Custom ColumnViewColumn """
219 |
220 | def __init__(self, win: Gtk.ApplicationWindow, col_view: Gtk.ColumnView, data: List):
221 | # Init ListView with store model class.
222 | super(MyColumnViewColumn, self).__init__(ColumnElem, col_view)
223 | self.win = win
224 | # put some data into the model
225 | for elem in data:
226 | self.add(ColumnElem(elem))
227 |
228 | def factory_setup(self, widget, item: Gtk.ListItem):
229 | """ Gtk.SignalListItemFactory::setup signal callback
230 | Handles the creation widgets to put in the ColumnViewColumn
231 | """
232 | label = Gtk.Label()
233 | label.set_halign(Gtk.Align.START)
234 | label.set_hexpand(True)
235 | label.set_margin_start(10)
236 | item.set_child(label)
237 |
238 | def factory_bind(self, widget, item: Gtk.ListItem):
239 | """ Gtk.SignalListItemFactory::bind signal callback
240 | Handles adding data for the model to the widgets created in setup
241 | """
242 | label = item.get_child() # Get the Gtk.Label stored in the ListItem
243 | data = item.get_item() # get the model item, connected to current ListItem
244 | label.set_text(data.name) # Update Gtk.Label with data from model item
245 |
246 | def selection_changed(self, widget, ndx: int):
247 | """ trigged when selecting in listview is changed"""
248 | markup = self.win._get_text_markup(
249 | f'Row {ndx} was selected ( {self.store[ndx]} )')
250 | self.win.page4_label.set_markup(markup)
251 |
252 |
253 | class MyWindow(Window):
254 |
255 | def __init__(self, title, width, height, **kwargs):
256 | super(MyWindow, self).__init__(title, height, width, **kwargs)
257 | # load the custom css, so we can use it later
258 | self.load_css('main.css')
259 | self.revealer = None
260 | # Add Menu Button to the titlebar (Right Side)
261 | menu = MenuButton(APP_MENU, 'app-menu')
262 | self.headerbar.pack_end(menu)
263 | # Create actions to handle menu actions
264 | self.create_action('new', self.menu_handler)
265 | self.create_action('about', self.menu_handler)
266 | self.create_action('quit', self.menu_handler)
267 | self.create_action('shortcuts', self.menu_handler)
268 |
269 | # make a new title label and add it to the left.
270 | # So we kan place the stack switcher in the middle
271 | label = Gtk.Label()
272 | label.set_text(title)
273 | # add 2 chars indent on the label for better looks
274 | label.set_halign(Gtk.Align.END)
275 | label.set_width_chars(len(title) + 2)
276 | self.headerbar.pack_start(label)
277 | # Main content box
278 | content = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
279 | # Search Bar
280 | self.search = SearchBar(self)
281 | content.append(self.search)
282 | # search bar is active by default
283 | self.search.set_callback(self.on_search)
284 |
285 | # Stack
286 | self.stack = Stack()
287 |
288 | # Stack Page 1
289 | self.page1 = self.setup_page_one('page1', 'Page 1')
290 | # Stack Page 2
291 | self.page2 = self.setup_page_two('page2', 'Page 2')
292 | # Stack Page 3
293 | self.page3 = self.setup_page_three('page3', 'Page 3')
294 | # Stack Page 4
295 | self.page4 = self.setup_page_four('page4', 'Page 4')
296 | # Stack Page 5
297 | self.page5 = self.setup_page_five('page5', 'Page 5')
298 | # add stack switcher to center of titlebar
299 | self.headerbar.set_title_widget(self.stack.switcher)
300 | # Add stack to window
301 | content.append(self.stack)
302 | # Add main content box to window
303 | self.set_child(content)
304 |
305 | def setup_page_header(self, name, title):
306 | """ setup the common widgets for each page """
307 | # Content box for the page
308 | frame = Gtk.Frame()
309 | # Set Frame Margins
310 | frame.set_margin_top(15)
311 | frame.set_margin_start(15)
312 | frame.set_margin_end(15)
313 | frame.set_margin_bottom(15)
314 | # Content box for the page
315 | content = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
316 | # Add a label with custom font in the center
317 | label = Gtk.Label()
318 | label.set_margin_top(20)
319 | markup = get_font_markup('Noto Sans Regular 20', f'This is {title}')
320 | label.set_markup(markup)
321 | label.set_valign(Gtk.Align.CENTER)
322 | content.append(label)
323 | # Output label to write user action on the page
324 | label = Gtk.Label()
325 | label.set_margin_top(20)
326 | label.set_margin_start(20)
327 | label.set_hexpand(True)
328 | label.set_halign(Gtk.Align.CENTER)
329 | label.set_xalign(0.0)
330 | content.append(label)
331 | frame.set_child(content)
332 | return frame, content, label
333 |
334 | def setup_page_one(self, name, title):
335 | """ Add a page with a icon selector to the stack"""
336 | # Main Content box for the page
337 | main = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
338 | # Add info selector
339 | selector = IconSelector()
340 | selector.add_row("row1", "dialog-information-symbolic")
341 | selector.add_row("row2", "software-update-available-symbolic")
342 | selector.add_row("row3", "drive-multidisk-symbolic")
343 | selector.add_row("row4", "insert-object-symbolic")
344 | selector.set_callback(self.on_select_icon_selector)
345 | main.append(selector)
346 | page_frame, content_right, lbl = self.setup_page_header(name, title)
347 | self.page1_label = lbl
348 | # Lock button
349 | lock_btn = Gtk.LockButton.new(get_permision())
350 | lock_btn.set_margin_top(20)
351 | lock_btn.set_halign(Gtk.Align.CENTER)
352 | lock_btn.set_hexpand(False)
353 | content_right.append(lock_btn)
354 | # buttoms
355 | box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
356 | box.set_halign(Gtk.Align.CENTER)
357 | box.set_margin_top(20)
358 | box.set_spacing(10)
359 | for x in range(5):
360 | btn = Gtk.Button()
361 | btn.set_label(f'Button {x}')
362 | btn.connect('clicked', self.on_button_clicked)
363 | box.append(btn)
364 | content_right.append(box)
365 | # Entry
366 | entry = Gtk.Entry()
367 | entry.set_halign(Gtk.Align.FILL)
368 | entry.set_valign(Gtk.Align.END)
369 | entry.set_margin_top(20)
370 | entry.set_margin_start(20)
371 | entry.set_margin_end(20)
372 | entry.set_placeholder_text("Type something here ....")
373 | entry.connect('activate', self.on_entry_activate)
374 | content_right.append(entry)
375 | # Calendar
376 | calendar = Gtk.Calendar()
377 | calendar.set_margin_top(20)
378 | calendar.set_halign(Gtk.Align.CENTER)
379 | calendar.connect('day-selected', self.on_calendar_changed)
380 | content_right.append(calendar)
381 | # DropDown
382 | model = Gtk.StringList()
383 | for txt in ['One', 'Two', 'Three', 'Four']:
384 | model.append(txt)
385 | dropdown = Gtk.DropDown.new(model)
386 | dropdown.set_margin_top(20)
387 | dropdown.set_margin_start(20)
388 | dropdown.set_size_request(200, -1)
389 | dropdown.set_halign(Gtk.Align.START)
390 | content_right.append(dropdown)
391 | # DropDown
392 | dropdown = Gtk.DropDown.new_from_strings(
393 | ['Red', 'Green', 'Blue', 'Black', 'White'])
394 | dropdown.set_margin_top(20)
395 | dropdown.set_margin_start(20)
396 | dropdown.set_size_request(200, -1)
397 | dropdown.set_halign(Gtk.Align.START)
398 | content_right.append(dropdown)
399 | main.append(page_frame)
400 | # Add the content box as a new page in the stack
401 | return self.stack.add_page(name, title, main)
402 |
403 | def setup_page_two(self, name, title):
404 | """ Add a page with a text selector to the stack"""
405 | # Content box for the page
406 | main = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
407 | # Add info selector
408 | selector = TextSelector()
409 | selector.add_row("Orange", "Orange")
410 | selector.add_row("Apple", "Apple")
411 | selector.add_row("Water Melon", "Water Melon")
412 | selector.add_row("Lollypop", "Lollypop")
413 | selector.set_callback(self.on_select_text_selector)
414 | main.append(selector)
415 | # Add a label with custom font in the center
416 | frame, content_right, label = self.setup_page_header(name, title)
417 | self.page2_label = label
418 | # Overlay
419 | overlay_info = Gtk.InfoBar()
420 | overlay_info.set_halign(Gtk.Align.FILL)
421 | overlay_info.set_valign(Gtk.Align.START)
422 | overlay_info.set_margin_top(10)
423 | overlay_info.set_margin_start(10)
424 | overlay_info.set_margin_end(10)
425 | lbl = Gtk.Label()
426 | lbl.set_halign(Gtk.Align.FILL)
427 | lbl.set_valign(Gtk.Align.FILL)
428 | lbl.set_hexpand(True)
429 | lbl.set_vexpand(True)
430 | lbl.set_markup(
431 | 'This is an Gtk.Infobar as an overlay')
432 | overlay_info.add_child(lbl)
433 | self.overlay_info = overlay_info
434 | frame_child = Gtk.Frame()
435 | # TexkView
436 | sw = Gtk.ScrolledWindow()
437 | text = Gtk.TextView.new()
438 | text.set_vexpand(True)
439 | # Set Wrap Mode to word
440 | text.set_wrap_mode(Gtk.WrapMode.WORD)
441 | # Add some text
442 | txt = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras vitae leo ac magna lobortis maximus. ' \
443 | 'Etiam eleifend, libero a pulvinar ornare, justo nunc porta velit, ut sodales mi est feugiat tellus. '
444 | text.get_buffer().set_text(txt * 10)
445 | sw.set_child(text)
446 | frame_child.set_child(sw)
447 | overlay = Gtk.Overlay()
448 | overlay.set_margin_top(20)
449 | overlay.set_margin_start(20)
450 | overlay.set_margin_end(20)
451 | overlay.set_margin_bottom(20)
452 | overlay.set_child(frame_child)
453 | overlay.add_overlay(overlay_info)
454 | content_right.append(overlay)
455 | # Switch to control overlay visibility
456 | switch_row = SwitchRow("Show Overlay")
457 | switch_row.set_state(True)
458 | switch_row.connect('state-set', self.on_switch_overlay)
459 | content_right.append(switch_row)
460 | main.append(frame)
461 | # Add the content box as a new page in the stack
462 | return self.stack.add_page(name, title, main)
463 |
464 | def setup_page_three(self, name, title):
465 | """ Add a page with css styled content to the stack"""
466 | # Content box for the page
467 |
468 | frame = Gtk.Frame()
469 | # Set Frame Margins
470 | frame.set_margin_top(15)
471 | frame.set_margin_start(15)
472 | frame.set_margin_end(15)
473 | frame.set_margin_bottom(15)
474 |
475 | # Left/Right Paned
476 | # Orientation is the ways the separator is moving, not the way it is facing
477 | # So HORIZONTAL split in Left/Right and VERTICAL split in Top/Down
478 | self.left_right_paned = Gtk.Paned(
479 | orientation=Gtk.Orientation.HORIZONTAL)
480 | # Left Side
481 | left_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
482 | left_box.set_vexpand(True)
483 | left_box.set_spacing(5)
484 | left_label = Gtk.Label.new("LEFT")
485 | left_label.set_valign(Gtk.Align.START)
486 | left_label.set_halign(Gtk.Align.START)
487 | left_box.append(left_label)
488 | # Add Progress Bar
489 | progress = Gtk.ProgressBar()
490 | progress.set_fraction(.75)
491 | left_box.append(progress)
492 | # Add Scale
493 | scale = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL, 0, 100, 5)
494 | scale.set_value(25)
495 | left_box.append(scale)
496 | # sepatator
497 | separator = Gtk.Separator(orientation=Gtk.Orientation.HORIZONTAL)
498 | left_box.append(separator)
499 | self.left_right_paned.set_start_child(left_box)
500 | self.left_right_paned.set_shrink_start_child(False) # Can't shrink
501 | # Right Side
502 | right_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
503 | right_label = Gtk.Label.new("RIGHT")
504 | right_label.set_valign(Gtk.Align.START)
505 | right_label.set_halign(Gtk.Align.START)
506 | right_box.append(right_label)
507 | # TexkView
508 | text = Gtk.TextView.new()
509 | # Set the default width
510 | text.set_size_request(150, -1)
511 | # Set Wrap Mode to word
512 | text.set_wrap_mode(Gtk.WrapMode.WORD)
513 | # Add some text
514 | txt = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras vitae leo ac magna lobortis maximus. ' \
515 | 'Etiam eleifend, libero a pulvinar ornare, justo nunc porta velit, ut sodales mi est feugiat tellus. '
516 | text.get_buffer().set_text(txt)
517 | right_box.append(text)
518 | # Add Switches
519 | for txt in ['Reveal', 'Yet Another Option']:
520 | grid = Gtk.Grid()
521 | grid.set_column_spacing(30)
522 | grid.insert_row(0)
523 | grid.insert_column(0)
524 | grid.insert_column(1)
525 | grid.insert_column(2)
526 | grid.set_row_homogeneous(True)
527 | label = Gtk.Label.new(txt)
528 | label.set_hexpand(True)
529 | label.set_xalign(0.0)
530 | label.set_valign(Gtk.Align.CENTER)
531 | switch = Gtk.Switch()
532 | if txt == "Reveal":
533 | switch.connect('state-set', self.on_switch_activate)
534 | switch.set_state(True)
535 | grid.attach(label, 0, 1, 2, 1)
536 | grid.attach(switch, 2, 1, 1, 1)
537 | right_box.append(grid)
538 | # Some bottoms
539 | lock_btn = Gtk.LockButton.new()
540 | right_box.append(lock_btn)
541 | # Add the box to paned
542 | self.left_right_paned.set_end_child(right_box)
543 | self.left_right_paned.set_shrink_end_child(False) # Can't shrink
544 | # Top/Down Paned
545 | self.top_botton_paned = Gtk.Paned(orientation=Gtk.Orientation.VERTICAL)
546 | # Top
547 | self.top_botton_paned.set_start_child(self.left_right_paned)
548 | self.top_botton_paned.set_shrink_start_child(False)
549 | # Bottom
550 | self.bottom_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
551 | self.bottom_box.set_vexpand(False)
552 | # Add a label with custom font in the center
553 | label = Gtk.Label()
554 | markup = get_font_markup(
555 | 'Noto Sans Regular 24', f'This page is styled using main.css')
556 | label.set_markup(markup)
557 | # fill the whole page, will make the Label centered.
558 | label.set_halign(Gtk.Align.CENTER)
559 | label.set_vexpand(False)
560 | self.bottom_box.append(label)
561 | label = Gtk.Label()
562 | markup = get_font_markup(
563 | 'Noto Sans Regular 18', f'UGLY AS HELL, but shows how it is working')
564 | label.set_markup(markup)
565 | # fill the whole page, will make the Label centered.
566 | label.set_halign(Gtk.Align.CENTER)
567 | label.set_vexpand(False)
568 | self.bottom_box.append(label)
569 | # Revealer
570 | self.revealer = Gtk.Revealer()
571 | self.revealer.set_valign(Gtk.Align.END)
572 | box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
573 | label = Gtk.Label.new("This is a revlealer")
574 | box.append(label)
575 | self.revealer.set_child(box)
576 | self.revealer.set_transition_type(Gtk.RevealerTransitionType.CROSSFADE)
577 | self.revealer.set_transition_duration(200)
578 | self.revealer.set_reveal_child(True)
579 | self.bottom_box.append(self.revealer)
580 | self.top_botton_paned.set_end_child(self.bottom_box)
581 | self.top_botton_paned.set_shrink_end_child(False) # Can't shrink
582 | frame.set_child(self.top_botton_paned)
583 | self.page3_label = label
584 | # add custom styling to widgets
585 | self.add_custom_styling(frame)
586 | # Add the content box as a new page in the stack
587 | return self.stack.add_page(name, title, frame)
588 |
589 | def setup_page_four(self, name, title):
590 | """ Add a page with a text selector to the stack"""
591 | # Content box for the page
592 | frame, content, label = self.setup_page_header(name, title)
593 | self.page4_label = label
594 |
595 | # ColumnView with custom columns
596 | self.columnview = Gtk.ColumnView()
597 | self.columnview.set_show_column_separators(True)
598 | data = [f'Data Row: {row}' for row in range(50)]
599 | for i in range(4):
600 | column = MyColumnViewColumn(self, self.columnview, data)
601 | column.set_title(f"Column {i}")
602 | self.columnview.append_column(column)
603 | lw_frame = Gtk.Frame()
604 | lw_frame.set_valign(Gtk.Align.FILL)
605 | lw_frame.set_vexpand(True)
606 | lw_frame.set_margin_start(20)
607 | lw_frame.set_margin_end(20)
608 | lw_frame.set_margin_top(10)
609 | lw_frame.set_margin_bottom(10)
610 | sw = Gtk.ScrolledWindow()
611 | sw.set_child(self.columnview)
612 | lw_frame.set_child(sw)
613 | content.append(lw_frame)
614 |
615 | # Listview with switches
616 | self.listview = MyListView(self)
617 | lw_frame = Gtk.Frame()
618 | lw_frame.set_valign(Gtk.Align.FILL)
619 | lw_frame.set_vexpand(True)
620 | lw_frame.set_margin_start(20)
621 | lw_frame.set_margin_end(20)
622 | # lw_frame.set_margin_top(10)
623 | lw_frame.set_margin_bottom(10)
624 | sw = Gtk.ScrolledWindow()
625 | sw.set_child(self.listview)
626 | lw_frame.set_child(sw)
627 | content.append(lw_frame)
628 | # Simple Listview with strings
629 | self.listview_str = MyListViewStrings(self)
630 | lw_frame = Gtk.Frame()
631 | lw_frame.set_valign(Gtk.Align.FILL)
632 | lw_frame.set_vexpand(True)
633 | lw_frame.set_margin_start(20)
634 | lw_frame.set_margin_end(20)
635 | # lw_frame.set_margin_top(10)
636 | lw_frame.set_margin_bottom(10)
637 | sw = Gtk.ScrolledWindow()
638 | # Create Gtk.Listview
639 | lw = self.listview_str
640 | sw.set_child(lw)
641 | lw_frame.set_child(sw)
642 | content.append(lw_frame)
643 | frame.set_child(content)
644 | # Add the content box as a new page in the stack
645 | return self.stack.add_page(name, title, frame)
646 |
647 | def setup_page_five(self, name, title):
648 | """ Add a new page to the stack"""
649 | # Content box for the page
650 | frame, content, label = self.setup_page_header(name, title)
651 | self.page5_label = label
652 | # Material Color button
653 | btn_row = ButtonRow(["Material Color"], self.on_button_chooser)
654 | content.append(btn_row)
655 | # Add the content box as a new page in the stack
656 | return self.stack.add_page(name, title, frame)
657 |
658 | def _get_text_markup(self, txt):
659 | txt = f'{txt}'
660 | markup = get_font_markup('Noto Sans Regular 14', txt)
661 | return markup
662 |
663 | def show_shortcuts(self):
664 | builder = Gtk.Builder.new_from_file('shortcuts.ui')
665 | shortcuts = builder.get_object('shortcuts')
666 | shortcuts.present()
667 |
668 | # ---------------------- Handlers --------------------------
669 |
670 | def menu_handler(self, action, state):
671 | """ Callback for menu actions"""
672 | name = action.get_name()
673 | print(f'active : {name}')
674 | if name == 'quit':
675 | self.close()
676 | elif name == 'shortcuts':
677 | self.show_shortcuts()
678 |
679 | def on_color_selected(self, widget):
680 | selected_color = self.chooser.get_rgba()
681 | color_txt = selected_color.to_string()
682 | markup = self._get_text_markup(
683 | f'{widget.get_label()} was pressed. {color_txt}')
684 | self.page5_label.set_markup(markup)
685 |
686 | def on_button_chooser(self, widget):
687 | """ callback for buttom clicked (Page1) """
688 | dialog = MaterialColorDialog("Select Color", self)
689 | dialog.connect('response', self.on_dialog_response)
690 | dialog.show()
691 |
692 | def on_search(self, widget):
693 | """ callback for the searchbar entry """
694 | print(f'Searching for : {widget.get_text()}')
695 |
696 | def on_select_icon_selector(self, name):
697 | """ called when icon_selector selection is changed (Page1) """
698 | markup = self._get_text_markup(f'{name} is selected')
699 | self.page1_label.set_markup(markup)
700 |
701 | def on_select_text_selector(self, name):
702 | """ called when text_selector is changed (Page2) """
703 | markup = self._get_text_markup(f'{name} is selected')
704 | self.page2_label.set_markup(markup)
705 |
706 | def on_switch_activate(self, widget, state):
707 | """ callback for reveal switch (Page3) """
708 | if self.revealer:
709 | self.revealer.set_reveal_child(state)
710 | time.sleep(.5)
711 | self.top_botton_paned.set_position(1000)
712 |
713 | def on_switch_overlay(self, widget, state):
714 | """ callback for overlay switch (Page2) """
715 | if self.overlay_info:
716 | self.overlay_info.set_revealed(state)
717 |
718 | def on_button_clicked(self, widget):
719 | """ callback for buttom clicked (Page1) """
720 | markup = self._get_text_markup(f'{widget.get_label()} was pressed')
721 | self.page1_label.set_markup(markup)
722 |
723 | def on_calendar_changed(self, widget):
724 | """ callback for calendar selection (Page1) """
725 | date = widget.get_date().format('%F')
726 | txt = f'{date} was selected in calendar'
727 | markup = self._get_text_markup(txt)
728 | self.page1_label.set_markup(markup)
729 |
730 | def on_entry_activate(self, widget):
731 | """ callback for entry actication (Page1) """
732 | txt = f'{widget.get_buffer().get_text()} was typed in entry'
733 | markup = self._get_text_markup(txt)
734 | self.page1_label.set_markup(markup)
735 |
736 | def on_dialog_response(self, widget, response_id):
737 | if response_id == Gtk.ResponseType.OK:
738 | # get selected color in hex format
739 | color = widget.get_color()
740 | markup = f'the color {color} was selected'
741 | self.page5_label.set_markup(markup)
742 | elif response_id == Gtk.ResponseType.CANCEL:
743 | print("cancel")
744 | # if the messagedialog is destroyed (by pressing ESC)
745 | elif response_id == Gtk.ResponseType.DELETE_EVENT:
746 | print("dialog closed or cancelled")
747 | widget.destroy()
748 |
749 |
750 | class Application(Gtk.Application):
751 | """ Main Aplication class """
752 |
753 | def __init__(self):
754 | super().__init__(application_id='dk.rasmil.Example',
755 | flags=Gio.ApplicationFlags.FLAGS_NONE)
756 |
757 | def do_activate(self):
758 | win = self.props.active_window
759 | if not win:
760 | win = MyWindow("My Gtk4 Application", 800, 800, application=self)
761 | win.present()
762 |
763 |
764 | def main():
765 | """ Run the main application"""
766 | app = Application()
767 | return app.run(sys.argv)
768 |
769 |
770 | if __name__ == '__main__':
771 | main()
772 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.
5 | Everyone is permitted to copy and distribute verbatim copies
6 | of this license document, but changing it is not allowed.
7 |
8 | Preamble
9 |
10 | The GNU General Public License is a free, copyleft license for
11 | software and other kinds of works.
12 |
13 | The licenses for most software and other practical works are designed
14 | to take away your freedom to share and change the works. By contrast,
15 | the GNU General Public License is intended to guarantee your freedom to
16 | share and change all versions of a program--to make sure it remains free
17 | software for all its users. We, the Free Software Foundation, use the
18 | GNU General Public License for most of our software; it applies also to
19 | any other work released this way by its authors. You can apply it to
20 | your programs, too.
21 |
22 | When we speak of free software, we are referring to freedom, not
23 | price. Our General Public Licenses are designed to make sure that you
24 | have the freedom to distribute copies of free software (and charge for
25 | them if you wish), that you receive source code or can get it if you
26 | want it, that you can change the software or use pieces of it in new
27 | free programs, and that you know you can do these things.
28 |
29 | To protect your rights, we need to prevent others from denying you
30 | these rights or asking you to surrender the rights. Therefore, you have
31 | certain responsibilities if you distribute copies of the software, or if
32 | you modify it: responsibilities to respect the freedom of others.
33 |
34 | For example, if you distribute copies of such a program, whether
35 | gratis or for a fee, you must pass on to the recipients the same
36 | freedoms that you received. You must make sure that they, too, receive
37 | or can get the source code. And you must show them these terms so they
38 | know their rights.
39 |
40 | Developers that use the GNU GPL protect your rights with two steps:
41 | (1) assert copyright on the software, and (2) offer you this License
42 | giving you legal permission to copy, distribute and/or modify it.
43 |
44 | For the developers' and authors' protection, the GPL clearly explains
45 | that there is no warranty for this free software. For both users' and
46 | authors' sake, the GPL requires that modified versions be marked as
47 | changed, so that their problems will not be attributed erroneously to
48 | authors of previous versions.
49 |
50 | Some devices are designed to deny users access to install or run
51 | modified versions of the software inside them, although the manufacturer
52 | can do so. This is fundamentally incompatible with the aim of
53 | protecting users' freedom to change the software. The systematic
54 | pattern of such abuse occurs in the area of products for individuals to
55 | use, which is precisely where it is most unacceptable. Therefore, we
56 | have designed this version of the GPL to prohibit the practice for those
57 | products. If such problems arise substantially in other domains, we
58 | stand ready to extend this provision to those domains in future versions
59 | of the GPL, as needed to protect the freedom of users.
60 |
61 | Finally, every program is threatened constantly by software patents.
62 | States should not allow patents to restrict development and use of
63 | software on general-purpose computers, but in those that do, we wish to
64 | avoid the special danger that patents applied to a free program could
65 | make it effectively proprietary. To prevent this, the GPL assures that
66 | patents cannot be used to render the program non-free.
67 |
68 | The precise terms and conditions for copying, distribution and
69 | modification follow.
70 |
71 | TERMS AND CONDITIONS
72 |
73 | 0. Definitions.
74 |
75 | "This License" refers to version 3 of the GNU General Public License.
76 |
77 | "Copyright" also means copyright-like laws that apply to other kinds of
78 | works, such as semiconductor masks.
79 |
80 | "The Program" refers to any copyrightable work licensed under this
81 | License. Each licensee is addressed as "you". "Licensees" and
82 | "recipients" may be individuals or organizations.
83 |
84 | To "modify" a work means to copy from or adapt all or part of the work
85 | in a fashion requiring copyright permission, other than the making of an
86 | exact copy. The resulting work is called a "modified version" of the
87 | earlier work or a work "based on" the earlier work.
88 |
89 | A "covered work" means either the unmodified Program or a work based
90 | on the Program.
91 |
92 | To "propagate" a work means to do anything with it that, without
93 | permission, would make you directly or secondarily liable for
94 | infringement under applicable copyright law, except executing it on a
95 | computer or modifying a private copy. Propagation includes copying,
96 | distribution (with or without modification), making available to the
97 | public, and in some countries other activities as well.
98 |
99 | To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies. Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 |
103 | An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License. If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 |
112 | 1. Source Code.
113 |
114 | The "source code" for a work means the preferred form of the work
115 | for making modifications to it. "Object code" means any non-source
116 | form of a work.
117 |
118 | A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 |
123 | The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form. A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 |
134 | The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities. However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work. For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 |
147 | The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 |
151 | The Corresponding Source for a work in source code form is that
152 | same work.
153 |
154 | 2. Basic Permissions.
155 |
156 | All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met. This License explicitly affirms your unlimited
159 | permission to run the unmodified Program. The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work. This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 |
164 | You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force. You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright. Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 |
175 | Conveying under any other circumstances is permitted solely under
176 | the conditions stated below. Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 |
179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 |
181 | No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 |
187 | When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 |
195 | 4. Conveying Verbatim Copies.
196 |
197 | You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 |
205 | You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 |
208 | 5. Conveying Modified Source Versions.
209 |
210 | You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 |
214 | a) The work must carry prominent notices stating that you modified
215 | it, and giving a relevant date.
216 |
217 | b) The work must carry prominent notices stating that it is
218 | released under this License and any conditions added under section
219 | 7. This requirement modifies the requirement in section 4 to
220 | "keep intact all notices".
221 |
222 | c) You must license the entire work, as a whole, under this
223 | License to anyone who comes into possession of a copy. This
224 | License will therefore apply, along with any applicable section 7
225 | additional terms, to the whole of the work, and all its parts,
226 | regardless of how they are packaged. This License gives no
227 | permission to license the work in any other way, but it does not
228 | invalidate such permission if you have separately received it.
229 |
230 | d) If the work has interactive user interfaces, each must display
231 | Appropriate Legal Notices; however, if the Program has interactive
232 | interfaces that do not display Appropriate Legal Notices, your
233 | work need not make them do so.
234 |
235 | A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit. Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 |
245 | 6. Conveying Non-Source Forms.
246 |
247 | You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 |
252 | a) Convey the object code in, or embodied in, a physical product
253 | (including a physical distribution medium), accompanied by the
254 | Corresponding Source fixed on a durable physical medium
255 | customarily used for software interchange.
256 |
257 | b) Convey the object code in, or embodied in, a physical product
258 | (including a physical distribution medium), accompanied by a
259 | written offer, valid for at least three years and valid for as
260 | long as you offer spare parts or customer support for that product
261 | model, to give anyone who possesses the object code either (1) a
262 | copy of the Corresponding Source for all the software in the
263 | product that is covered by this License, on a durable physical
264 | medium customarily used for software interchange, for a price no
265 | more than your reasonable cost of physically performing this
266 | conveying of source, or (2) access to copy the
267 | Corresponding Source from a network server at no charge.
268 |
269 | c) Convey individual copies of the object code with a copy of the
270 | written offer to provide the Corresponding Source. This
271 | alternative is allowed only occasionally and noncommercially, and
272 | only if you received the object code with such an offer, in accord
273 | with subsection 6b.
274 |
275 | d) Convey the object code by offering access from a designated
276 | place (gratis or for a charge), and offer equivalent access to the
277 | Corresponding Source in the same way through the same place at no
278 | further charge. You need not require recipients to copy the
279 | Corresponding Source along with the object code. If the place to
280 | copy the object code is a network server, the Corresponding Source
281 | may be on a different server (operated by you or a third party)
282 | that supports equivalent copying facilities, provided you maintain
283 | clear directions next to the object code saying where to find the
284 | Corresponding Source. Regardless of what server hosts the
285 | Corresponding Source, you remain obligated to ensure that it is
286 | available for as long as needed to satisfy these requirements.
287 |
288 | e) Convey the object code using peer-to-peer transmission, provided
289 | you inform other peers where the object code and Corresponding
290 | Source of the work are being offered to the general public at no
291 | charge under subsection 6d.
292 |
293 | A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 |
297 | A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling. In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage. For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product. A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 |
310 | "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source. The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 |
318 | If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information. But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 |
329 | The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed. Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 |
337 | Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 |
343 | 7. Additional Terms.
344 |
345 | "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law. If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 |
354 | When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it. (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.) You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 |
361 | Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 |
365 | a) Disclaiming warranty or limiting liability differently from the
366 | terms of sections 15 and 16 of this License; or
367 |
368 | b) Requiring preservation of specified reasonable legal notices or
369 | author attributions in that material or in the Appropriate Legal
370 | Notices displayed by works containing it; or
371 |
372 | c) Prohibiting misrepresentation of the origin of that material, or
373 | requiring that modified versions of such material be marked in
374 | reasonable ways as different from the original version; or
375 |
376 | d) Limiting the use for publicity purposes of names of licensors or
377 | authors of the material; or
378 |
379 | e) Declining to grant rights under trademark law for use of some
380 | trade names, trademarks, or service marks; or
381 |
382 | f) Requiring indemnification of licensors and authors of that
383 | material by anyone who conveys the material (or modified versions of
384 | it) with contractual assumptions of liability to the recipient, for
385 | any liability that these contractual assumptions directly impose on
386 | those licensors and authors.
387 |
388 | All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10. If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term. If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 |
398 | If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 |
403 | Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 |
407 | 8. Termination.
408 |
409 | You may not propagate or modify a covered work except as expressly
410 | provided under this License. Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 |
415 | However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 |
422 | Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 |
429 | Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License. If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 |
435 | 9. Acceptance Not Required for Having Copies.
436 |
437 | You are not required to accept this License in order to receive or
438 | run a copy of the Program. Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance. However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work. These actions infringe copyright if you do
443 | not accept this License. Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 |
446 | 10. Automatic Licensing of Downstream Recipients.
447 |
448 | Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License. You are not responsible
451 | for enforcing compliance by third parties with this License.
452 |
453 | An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations. If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 |
463 | You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License. For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 |
471 | 11. Patents.
472 |
473 | A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based. The
475 | work thus licensed is called the contributor's "contributor version".
476 |
477 | A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version. For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 |
487 | Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 |
492 | In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement). To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 |
499 | If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients. "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 |
513 | If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 |
521 | A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License. You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 |
536 | Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 |
540 | 12. No Surrender of Others' Freedom.
541 |
542 | If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License. If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all. For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 |
552 | 13. Use with the GNU Affero General Public License.
553 |
554 | Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work. The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 |
563 | 14. Revised Versions of this License.
564 |
565 | The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time. Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 |
570 | Each version is given a distinguishing version number. If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation. If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 |
579 | If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 |
584 | Later license versions may give you additional or different
585 | permissions. However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 |
589 | 15. Disclaimer of Warranty.
590 |
591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 |
600 | 16. Limitation of Liability.
601 |
602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 |
612 | 17. Interpretation of Sections 15 and 16.
613 |
614 | If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 |
621 | END OF TERMS AND CONDITIONS
622 |
623 | How to Apply These Terms to Your New Programs
624 |
625 | If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 |
629 | To do so, attach the following notices to the program. It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 |
634 |
635 | Copyright (C)
636 |
637 | This program is free software: you can redistribute it and/or modify
638 | it under the terms of the GNU General Public License as published by
639 | the Free Software Foundation, either version 3 of the License, or
640 | (at your option) any later version.
641 |
642 | This program is distributed in the hope that it will be useful,
643 | but WITHOUT ANY WARRANTY; without even the implied warranty of
644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
645 | GNU General Public License for more details.
646 |
647 | You should have received a copy of the GNU General Public License
648 | along with this program. If not, see .
649 |
650 | Also add information on how to contact you by electronic and paper mail.
651 |
652 | If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 |
655 | Copyright (C)
656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 | This is free software, and you are welcome to redistribute it
658 | under certain conditions; type `show c' for details.
659 |
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License. Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 |
664 | You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | .
668 |
669 | The GNU General Public License does not permit incorporating your program
670 | into proprietary programs. If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library. If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License. But first, please read
674 | .
675 |
--------------------------------------------------------------------------------