Changeset 3268

Timestamp:

07/31/08 15:40:50 (5 years ago)

Author:

nopper

Message:

New expander implementation (pure python)

Location:

branch/PacketManipulator/widgets

Files:

• Expander.py (modified) (7 diffs)
• PropertyGrid.py (modified) (4 diffs)

branch/PacketManipulator/widgets/Expander.py

@@ -19 +19 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
+
 import gtk
 import gobject
 
+from gtk import gdk
 from higwidgets.higbuttons import HIGArrowButton
+
+#
+# Reimplementation of gtk.Layout in python
+# Example on how to implement a scrollable container in python
+#
+# Johan Dahlin <johan@gnome.org>, 2006
+#
+# Readaption for implementing show/hide animation and only one child by
+# Francesco Piccinno <stack.box@gmail.com>, 2008
+#
+# Requires PyGTK 2.8.0 or later
+
+class Child:
+    widget = None
+    x = 0
+    y = 0
+
+def set_adjustment_upper(adj, upper, always_emit):
+    changed = False
+    value_changed = False
+
+    min = max(0.0, upper - adj.page_size)
+
+    if upper != adj.upper:
+        adj.upper = upper
+        changed = True
+
+    if adj.value > min:
+        adj.value = min
+        value_changed = True
+
+    if changed or always_emit:
+        adj.changed()
+    if value_changed:
+        adj.value_changed()
+
+def new_adj():
+    return gtk.Adjustment(0.0, 0.0, 0.0,
+                          0.0, 0.0, 0.0)
+
+class Layout(gtk.Container):
+    __gsignals__ = {
+        'animation-end' : (gobject.SIGNAL_RUN_LAST, None, (gobject.TYPE_BOOLEAN, )),
+        'set_scroll_adjustments' : (gobject.SIGNAL_RUN_LAST, None,
+                                   (gtk.Adjustment, gtk.Adjustment))
+    }
+
+    def __init__(self):
+        self._child = None
+        self._width = 100
+        self._height = 100
+        self._hadj = None
+        self._vadj = None
+        self._bin_window = None
+        self._hadj_changed_id = -1
+        self._vadj_changed_id = -1
+
+        self._animating = False
+        self._to_show = True
+
+        self._current = 0
+        self._dest = 0
+        self._speed = 5
+
+        self._time_int = 10
+        self._time_tot = 300
+
+        gtk.Container.__init__(self)
+
+        if not self._hadj or not self._vadj:
+            self._set_adjustments(self._vadj or new_adj(),
+                                  self._hadj or new_adj())
+
+    def _move(self, x=0, y=0):
+        if not self._child:
+            return
+
+        if x != self._child.x or \
+           y != self._child.y:
+
+            self._child.x = x
+            self._child.y = y
+
+            self.queue_resize()
+
+    def set_size(self, width, height):
+        if self._width != width:
+            self._width = width
+        if self._height != height:
+            self._height = height
+        if self._hadj:
+            set_adjustment_upper(self._hadj, self._width, False)
+        if self._vadj:
+            set_adjustment_upper(self._vadj, self._height, False)
+
+        if self.flags() & gtk.REALIZED:
+            self._bin_window.resize(max(width, self.allocation.width),
+                                    max(height, self.allocation.height))
+
+    def do_realize(self):
+        self.set_flags(self.flags() | gtk.REALIZED)
+
+        self.window = gdk.Window(
+            self.get_parent_window(),
+            window_type=gdk.WINDOW_CHILD,
+            x=self.allocation.x,
+            y=self.allocation.y,
+            width=self.allocation.width,
+            height=self.allocation.height,
+            wclass=gdk.INPUT_OUTPUT,
+            colormap=self.get_colormap(),
+            event_mask=gdk.VISIBILITY_NOTIFY_MASK)
+        self.window.set_user_data(self)
+
+        self._bin_window = gdk.Window(
+            self.window,
+            window_type=gdk.WINDOW_CHILD,
+            x=int(-self._hadj.value),
+            y=int(-self._vadj.value),
+            width=max(self._width, self.allocation.width),
+            height=max(self._height, self.allocation.height),
+            colormap=self.get_colormap(),
+            wclass=gdk.INPUT_OUTPUT,
+            event_mask=(self.get_events() | gdk.EXPOSURE_MASK |
+                        gdk.SCROLL_MASK))
+        self._bin_window.set_user_data(self)
+
+        self.set_style(self.style.attach(self.window))
+        self.style.set_background(self.window, gtk.STATE_NORMAL)
+        self.style.set_background(self._bin_window, gtk.STATE_NORMAL)
+
+        if self._child:
+            self._child.widget.set_parent_window(self._bin_window)
+
+        self.queue_resize()
+
+    def do_unrealize(self):
+        self._bin_window.set_user_data(None)
+        self._bin_window.destroy()
+        self._bin_window = None
+        gtk.Container.do_unrealize(self)
+
+    def _do_style_set(self, style):
+        gtk.Widget.do_style_set(self, style)
+
+        if self.flags() & gtk.REALIZED:
+            self.style.set_background(self._bin_window, gtk.STATE_NORMAL)
+
+    def do_expose_event(self, event):
+        if event.window != self._bin_window:
+            return False
+
+        gtk.Container.do_expose_event(self, event)
+
+        return False
+
+    def do_map(self):
+        self.set_flags(self.flags() | gtk.MAPPED)
+
+        if self._child:
+            flags = self._child.widget.flags()
+
+            if flags & gtk.VISIBLE and not (flags & gtk.MAPPED):
+                self._child.widget.map()
+
+        self._bin_window.show()
+        self.window.show()
+
+    def do_size_request(self, req):
+        req.width = 0
+        req.height = 0
+
+        if self._child and (self._animating or self._to_show):
+        #if self._child:
+            req.width, req.height = self._child.widget.size_request()
+
+    def do_size_allocate(self, allocation):
+        self.allocation = allocation
+
+        if self._child:
+            rect = gdk.Rectangle(self._child.x, self._child.y,
+                                 allocation.width, allocation.height)
+            self._child.widget.size_allocate(rect)
+
+        if self.flags() & gtk.REALIZED:
+            self.window.move_resize(*allocation)
+            self._bin_window.resize(max(self._width, allocation.width),
+                                    max(self._height, allocation.height))
+
+        self._hadj.page_size = allocation.width
+        self._hadj.page_increment = allocation.width * 0.9
+        self._hadj.lower = 0
+        set_adjustment_upper(self._hadj,
+                             max(allocation.width, self._width), True)
+
+        self._vadj.page_size = allocation.height
+        self._vadj.page_increment = allocation.height * 0.9
+        self._vadj.lower = 0
+        self._vadj.upper = max(allocation.height, self._height)
+        set_adjustment_upper(self._vadj,
+                             max(allocation.height, self._height), True)
+
+    def do_set_scroll_adjustments(self, hadj, vadj):
+        self._set_adjustments(hadj, vadj)
+
+    def do_forall(self, include_internals, callback, data):
+        if self._child:
+            callback(self._child.widget, data)
+
+    def do_add(self, widget):
+        if self._child:
+            raise AttributeError
+
+        child = Child()
+        child.widget = widget
+        child.x, child.y = 0, 0
+
+        self._child = child
+
+        if self.flags() & gtk.REALIZED:
+            widget.set_parent_window(self._bin_window)
+
+        widget.set_parent(self)
+
+    def do_remove(self, widget):
+        if self._animating:
+            raise Exception("Try later please :)")
+
+        if self._child and self._child.widget == widget:
+            self._child = None
+            widget.unparent()
+        else:
+            raise AttributeError
+
+    # Private
+
+    def _set_adjustments(self, hadj, vadj):
+        if not hadj and self._hadj:
+            hadj = new_adj()
+
+        if not vadj and self._vadj:
+            vadj = new_adj()
+
+        if self._hadj and self._hadj != hadj:
+            self._hadj.disconnect(self._hadj_changed_id)
+
+        if self._vadj and self._vadj != vadj:
+            self._vadj.disconnect(self._vadj_changed_id)
+
+        need_adjust = False
+
+        if self._hadj != hadj:
+            self._hadj = hadj
+            set_adjustment_upper(hadj, self._width, False)
+            self._hadj_changed_id = hadj.connect(
+                "value-changed",
+                self._adjustment_changed)
+            need_adjust = True
+
+        if self._vadj != vadj:
+            self._vadj = vadj
+            set_adjustment_upper(vadj, self._height, False)
+            self._vadj_changed_id = vadj.connect(
+                "value-changed",
+                self._adjustment_changed)
+            need_adjust = True
+
+        if need_adjust and vadj and hadj:
+            self._adjustment_changed()
+
+    def _adjustment_changed(self, adj=None):
+        if self.flags() & gtk.REALIZED:
+            self._bin_window.move(int(-self._hadj.value),
+                                  int(-self._vadj.value))
+            self._bin_window.process_updates(True)
+
+    def _do_animation(self):
+        if not self._child:
+            return False
+
+        if not self._child.widget.flags() & gtk.VISIBLE:
+            self._child.widget.show()
+
+        if self._to_show:
+            if self._current < 0:
+                self._current += self._speed
+                self._move(0, self._current)
+
+                return True
+
+            self._current = 0
+            self._move(0, self._current)
+        else:
+            if self._current > self._dest:
+                self._current -= self._speed
+                self._move(0, self._current)
+
+                return True
+
+            self._current = -self.allocation.height
+            self._move(0, self._current)
+
+            self.hide()
+
+        self.emit('animation-end', self._to_show)
+        self._child.widget.set_sensitive(True)
+        return False
+
+    def toggle_animation(self):
+        if self._animating or not self._child:
+            return False
+
+        self._to_show = not self._to_show
+        self._speed = max(self.allocation.height / (self._time_tot / self._time_int), 1)
+        self._child.widget.set_sensitive(False)
+
+        if self._to_show:
+            self.show()
+            self.set_size_request(-1, -1)
+            self._dest = 0
+        else:
+            self.set_size_request(0, 0)
+            self._dest = -self.allocation.height
+
+        gobject.timeout_add(self._time_int, self._do_animation)
+
+        return True
+
+Layout.set_set_scroll_adjustments_signal('set-scroll-adjustments')
 
 class AnimatedExpander(gtk.VBox):
