GUI: Factor out Paned size tracking into reusable baseclass

1 files changed, 141 insertions, 73 deletions

diff --git a/GstInspector/GUI/window.py b/GstInspector/GUI/window.py
index 9b1954b..b406e2f 100644
--- a/GstInspector/GUI/window.py
+++ b/GstInspector/GUI/window.py
@@ -33,109 +33,88 @@ from GstInspector.GUI.filters import FilterManager, UIFilterNone
 from GstInspector.GUI.pages import PageManager
 from GstInspector.GUI.utils import widget_add_popup_menu
 
-class WindowState (object):
+class PanedState (object):
 
     def __init__ (self):
 
-        self.logger = logging.getLogger ("ui.window-state")
+        self.logger = logging.getLogger ("ui.paned-state")
 
-        self.notebook_size_allocate_id = None
+        self.horizontal = None
+        self.child_size_allocate_id = None
 
         self.paned_size = 0
         self.target_child_size = None
-        self.is_maximized = False
 
-    def attach (self, inspector_window):
+    def attach (self, paned, child):
 
-        widgets = inspector_window.widgets
+        self.paned = paned
+        self.child = child
 
-        self.app = inspector_window.app
-        self.paned = widgets.main_hpaned
-        self.notebook = widgets.element_info_book
-        self.window = widgets.inspector_window
+        if isinstance (paned, gtk.HPaned):
+            self.horizontal = True
+        else:
+            self.horizontal = False
 
-        if not self.app.state.info_pane_size:
-            label = gtk.Label ("Description: This string should have a good size")
-            size = label.size_request ()[0]
-            self.app.state.info_pane_size = size
+        self.paned.connect ("size-allocate",
+                            self.__handle_paned_size_allocate)
 
-        self.window.connect ("window-state-event",
-                             self.handle_window_state_event)
+    def detach (self):
 
-        self.paned.connect ("size-allocate",
-                            self.handle_paned_size_allocate)
+        if self.child_size_allocate_id is not None:
+            self.child.disconnect (self.child_size_allocate_id)
+            self.child_size_allocate_id = None
+        self.child = None
 
-        geometry = self.app.state.geometry
-        if geometry:
-            self.window.move (*geometry[:2])
-            self.window.set_default_size (*geometry[2:])
+        self.paned.disconnect_by_func (self.__handle_paned_size_allocate)
+        self.paned = None
 
-        if self.app.state.maximized:
-            self.logger.debug ("initially maximized")
-            self.window.maximize ()
+        self.horizontal = None
 
-    def detach (self):
+    def get_child_size (self):
 
-        window = self.window
+        raise NotImplementedError ()
 
-        self.app.state.maximized = self.is_maximized
-        if not self.is_maximized:
-            position = tuple (window.get_position ())
-            size = tuple (window.get_size ())
-            self.app.state.geometry = position + size
+    def set_child_size (self, size):
 
-        if self.notebook_size_allocate_id is not None:
-            self.notebook.disconnect (self.notebook_size_allocate_id)
-            self.notebook_size_allocate_id = None
-        self.notebook = None
+        pass
 
-        self.paned.disconnect_by_func (self.handle_paned_size_allocate)
-        self.paned = None
+    def __handle_child_size_allocate (self, widget, allocation):
 
-        self.window.disconnect_by_func (self.handle_window_state_event)
-        self.window = None
+        if self.horizontal:
+            size = allocation.width
+        else:
+            size = allocation.height
 
-    def handle_notebook_size_allocate (self, widget, allocation):
+        self.set_child_size (size)
 
-        if self.app.state.info_pane_size != allocation.width:
-            self.logger.debug ("notebook size changed to %i", allocation.width)
-            self.app.state.info_pane_size = allocation.width
+    def __handle_paned_size_allocate (self, widget, allocation):
 
-    def handle_paned_size_allocate (self, widget, allocation):
+        if self.horizontal:
+            size = allocation.width
+        else:
+            size = allocation.height
 
-        if self.paned_size == allocation.width:
+        if self.paned_size == size:
             return
 
-        self.paned_size = allocation.width
+        self.paned_size = size
 
-        if self.notebook_size_allocate_id is None:
-            child_size = self.app.state.info_pane_size
+        if self.child_size_allocate_id is None:
+            child_size = self.get_child_size ()
             if child_size:
-                self.set_info_pane_size (child_size)
+                self.set_size (child_size)
 
