]> git.gag.com Git - debian/gnuradio/commitdiff
Create one drawing area per flowgraph/notebook page.
authorjblum <jblum@221aa14e-8319-0410-a670-987f0aec2ac5>
Thu, 14 May 2009 21:18:28 +0000 (21:18 +0000)
committerjblum <jblum@221aa14e-8319-0410-a670-987f0aec2ac5>
Thu, 14 May 2009 21:18:28 +0000 (21:18 +0000)
Previously, there was one global drawing area, and empty notebook pages.

This has the advantage of saving the scroll position though mutiple scroll windows,
rendering the flow graph only when the notebook page is realized,
and proper use + appearance of the gtk notebook

git-svn-id: http://gnuradio.org/svn/gnuradio/trunk@11030 221aa14e-8319-0410-a670-987f0aec2ac5

grc/src/gui/ActionHandler.py
grc/src/gui/DrawingArea.py
grc/src/gui/MainWindow.py
grc/src/gui/NotebookPage.py

index f5f349d4a9a688c7dbd84bef9d70d634dab7d912..06e998b31ca2b02f28d7e26c956cfdedd1a2cd33 100644 (file)
@@ -61,7 +61,7 @@ class ActionHandler:
                self.main_window.connect('key-press-event', self._handle_key_press)
                self.get_page = self.main_window.get_page
                self.get_flow_graph = self.main_window.get_flow_graph
-               self.get_focus_flag = self.main_window.drawing_area.get_focus_flag
+               self.get_focus_flag = self.main_window.get_focus_flag
                #setup the messages
                Messages.register_messenger(self.main_window.add_report_line)
                Messages.send_init()
@@ -170,8 +170,8 @@ class ActionHandler:
                # Cut/Copy/Paste
                ##################################################
                elif state == Actions.BLOCK_CUT:
-                       self.handle_states(BLOCK_COPY)
-                       self.handle_states(ELEMENT_DELETE)
+                       self.handle_states(Actions.BLOCK_COPY)
+                       self.handle_states(Actions.ELEMENT_DELETE)
                elif state == Actions.BLOCK_COPY:
                        self.clipboard = self.get_flow_graph().copy_to_clipboard()
                elif state == Actions.BLOCK_PASTE:
index 22edb9093638c5e8653e8c084a6a10be326faa98..6f90049c50b4e162db97cbb7636dda32e710ff9a 100644 (file)
@@ -28,18 +28,17 @@ class DrawingArea(gtk.DrawingArea):
        The drawing area also responds to mouse and key events.
        """
 
-       def __init__(self, main_window):
+       def __init__(self, flow_graph):
                """
                DrawingArea contructor.
                Connect event handlers.
                @param main_window the main_window containing all flow graphs
                """
                self.ctrl_mask = False
-               self._main_window = main_window
-               #inject drawing area into main_window
-               self._main_window.drawing_area = self
+               self._flow_graph = flow_graph
                gtk.DrawingArea.__init__(self)
                self.set_size_request(MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT)
+               self.connect('realize', self._handle_window_realize)
                self.connect('configure-event', self._handle_window_configure)
                self.connect('expose-event', self._handle_window_expose)
                self.connect('motion-notify-event', self._handle_mouse_motion)
@@ -58,8 +57,9 @@ class DrawingArea(gtk.DrawingArea):
                #setup the focus flag
                self._focus_flag = False
                self.get_focus_flag = lambda: self._focus_flag
-               self.connect('leave-notify-event', self._handle_focus_event, False)
-               self.connect('enter-notify-event', self._handle_focus_event, True)
+               def _handle_focus_event(widget, event, focus_flag): self._focus_flag = focus_flag
+               self.connect('leave-notify-event', _handle_focus_event, False)
+               self.connect('enter-notify-event', _handle_focus_event, True)
 
        def new_pixmap(self, width, height): return gtk.gdk.Pixmap(self.window, width, height, -1)
 
@@ -70,18 +70,14 @@ class DrawingArea(gtk.DrawingArea):
                """
                Handle a drag and drop by adding a block at the given coordinate.
                """
-               self._main_window.get_flow_graph().add_new_block(selection_data.data, (x, y))
-
-       def _handle_focus_event(self, widget, event, focus_flag):
-               """Record the focus state of the flow graph window."""
-               self._focus_flag = focus_flag
+               self._flow_graph.add_new_block(selection_data.data, (x, y))
 
        def _handle_mouse_button_press(self, widget, event):
                """
                Forward button click information to the flow graph.
                """
                self.ctrl_mask = event.state & gtk.gdk.CONTROL_MASK
-               self._main_window.get_flow_graph().handle_mouse_button_press(
+               self._flow_graph.handle_mouse_button_press(
                        left_click=(event.button == 1),
                        double_click=(event.type == gtk.gdk._2BUTTON_PRESS),
                        coordinate=(event.x, event.y),
@@ -92,7 +88,7 @@ class DrawingArea(gtk.DrawingArea):
                Forward button release information to the flow graph.
                """
                self.ctrl_mask = event.state & gtk.gdk.CONTROL_MASK