@@ -33 +364 @@
         # optionally a close button :)
         
-        self.arrow = HIGArrowButton(gtk.ORIENTATION_VERTICAL)
-        self.arrow.set_relief(gtk.RELIEF_NONE)
-        self.arrow.connect('clicked', self.__on_toggle)
+        self._arrow = HIGArrowButton(gtk.ORIENTATION_VERTICAL)
+        self._arrow.set_relief(gtk.RELIEF_NONE)
+        self._arrow.connect('clicked', self.__on_toggle)
         
         self._label = gtk.Label()
@@ -45 +376 @@
         
         # The layout part
-        self.layout = gtk.Layout()
-        self.child = None
-        
-        self.animating = False
-        self.to_show = False
-        
-        self.speed = 10
-        self.current = 0
-        self.dest = 0
-
-        self.tot_time = 100
-        self.int_time = 5
+        self._layout = Layout()
         
         # Pack all
         hbox = gtk.HBox(False, 2)
-        hbox.pack_start(self.arrow, False, False)
+        hbox.pack_start(self._arrow, False, False)
         hbox.pack_start(self._image, False, False)
         hbox.pack_start(self._label)
@@ -67 +387 @@
         frame.add(hbox)
         
-        self.happy_box = gtk.EventBox()
-        self.happy_box.add(frame)
-        
-        self.pack_start(self.happy_box, False, False)
-        self.pack_end(self.layout)
+        self._happy_box = gtk.EventBox()
+        self._happy_box.add(frame)
+        
+        self.pack_start(self._happy_box, False, False)
+        self.pack_start(self._layout)
         
         self.show_all()