-            handler_id = self.notebook.connect ("size-allocate",
-                                                self.handle_notebook_size_allocate)
-            self.notebook_size_allocate_id = handler_id
-            self.logger.debug ("now listening for notebook size allocation changes")
+            handler_id = self.child.connect ("size-allocate",
+                                             self.__handle_child_size_allocate)
+            self.child_size_allocate_id = handler_id
+            self.logger.debug ("now listening for child size allocation changes")
 
         if self.target_child_size is not None:
-            self.set_info_pane_size (self.target_child_size)
-
-    def handle_window_state_event (self, window, event):
-
-        if not event.changed_mask & gtk.gdk.WINDOW_STATE_MAXIMIZED:
-            return
-
-        if event.new_window_state & gtk.gdk.WINDOW_STATE_MAXIMIZED:
-            self.logger.debug ("maximized")
-            self.is_maximized = True
-        else:
-            self.logger.debug ("unmaximized")
-            self.is_maximized = False
+            self.set_size (self.target_child_size)
 
-    def set_info_pane_size (self, size):
+    def set_size (self, size):
 
-        # For saving and restoring the info notebook size (and therefore the
+        # For saving and restoring the child widget's size (and therefore the
         # paned's handle position), we cannot just save and restore
         # paned.props.position.  Doing this breaks for maximized windows as
         # they seem to undergo a maximized-unmaximized-maximized cycle on
@@ -143,15 +122,15 @@ class WindowState (object):
         # between the maximized width and the default width.
 
         paned_children = self.paned.get_children ()
-        if not self.notebook in paned_children:
+        if not self.child in paned_children:
             return
         # The 'position' property of gtk.HPaned equals the width of the first
         # child.
-        if self.paned.get_child1 () == self.notebook:
-            # Notebook on the left.
+        if self.paned.get_child1 () == self.child:
+            # Child on the left/top.
             target_position = size
         else:
-            # Notebook on the right.
+            # Child on the right/bottom.
             border = self.paned.props.border_width
             handle = self.paned.style_get_property ("handle-size")
             target_position = self.paned_size - 2 * border - handle - size
@@ -168,6 +147,95 @@ class WindowState (object):
             self.logger.debug ("set paned position to %i (for size %i)",
                                target_position, size)
 
+class InfoPanedState (PanedState):
+
+    def attach (self, inspector_window):
+
+        self.app = inspector_window.app
+
+        if not self.app.state.info_pane_size:
+            label = gtk.Label ("Description: This string should have a good size")
+            size = label.size_request ()[0]
+            self.app.state.info_pane_size = size
+
+        widgets = inspector_window.widgets
+        PanedState.attach (self, widgets.main_hpaned, widgets.element_info_book)
+
+    def detach (self):
+
+        PanedState.detach (self)
+
+        self.app = None
+
+    def get_child_size (self):
+
+        return self.app.state.info_pane_size
+
+    def set_child_size (self, size):
+
+        if self.app.state.info_pane_size != size:
+            self.logger.debug ("child size changed to %i", size)
+            self.app.state.info_pane_size = size
+
+class WindowState (object):
+
+    def __init__ (self):
+
+        self.logger = logging.getLogger ("ui.window-state")
+
+        self.info_paned_state = InfoPanedState ()
+        self.is_maximized = False
+
+    def attach (self, inspector_window):
+
+        widgets = inspector_window.widgets
+
+        self.app = inspector_window.app
+        self.window = widgets.inspector_window
+
+        self.info_paned_state.attach (inspector_window)
+
+        self.window.connect ("window-state-event",
+                             self.handle_window_state_event)
+
+        geometry = self.app.state.geometry
+        if geometry:
+            self.window.move (*geometry[:2])
+            self.window.set_default_size (*geometry[2:])
+
+        if self.app.state.maximized:
+            self.logger.debug ("initially maximized")
+            self.window.maximize ()
+
+    def detach (self):
+
+        window = self.window
+
+        self.app.state.maximized = self.is_maximized
+        if not self.is_maximized:
+            position = tuple (window.get_position ())
+            size = tuple (window.get_size ())
+            self.app.state.geometry = position + size
+
+        self.window.disconnect_by_func (self.handle_window_state_event)
+        self.window = None
+
+    def handle_window_state_event (self, window, event):
+
+        if not event.changed_mask & gtk.gdk.WINDOW_STATE_MAXIMIZED:
+            return
+
+        if event.new_window_state & gtk.gdk.WINDOW_STATE_MAXIMIZED:
+            self.logger.debug ("maximized")
+            self.is_maximized = True
+        else:
+            self.logger.debug ("unmaximized")
+            self.is_maximized = False
+
+    def set_info_pane_size (self, size):
+
+        self.info_paned_state.set_size (size)
+
 class InspectorWindow (Data.Consumer):
 
     def _get_active (self):