-               self._main_window.get_flow_graph().handle_mouse_button_release(
+               self._flow_graph.handle_mouse_button_release(
                        left_click=(event.button == 1),
                        coordinate=(event.x, event.y),
                )
@@ -102,10 +98,17 @@ class DrawingArea(gtk.DrawingArea):
                Forward mouse motion information to the flow graph.
                """
                self.ctrl_mask = event.state & gtk.gdk.CONTROL_MASK
-               self._main_window.get_flow_graph().handle_mouse_motion(
+               self._flow_graph.handle_mouse_motion(
                        coordinate=(event.x, event.y),
                )
 
+       def _handle_window_realize(self, widget):
+               """
+               Called when the window is realized.
+               Update the flowgraph, which calls new pixmap.
+               """
+               self._flow_graph.update()
+
        def _handle_window_configure(self, widget, event):
                """
                Called when the window is resized.
@@ -119,5 +122,5 @@ class DrawingArea(gtk.DrawingArea):
                Double buffering: draw to pixmap, then draw pixmap to window.
                """
                gc = self.window.new_gc()
-               self._main_window.get_flow_graph().draw(gc, self._pixmap)
+               self._flow_graph.draw(gc, self._pixmap)
                self.window.draw_drawable(gc, self._pixmap, 0, 0, 0, 0, -1, -1)
index ffb696a452c354dc44bdad71e25cdeb5240e01b6..2106b8ea192c06f4c488bd61ea3e6422e48f3fe1 100644 (file)
@@ -18,7 +18,6 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 """
 
 from Constants import \
-       MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT, \
        NEW_FLOGRAPH_TITLE, DEFAULT_REPORTS_WINDOW_WIDTH
 from Actions import \
        APPLICATION_QUIT, FLOW_GRAPH_KILL, \
@@ -29,7 +28,6 @@ import gtk
 import Bars
 from BlockTreeWindow import BlockTreeWindow
 from Dialogs import TextDisplay, MessageDialogHelper
-from DrawingArea import DrawingArea
 from NotebookPage import NotebookPage
 import Preferences
 import Messages
@@ -59,12 +57,6 @@ class MainWindow(gtk.Window):
                vbox.pack_start(Bars.MenuBar(), False)
                vbox.pack_start(Bars.Toolbar(), False)
                vbox.pack_start(self.hpaned)
-               #setup scrolled window
-               self.scrolled_window = gtk.ScrolledWindow()
-               self.scrolled_window.set_size_request(MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT)
-               self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
-               self.drawing_area = DrawingArea(self)
-               self.scrolled_window.add_with_viewport(self.drawing_area)
                #create the notebook
                self.notebook = gtk.Notebook()
                self.page_to_be_closed = None
@@ -73,11 +65,9 @@ class MainWindow(gtk.Window):
                self.notebook.set_scrollable(True) #scroll arrows for page tabs
                self.notebook.connect('switch-page', self._handle_page_change)
                #setup containers
-               flow_graph_box = gtk.VBox(False, 0)
                self.flow_graph_vpaned = gtk.VPaned()
-               flow_graph_box.pack_start(self.notebook, False, False, 0)
-               flow_graph_box.pack_start(self.scrolled_window)
-               self.flow_graph_vpaned.pack1(flow_graph_box)
+               #flow_graph_box.pack_start(self.scrolled_window)
+               self.flow_graph_vpaned.pack1(self.notebook)
                self.hpaned.pack1(self.flow_graph_vpaned)
                self.hpaned.pack2(BlockTreeWindow(platform, self.get_flow_graph), False) #dont allow resize
                #create the reports window
@@ -155,8 +145,6 @@ class MainWindow(gtk.Window):
                try: #try to load from file
                        if file_path: Messages.send_start_load(file_path)
                        flow_graph = self._platform.get_new_flow_graph()
-                       #inject drawing area and handle states into flow graph
-                       flow_graph.drawing_area = self.drawing_area
                        flow_graph.handle_states = self.handle_states
                        page = NotebookPage(
                                self,
@@ -252,8 +240,7 @@ class MainWindow(gtk.Window):
                                )
                        )
                #show/hide notebook tabs
-               if len(self._get_pages()) > 1: self.notebook.show()
-               else: self.notebook.hide()
+               self.notebook.set_show_tabs(len(self._get_pages()) > 1)
 
        def get_page(self):
                """
@@ -269,6 +256,13 @@ class MainWindow(gtk.Window):
                """
                return self.get_page().get_flow_graph()
 
+       def get_focus_flag(self):
+               """
+               Get the focus flag from the current page.
+               @return the focus flag
+               """
+               return self.get_page().get_drawing_area().get_focus_flag()
+
        ############################################################
        # Helpers
        ############################################################
index 50a1216f968ee277211c0125e2051bc8725733c8..0d6a4a87c331c8a4f736a8e16b1e2542ac752ba4 100644 (file)
@@ -24,6 +24,8 @@ import gtk
 from .. utils import ParseXML
 from StateCache import StateCache
 from .. platforms.base.Constants import FLOW_GRAPH_DTD
+from Constants import MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT
+from DrawingArea import DrawingArea
 import os
 
 ############################################################
@@ -56,7 +58,6 @@ class NotebookPage(gtk.HBox):
                self.set_saved(True)
                #import the data to the flow graph
                self.get_flow_graph().import_data(initial_state)
-               self.get_flow_graph().update()
                #initialize page gui
                gtk.HBox.__init__(self, False, 0)
                self.show()
@@ -81,6 +82,18 @@ class NotebookPage(gtk.HBox):
                button.set_size_request(w+6, h+6)
                self.tab.pack_start(button, False)
                self.tab.show_all()
+               #setup scroll window and drawing area
+               self.scrolled_window = gtk.ScrolledWindow()
+               self.scrolled_window.set_size_request(MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT)
+               self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+               self.drawing_area = DrawingArea(self.get_flow_graph())
+               self.scrolled_window.add_with_viewport(self.get_drawing_area())
+               self.pack_start(self.scrolled_window)
+               #inject drawing area and handle states into flow graph
+               self.get_flow_graph().drawing_area = self.get_drawing_area()
+               self.show_all()
+
+       def get_drawing_area(self): return self.drawing_area
 
        def get_generator(self):
                """