@@ -81 +401 @@
         gtk.gdk.colormap_get_system().alloc_color(bg_color)
 
-        self.happy_box.modify_bg(gtk.STATE_NORMAL, bg_color)
-
-    def do_size_allocate(self, allocation):
-        ret = gtk.VBox.do_size_allocate(self, allocation)
-
-        if self.animating:
-            self.layout.show()
-        elif self.child and not self.animating:
-            alloc = self.layout.get_allocation()
-            w, h = alloc.width, alloc.height
-            
-            alloc = self.child.get_allocation()
-
-            #if w > alloc.width:
-            if w >= self.child.size_request()[0]:
-                alloc.width = w
-            else:
-                alloc.width = self.child.size_request()[0]
-
-            #if h > alloc.height:
-            if h >= self.child.size_request()[1]:
-                alloc.height = h
-            else:
-                alloc.height = self.child.size_request()[1]
-
-            self.child.size_allocate(alloc)
-            
-            if self.to_show:
-                self.layout.show()
-            else:
-                self.layout.hide()
-        
-        return ret
+        self._happy_box.modify_bg(gtk.STATE_NORMAL, bg_color)
 
     def add_widget(self, widget, show=False):
         """
         Add a widget to the expander.
-        
+
         @param widget the widget to add
         @param show if the widget should be showed
         """
