setup special wxgui connect on sinks, needs testing

[debian/gnuradio] / gr-wxgui / src / python / common.py

diff --git a/gr-wxgui/src/python/common.py b/gr-wxgui/src/python/common.py
index 9c97ce1ecad898a32e1871f9445c42713db7fd9e..dca41c9a3ec1d0f11fa8e48f4b784c29f498e1be 100644 (file)
--- a/gr-wxgui/src/python/common.py
+++ b/gr-wxgui/src/python/common.py
@@ -19,6 +19,83 @@
 # Boston, MA 02110-1301, USA.
 #
 
+##################################################
+# conditional disconnections of wx flow graph
+##################################################
+import wx
+
+def bind_to_visible_event(win, callback):
+       """
+       Bind a callback to a window when its visibility changes.
+       Specifically, callback when the window changes visibility
+       when a notebook tab event in one of the parents occurs.
+       @param win the wx window
+       @param callback a 1 param function
+       """
+       #is the window visible in the hierarchy
+       def is_wx_window_visible(my_win):
+               while True:
+                       parent = my_win.GetParent()
+                       if not parent: return True #reached the top of the hierarchy
+                       #if we are hidden, then finish, otherwise keep traversing up
+                       if isinstance(parent, wx.Notebook) and parent.GetCurrentPage() != my_win: return False
+                       my_win = parent
+       #call the callback, the arg is shown or not
+       def callback_factory(my_win, my_callback):
+               return lambda *args: my_callback(is_wx_window_visible(my_win))
+       handler = callback_factory(win, callback)
+       #bind the handler to all the parent notebooks
+       while win:
+               if isinstance(win, wx.Notebook):
+                       win.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, handler)
+               if not win.GetParent():
+                       win.Bind(wx.EVT_ACTIVATE, handler)
+               win = win.GetParent()
+
+from gnuradio import gr
+
+def conditional_connect(source, sink, hb, win, size):
+       nulls = list()
+       cache = [None]
+       def callback(visible, init=False):
+               if visible == cache[0]: return
+               cache[0] = visible
+               if not init: hb.lock()
+               print 'visible', visible, source, sink
+               if visible:
+                       if not init:
+                               hb.disconnect(source, nulls[0])
+                               hb.disconnect(nulls[1], nulls[2])
+                               hb.disconnect(nulls[2], sink)
+                               while nulls: nulls.pop()
+                       hb.connect(source, sink)
+               else:
+                       if not init: hb.disconnect(source, sink)
+                       nulls.extend([gr.null_sink(size), gr.null_source(size), gr.head(size, 0)])
+                       hb.connect(source, nulls[0])
+                       hb.connect(nulls[1], nulls[2], sink)
+               if not init: hb.unlock()
+       callback(False, init=True) #initially connect
+       bind_to_visible_event(win, callback)
+
+class wxgui_hb(object):
+       def wxgui_connect(self, *points):
+               """
+               Use wxgui connect when the first point is the self source of the hb.
+               The win property of this object should be set to the wx window.
+               When this method tries to connect self to the next point,
+               it will conditionally make this connection based on the visibility state.
+               """
+               try:
+                       assert points[0] == self or points[0][0] == self
+                       conditional_connect(
+                               points[0], points[1],
+                               win=self.win, hb=self,
+                               size=self._hb.input_signature().sizeof_stream_item(0),
+                       )
+                       if len(points[1:]) > 1: self.connect(*points[1:])
+               except (AssertionError, IndexError): self.connect(*points)
+
 #A macro to apply an index to a key
 index_key = lambda key, i: "%s_%d"%(key, i+1)