gtk-stream 0.9__tar.gz → 0.11__tar.gz

{gtk_stream-0.9 → gtk_stream-0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gtk-stream
-Version: 0.9
+Version: 0.11
 Summary: A simple stream-oriented GUI protocol
 Author-email: Marc Coiffier <marc.coiffier@univ-grenoble-alpes.fr>
 Project-URL: Homepage, https://coiffier.net/projects/gtk-stream/

{gtk_stream-0.9 → gtk_stream-0.11}/gtk_stream/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.9'
-__version_tuple__ = version_tuple = (0, 9)
+__version__ = version = '0.11'
+__version_tuple__ = version_tuple = (0, 11)

gtk_stream-0.11/gtk_stream/application.py

@@ -0,0 +1,140 @@
+# Gtk-Stream : A stream-based GUI protocol
+# Copyright (C) 2024  Marc Coiffier
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import sys
+from . import Gtk, GLib, Gdk
+from .common import printEvent
+from .properties import parse_property, get_prop_type, set_parse_prop
+
+class _Object:
+    pass
+
+def app_message(name, store = None):
+    """A decorator for methods that are both called from the pilot
+    application and need access to the gtk main thread"""
+    def app_message_f(f):
+        def ret(self, *args, **kwargs):
+            def cb():
+                f(self, *args, **kwargs)
+            self.run_when_idle(cb)
+        ret.__tag_name__ = name
+        ret.__store__ = store
+        return ret
+    return app_message_f
+
+def single_store():
+    store = _Object()
+    def setChild(child):
+        store.child = child
+    return (lambda: store.child, setChild, None)
+def multiple_store():
+    children = []
+    return (lambda: children, children.append, None)
+def style_store():
+    style = []
+    return (lambda: " ".join(style),None, style.append)
+
+class GtkStreamApp(Gtk.Application):
+    def __init__(self, logger, name = None, **kwargs):
+        super().__init__(**kwargs)
+        self.logger = logger
+        if name != None:
+            GLib.set_application_name(name)
+        self.namedWidgets = { }
+        self.namedWindows = { }
+        
+        # The first messages from the pilot may arrive before the
+        # application is ready to process them.
+        # 
+        # If that happens, store the actions until they can be taken
+        # (when the "startup" signal is called)
+        callback_queue = []
+        def run_when_idle_before_startup(cb):
+            callback_queue.append(cb)
+        self.run_when_idle = run_when_idle_before_startup
+        
+        def on_startup(_):
+            for cb in callback_queue:
+                GLib.idle_add(cb)
+            self.run_when_idle = GLib.idle_add
+        self.connect('startup', on_startup)
+        
+    def nameWidget(self, id, w):
+        if id is not None:
+            self.namedWidgets[id] = w
+
+    @app_message('file-dialog')
+    def openFileDialog(self, id, parent):
+        dialog = Gtk.FileDialog()
+        dialog.props.modal = True
+        def on_choose(_, b):
+            try:
+                file = dialog.open_finish(b)
+                print(f"{id}:selected:{file.get_path()}")
+                sys.stdout.flush()
+            except GLib.GError as e:
+                print(f"{id}:none-selected")
+                sys.stdout.flush()
+                
+        dialog.open(parent = self.namedWindows[parent], callback = on_choose)
+
+    @app_message('window', single_store)
+    def newWindow(self, document, id, **attrs):
+        win = Gtk.Window(application=self)
+        for (attr_name, attr_val) in attrs.items():
+            set_parse_prop(self, win, attr_name, attr_val)
+        self.namedWindows[id] = win
+        win.set_child(document.render())
+        win.connect('close-request', printEvent(self.logger, 'close-request', id))
+        win.present()
+
+    @app_message('style', style_store)
+    def addStyle(self, style):
+        provider = Gtk.CssProvider()
+        provider.load_from_data(style)
+        Gtk.StyleContext.add_provider_for_display(Gdk.Display.get_default(), provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
+
+    @app_message('add-icon-path')
+    def addIconPath(self, path):
+        theme = Gtk.IconTheme.get_for_display(Gdk.Display.get_default())
+        theme.add_search_path(path)
+        
+    @app_message('close-window')
+    def closeWindow(self, id):
+        self.namedWindows[id].close()
+
+    @app_message('remove')
+    def removeWidget(self, id):
+        w = self.namedWidgets[id]
+        w.get_parent().remove(w)
+
+    @app_message('insert', multiple_store)
+    def insertWidgets(self, documents, into):
+        for doc in documents:
+            self.insertWidget(doc, into)
+
+    def insertWidget(self, document, into):
+        if into in self.namedWidgets:
+            w = self.namedWidgets[into]
+            w.insert_child(document)
+        else:
+            raise Exception(f"Error: unknown widget id '{into}'")
+    
+    @app_message('set-prop')
+    def setProp(self, id, name, value):
+        w = self.namedWidgets[id]
+        w.set_property(name, parse_property(get_prop_type(w.__class__, name), value)(self))
+

{gtk_stream-0.9 → gtk_stream-0.11}/gtk_stream/documents/__init__.py

@@ -6,6 +6,7 @@ from .classes.ProgressBar    import ProgressBar
 from .classes.Separator      import Separator
 
 from .classes.Button         import Button, LinkButton
+from .classes.Scale          import Scale
 from .classes.Dropdown       import Dropdown, Item
 from .classes.Switch         import Switch
 from .classes.Entry          import Entry

{gtk_stream-0.9 → gtk_stream-0.11}/gtk_stream/documents/classes/Button.py

@@ -15,7 +15,6 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 from ... import Gtk
-from ...common import printEvent
 from .. import Document
 
 class Button(Document):
@@ -24,7 +23,7 @@ class Button(Document):
         super().__init__(app, id = id, **kwargs)
     def render_raw(self):
         button = Gtk.Button()
-        button.connect('clicked', printEvent(self.app.logger, 'clicked', self.id))
+        self.connect_event(button, 'clicked', 'clicked')
         return button
     def insert_child(self, w, d):
         w.set_child(d.render())
@@ -35,7 +34,9 @@ class LinkButton(Button):
         super().__init__(app, id=id, **kwargs)
     def render_raw(self):
         button = Gtk.LinkButton()
-        button.connect('activate-link', printEvent(self.app.logger, 'clicked', self.id, True))
+        self.connect_event(
+            button, 'activate-link', 'clicked',
+            retval = True)
         return button
     def insert_child(self, w, d):
         w.set_child(d.render())

{gtk_stream-0.9 → gtk_stream-0.11}/gtk_stream/documents/classes/Document.py

@@ -15,15 +15,21 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 from ...properties import parse_property, get_prop_type
+from ...common import printEvent
 
 class Document:
     __g_class__ = None
     def __init__(self, app, id = None, **attrs):
         self.id = id
         self.app = app
-        self.props = { attr: parse_property(get_prop_type(self.__g_class__, attr), val) for (attr, val) in attrs.items() }
+        self.props = {
+            attr: parse_property(get_prop_type(self.__g_class__, attr), val)
+            for (attr, val) in attrs.items()
+        }
         self.children = []
 
+    def connect_event(self, w, event, name, **printEvent_kwargs):
+        w.connect(event, printEvent(self.app.logger, name, self.id, **printEvent_kwargs))
     def add_child(self, child):
         self.children.append(child)
         

{gtk_stream-0.9 → gtk_stream-0.11}/gtk_stream/documents/classes/Dropdown.py

@@ -16,7 +16,6 @@
 
 from ... import Gtk, Gio, GObject
 from .. import Document
-from ...common import printEvent
 
 class Item(Document):
     def __init__(self, app, value, **kwargs):
@@ -57,9 +56,14 @@ class Dropdown(Document):
         factory.connect("setup", on_list_setup)
         factory.connect("bind", on_list_bind)
 
-        ret = Gtk.DropDown(model=model, expression=Gtk.PropertyExpression.new(_ItemObject, None, 'item_value'), factory=factory)
+        ret = Gtk.DropDown(
+            model=model,
+            expression=Gtk.PropertyExpression.new(_ItemObject, None, 'item_value'),
+            factory=factory)
         
-        ret.connect('notify::selected-item', printEvent(self.app.logger, 'selected', self.id, get_data = lambda w,_: w.get_selected_item().value))
+        self.connect_event(
+            ret, 'notify::selected-item', 'selected',
+            get_data = lambda w,_: w.get_selected_item().value)
         return ret
     def insert_child(self, w, d):
         pass

{gtk_stream-0.9 → gtk_stream-0.11}/gtk_stream/documents/classes/Entry.py

@@ -15,7 +15,6 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 from ... import Gtk
-from ...common import printEvent
 from .. import Document
 
 class Entry(Document):
@@ -24,5 +23,8 @@ class Entry(Document):
         super().__init__(app, id = id, **kwargs)
     def render_raw(self):
         entry = Gtk.Entry()
-        entry.connect('changed', printEvent(self.app.logger, 'changed', self.id, get_data = lambda _: entry.get_text()))
+        self.connect_event(
+            entry, 'changed', 'changed',
+            get_data = lambda _: entry.get_text()
+        )
         return entry

gtk_stream-0.11/gtk_stream/documents/classes/Scale.py

@@ -0,0 +1,30 @@
+# Gtk-Stream : A stream-based GUI protocol
+# Copyright (C) 2024  Marc Coiffier
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from ... import Gtk
+from .. import Document
+
+class Scale(Document):
+    __g_class__ = Gtk.Scale
+    def __init__(self, app, id, **kwargs):
+        super().__init__(app, id = id, **kwargs)
+    def render_raw(self):
+        scale = Gtk.Scale()
+        self.connect_event(
+            scale, 'value-changed', 'changed',
+            get_data = lambda _: str(scale.get_value())
+        )
+        return scale

{gtk_stream-0.9 → gtk_stream-0.11}/gtk_stream/documents/classes/Switch.py

@@ -15,7 +15,6 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 from ... import Gtk
-from ...common import printEvent
 from .. import Document
 from ...properties import parse_property
 
@@ -26,7 +25,8 @@ class Switch(Document):
         self.managed = parse_property('gboolean', managed)(app)
     def render_raw(self):
         ret = Gtk.Switch()
-        ret.connect('state-set', printEvent(self.app.logger, 'switch', self.id,
-                                            retval = self.managed,
-                                            get_data = lambda _,state: "on" if state else "off"))
+        self.connect_event(
+            ret, 'state-set', 'switch', 
+            retval   = self.managed,
+            get_data = lambda _,state: "on" if state else "off")
         return ret

{gtk_stream-0.9 → gtk_stream-0.11}/gtk_stream/parser.py

@@ -14,6 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+import functools
 import threading
 import signal
 import sys
@@ -24,9 +25,6 @@ from . import documents as docs
 
 from .application import GtkStreamApp
 
-class _Object:
-    pass
-   
 WIDGET_DOCUMENTS = {
     'progress-bar'    : docs.ProgressBar,
     'label'           : docs.Label,
@@ -49,7 +47,9 @@ WIDGET_DOCUMENTS = {
     'stack'           : docs.Stack,
     'flow-box'        : docs.FlowBox,
     'flow-box-prepend': docs.FlowBoxPrepend,
-    'entry'           : docs.Entry
+    'entry'           : docs.Entry,
+    'scale'           : docs.Scale
+    
 }
 
 class GtkStreamXMLHandler(sax.ContentHandler):
@@ -109,83 +109,48 @@ class GtkStreamXMLHandler(sax.ContentHandler):
                     self.quit_application()
                 signal.signal(signal.SIGINT, on_sigint)
 
+                # Get all messages directly from the application
+                # class. This allows defining new messages without
+                # touching the parser
+                self.messages = {
+                    f.__tag_name__: self.startMessage(functools.partial(f,self.app), f.__store__)
+                    for f in GtkStreamApp.__dict__.values()
+                    if hasattr(f, '__tag_name__')
+                }
+                self.logger.debug("Messages: %s", self.messages)
+
                 self.transition_enter = self.transE_message
                 self.transition_leave = self.transL_tag('application', self.transE_final, self.transL_final)
             case _:
                 raise Exception("Error: expected 'application' tag")
-    def transE_message(self, name, attrs):
-        leave_parent = self.transition_leave
-        match name:
-            case 'style':
-                style = _Object()
-                style.chars = []
-                def onchars(s):
-                    style.chars.append(s)
-                def leave():
-                    self.transition_chars = self.ignore_chars
-                    self.app.addStyle(" ".join(style.chars))
-                self.transition_chars = onchars
-                self.transition_enter = self.transE_final
-                self.transition_leave = self.transL_tag('style', self.transE_message, leave_parent, leave)
-                
-            case 'window':
-                if 'id' in attrs:
-                    store = _Object()
-                    def leave():
-                        self.app.newWindow(store.child, **attrs)
-                    def setChild(c):
-                        store.child = c
-                    self.transition_enter = self.transE_addChild(setChild)
-                    self.transition_leave = self.transL_tag('window', self.transE_message, leave_parent, leave)
-                else:
-                    raise Exception("Error: expected attribute 'id' in 'window' tag")
-                
-            case 'file-dialog':
-                id = attrs.get('id')
-                parent = attrs.get('parent')
-                if id != None and parent != None:
-                    self.app.openFileDialog(id, parent)
-                    self.transition_enter = self.transE_final
-                    self.transition_leave = self.transL_tag('file-dialog', self.transE_message, leave_parent)
-                else:
-                    raise Exception("Error: expected 'id' and 'parent' attributes on 'file-chooser'")
-
-            case 'close-window':
-                if 'id' in attrs:
-                    def leave():
-                        self.app.closeWindow(attrs['id'])
-                    self.transition_enter = self.transE_final
-                    self.transition_leave = self.transL_tag('close-window', self.transE_message, leave_parent, leave)
-                else:
-                    raise Exception("Error: expected 'id' attribute in 'close-window' tag")
 
-            case 'set-prop':
-                self.app.setProp(**attrs)
+    def startMessage(self, f, child = None):
+        if child != None:
+            def ret(name,attrs):
+                getC, setC, setChars = child()
+                old_chars = self.transition_chars
+                def leave():
+                    if setChars != None:
+                        self.transition_chars = old_chars
+                    f(getC(),**attrs)
+                if setChars != None:
+                    self.transition_chars = setChars
+                self.transition_enter = self.transE_addChild(setC)
+                self.transition_leave = self.transL_tag(name, self.transE_message, self.transition_leave, leave)
+        else:
+            def ret(name, attrs):
+                def leave():
+                    f(**attrs)
                 self.transition_enter = self.transE_final
-                self.transition_leave = self.transL_tag('set-prop', self.transE_message, leave_parent)
-                
-            case 'insert':
-                if 'into' in attrs:
-                    children = []
-                    def leave():
-                        for child in children:
-                            self.app.insertWidget(attrs['into'], child)
-                    self.transition_enter = self.transE_addChild(lambda child: children.append(child))
-                    self.transition_leave = self.transL_tag('insert', self.transE_message, leave_parent, leave)
-                else:
-                    raise Exception("Expected 'to' attribute of 'append' message")
-
-            case 'remove':
-                if 'id' in attrs:
-                    def leave():
-                        self.app.removeWidget(attrs['id'])
-                    self.transition_enter = self.transE_final
-                    self.transition_leave = self.transL_tag('remove', self.transE_message, leave_parent, leave)
-                else:
-                    raise Exception("Expected 'id' attribute of 'remove' message")
+                self.transition_leave = self.transL_tag(name, self.transE_message, self.transition_leave, leave)
+        return ret
 
-            case _:
-                raise Exception(f"Error: unknown message '{name}'")
+    def transE_message(self, name, attrs):
+        start = self.messages.get(name)
+        if start != None:
+            start(name,attrs)
+        else:
+            raise Exception(f"Error: unknown message '{name}'")
 
     def transE_addChild(self, addChild):
         def ret(name, attrs):
@@ -197,7 +162,7 @@ class GtkStreamXMLHandler(sax.ContentHandler):
                 self.transition_enter = self.transE_addChild(lambda child: doc.add_child(child))
                 self.transition_leave = self.transL_tag(name, self.transE_addChild(addChild), leave_parent)
             else:
-                raise Exception(f"Error: Unknown widget {name}")
+                raise Exception(f"Error: Unknown widget type '{name}'")
         return ret
 
     def characters(self, s):

{gtk_stream-0.9 → gtk_stream-0.11}/gtk_stream/properties.py

@@ -36,6 +36,17 @@ def _parse_searchMode_property(val):
             return _const(Gtk.StringFilterMatchMode.SUBSTRING)
         case _:
             return _const(Gtk.StringFilterMatchMode.PREFIX)
+def _parse_adjustment_property(val):
+    adj = Gtk.Adjustment()
+    start, end, *rest = val.split(':')
+    adj.set_lower(int(start))
+    adj.set_upper(int(end))
+    if len(rest) > 0:
+        default = rest[0]
+    else:
+        default = start
+    adj.set_value(int(default))
+    return _const(adj)
 def _parse_css_classes_property(val):
     return _const(val.split())
 def _parse_widget_property(val):
@@ -50,6 +61,7 @@ _PARSE_TYPE_PROPERTY = {
     'gboolean'                 : _parse_boolean_property,
     'GtkStringFilterMatchMode' : _parse_searchMode_property,
     'GtkWidget'                : _parse_widget_property,
+    'GtkAdjustment'            : _parse_adjustment_property,
     'gchararray'               : _const,
 }
 
@@ -57,4 +69,9 @@ def parse_property(prop_type, val):
     # print(f"Parsing property '{val}' of type '{prop_type}'", file=sys.stderr)
     return _PARSE_TYPE_PROPERTY[prop_type](val)
 def get_prop_type(klass, prop):
-    return klass.find_property(prop).value_type.name
+    try:
+        return klass.find_property(prop).value_type.name
+    except AttributeError:
+        raise Exception(f"Unknown GTK property '{prop}' of class '{klass}'")
+def set_parse_prop(app, w, prop_name, val):
+    w.set_property(prop_name, parse_property(get_prop_type(w.__class__, prop_name), val)(app))

{gtk_stream-0.9 → gtk_stream-0.11}/gtk_stream.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gtk-stream
-Version: 0.9
+Version: 0.11
 Summary: A simple stream-oriented GUI protocol
 Author-email: Marc Coiffier <marc.coiffier@univ-grenoble-alpes.fr>
 Project-URL: Homepage, https://coiffier.net/projects/gtk-stream/

{gtk_stream-0.9 → gtk_stream-0.11}/gtk_stream.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ gtk_stream/documents/classes/Label.py
 gtk_stream/documents/classes/Paned.py
 gtk_stream/documents/classes/Picture.py
 gtk_stream/documents/classes/ProgressBar.py
+gtk_stream/documents/classes/Scale.py
 gtk_stream/documents/classes/ScrolledWindow.py
 gtk_stream/documents/classes/Separator.py
 gtk_stream/documents/classes/Stack.py

gtk_stream-0.9/gtk_stream/application.py

@@ -1,101 +0,0 @@
-# Gtk-Stream : A stream-based GUI protocol
-# Copyright (C) 2024  Marc Coiffier
-# 
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-# 
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-import sys
-from . import Gtk, GLib, Gdk
-from .common import printEvent
-from .properties import parse_property, get_prop_type
-
-class GtkStreamApp(Gtk.Application):
-    def __init__(self, logger, name = None, **kwargs):
-        super().__init__(**kwargs)
-        self.logger = logger
-        if name != None:
-            GLib.set_application_name(name)
-        self.namedWidgets = { }
-        self.namedWindows = { }
-        
-        self.callback_queue = []
-
-        def run_when_idle_before_startup(cb):
-            self.callback_queue.append(cb)
-        self.run_when_idle = run_when_idle_before_startup
-        
-        def on_startup(_):
-            for cb in self.callback_queue:
-                GLib.idle_add(cb)
-            self.run_when_idle = GLib.idle_add
-        self.connect('startup', on_startup)
-        
-    def nameWidget(self, id, w):
-        if id is not None:
-            self.namedWidgets[id] = w
-
-    def openFileDialog(self, id, parent):
-        def cb():
-            dialog = Gtk.FileDialog()
-            dialog.props.modal = True
-            def on_choose(_, b):
-                try:
-                    file = dialog.open_finish(b)
-                    print(f"{id}:selected:{file.get_path()}")
-                    sys.stdout.flush()
-                except GLib.GError as e:
-                    print(f"{id}:none-selected")
-                    sys.stdout.flush()
-                    
-            dialog.open(parent = self.namedWindows[parent], callback = on_choose)
-        self.run_when_idle(cb)
-    def newWindow(self, document, id, title = "Window", width = None, height = None):
-        def cb():
-            win = Gtk.Window(application=self)
-            win.set_title(title)
-            if width != None and height != None:
-                win.set_default_size(int(width), int(height))
-            self.namedWindows[id] = win
-            win.set_child(document.render())
-            win.connect('close-request', printEvent(self.logger, 'close-request', id))
-            win.present()
-            return False
-        self.run_when_idle(cb)
-    def addStyle(self, style):
-        def cb():
-            provider = Gtk.CssProvider()
-            provider.load_from_data(style)
-            Gtk.StyleContext.add_provider_for_display(Gdk.Display.get_default(), provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
-        self.run_when_idle(cb)
-    def closeWindow(self, id):
-        def cb():
-            self.namedWindows[id].close()
-        self.run_when_idle(cb)
-    def removeWidget(self, id):
-        def cb():
-            w = self.namedWidgets[id]
-            w.get_parent().remove(w)
-        self.run_when_idle(cb)
-    def insertWidget(self, to, document):
-        def cb():
-            if to in self.namedWidgets:
-                w = self.namedWidgets[to]
-                w.insert_child(document)
-            else:
-                raise Exception(f"Error: unknown widget id '{to}'")
-        self.run_when_idle(cb)
-    def setProp(self, id, name, value):
-        def cb():
-            w = self.namedWidgets[id]
-            w.set_property(name, parse_property(get_prop_type(w.__class__, name), value)(self))
-        self.run_when_idle(cb)