-        
-        if self.child:
-            raise Exception("Could not add another widget as child.")
-        
-        self.child = widget
-        
-        self.layout.put(self.child, 0, 0)
-        self.do_size_allocate(self.get_allocation())
-        self.set_expanded(show)
+
+        #FIXME: this
+        self._layout.add(widget)
 
     def add(self, widget):
         self.add_widget(widget, True)
-
-    def set_expanded(self, val):
-        """
-        Show or hide the child widget without animation
-        """
-        
-        if not self.child:
-            return
-        
-        self.arrow.set_active(val)
-        self.to_show = val
-
-        if val:
-            self.current = 0
-            self.layout.move(self.child, 0, self.current)
-            self.layout.show()
-        else:
-            self.layout.hide()
-            self.current = self.__get_child_height()
-            self.layout.move(self.child, 0, self.current)
-        
-        if not self.animating:
-            self.__set_animating(False)
 
     def get_label(self):
@@ -168 +427 @@
         self._label.set_use_markup(True)
 
-    def __animate_hide(self):
-        if self.current > self.dest:
-            self.current -= self.speed
-            self.layout.move(self.child, 0, self.current)
-
-            return True
-
-        if self.dest < 0:
-            self.layout.hide()
-        
-        self.current = self.__get_child_height()
-        self.__set_animating(False)
-        self.arrow.set_sensitive(True)
-        
-        return False
-
-    def __animate_show(self):
-        if self.current < 0:
-            self.current += self.speed
-            self.layout.move(self.child, 0, self.current)
-
-            return True
-        
-        self.current = 0
-        self.layout.move(self.child, 0, 0)
-        self.__set_animating(False)
-        self.arrow.set_sensitive(True)
-        
-        return False
-    
-
     def __on_toggle(self, btn):
-        if not self.child:
-            return
-        
-        self.arrow.set_active(not self.arrow.get_active())
-        self.to_show = self.arrow.get_active()
-        self.__set_animating(True)
-        
-        self.arrow.set_sensitive(False)
-
-        # We need to calculate the speed offset to complete
-        # the scrolling in self.tot_time
-
-        self.speed = self.__get_child_height() / (self.tot_time / self.int_time)
-
-        # Avoid null scrolling
-        if self.speed < 5:
-            self.speed = 5
-
-        if self.to_show:
-            self.dest = 0
-            self.current = -self.__get_child_height()
-            
-            gobject.timeout_add(self.int_time, self.__animate_show)
-        else:
-            self.dest = -self.__get_child_height()
-            self.current = 0
-            
-            gobject.timeout_add(self.int_time, self.__animate_hide)
-    
-    def __get_child_height(self):
-        if self.child.flags() & gtk.REALIZED:
-            return self.child.get_allocation().height
-        else:
-            return self.child.size_request()[1]
-
-    def __set_animating(self, val):
-        self.animating = val
-
-        if not self.child:
-            return
-
-        self.child.set_sensitive(not self.animating)
-
-        alloc = self.layout.get_allocation()
-
-        if self.to_show:
-            alloc.height = self.__get_child_height()
-            self.layout.set_size_request(-1, alloc.height + 2)
-        else:
-            alloc.height = 0
-            self.layout.set_size_request(-1, -1)
-        
-        self.layout.size_allocate(alloc)
-        self.size_allocate(self.get_allocation())
+        if self._layout.toggle_animation():
+            self._arrow.set_active(not self._arrow.get_active())
     
     def get_image(self):
@@ -266 +442 @@
 gobject.type_register(AnimatedExpander)
 
+class ToolPage(AnimatedExpander):
+    def __init__(self, parent, label=None, image=gtk.STOCK_PROPERTIES):
+        super(ToolPage, self).__init__(label, image)
+
+        self._parent = parent
+        self._active = False
+
+        self._layout.connect('animation-end', lambda w, v: self.set_active(v))
+
+    def get_active(self):
+        return self._active
+
+    def set_active(self, val):
+        self._active = val
+        self._parent.realloc(self)
+
+class ToolBox(gtk.VBox):
+    def __init__(self):
+        super(ToolBox, self).__init__(False, 2)
+        self.set_border_width(4)
+
+        self._active_page = None
+        self._pages = []
+
+    def append_page(self, child, txt):
+        page = ToolPage(self, txt)
+        page.add(child)
+
+        self._pages.append(page)
+
+
+        self._active_page = page
+        self.pack_start(page, True, True)
+
+    def realloc(self, page):
+        if page.get_active():
+            self.set_child_packing(page, True, True, 0, gtk.PACK_START)
+
+            if self._active_page:
+                self._active_page.set_active(False)
+                self._active_page = page
+        else:
+            self.set_child_packing(page, False, False, 0, gtk.PACK_START)
+
+def main(klass):
+    w = gtk.Window()
+    vbox = gtk.VBox()
+
+    sw = gtk.ScrolledWindow()
+    sw.add(gtk.TextView())
+    sw.set_size_request(400, 400)
+    
+    exp = klass("miao")
+    exp.add(sw)
+
+    vbox.pack_start(exp, False, False)
+
+    sw = gtk.ScrolledWindow()
+    sw.add(gtk.TextView())
+    
+    exp = klass("miao")
+    exp.add(sw)
+    vbox.pack_start(exp)
+
+    vbox.pack_start(gtk.Label("mias"), False, False)
+    w.add(vbox)
+    w.show_all()
+
+def toolbox():
+    w = gtk.Window()
+    box = ToolBox()
+    box.append_page(gtk.Label("Testing"), "miao")
+    box.append_page(gtk.Label("Testing"), "miao")
+    w.add(box)
+    w.show_all()
+
 if __name__ == "__main__":
-    w = gtk.Window()
-    exp = AnimatedExpander("<b>Testinggggg</b>")
-    sw = gtk.ScrolledWindow()
-    exp.add_widget(gtk.Label("Miao"))
-    w.add(exp)
-    w.show_all()
+    #main(AnimatedExpander)
+    #main(gtk.Expander)
+    toolbox()
     gtk.main()

branch/PacketManipulator/widgets/PropertyGrid.py

@@ -36 +36 @@
 # Higwidgets
 from higwidgets.hignetwidgets import HIGIpEntry
+from widgets.Expander import AnimatedExpander
 
 class Editor(gtk.HBox):
@@ -595 +596 @@
 class PropertyGrid(gtk.VBox):
     def __init__(self):
-        gtk.VBox.__init__(self)
+        gtk.VBox.__init__(self, False, 2)
+
+        self.set_border_width(2)
 
         self.__create_toolbar()
@@ -605 +608 @@
         self.tree = PropertyGridTree()
 
-        self.expander = gtk.Expander("Description")
-
         self.desc_text = gtk.TextView()
         self.desc_text.set_wrap_mode(gtk.WRAP_WORD)
-        self.desc_text.set_size_request(1, 70)
+        #self.desc_text.set_size_request(1, 70)
         self.desc_text.set_editable(False)
         self.desc_text.set_left_margin(5)
@@ -619 +620 @@
         sw.add(self.desc_text)
 
-        self.expander.add(sw)
-        
-        self.pack_start(self.tree)
-        self.pack_start(self.expander, False, False)
+        expander = AnimatedExpander('Protocol')
+        expander.add(self.tree)
+
+        self.pack_start(expander)
+
+        expander = AnimatedExpander('Description')
+        expander.add(sw)
+
+        self.pack_start(expander, False, False)
 
         self.clear = self.tree.clear