+ """

+ The action handler will setup all the major window components,

+ and handle button presses and flow graph operations from the GUI.

+ """

+

+ def __init__(self, file_paths, platform):

+ """

+ ActionHandler constructor.

+ Create the main window, setup the message handler, import the preferences,

+ and connect all of the action handlers. Finally, enter the gtk main loop and block.

+

+ Args:

+ file_paths: a list of flow graph file passed from command line

+ platform: platform module

+ """

+ self.clipboard = None

+ for action in Actions.get_all_actions(): action.connect('activate', self._handle_action)

+ #setup the main window

+ self.platform = platform;

+ self.main_window = MainWindow(platform)

+ self.main_window.connect('delete-event', self._quit)

+ 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.get_focus_flag

+ #setup the messages

+ Messages.register_messenger(self.main_window.add_report_line)

+ Messages.send_init(platform)

+ #initialize

+ self.init_file_paths = file_paths

+ Actions.APPLICATION_INITIALIZE()

+ #enter the mainloop

+ gtk.main()

+

+ def _handle_key_press(self, widget, event):

+ """

+ Handle key presses from the keyboard and translate key combinations into actions.

+ This key press handler is called prior to the gtk key press handler.

+ This handler bypasses built in accelerator key handling when in focus because

+ * some keys are ignored by the accelerators like the direction keys,

+ * some keys are not registered to any accelerators but are still used.

+ When not in focus, gtk and the accelerators handle the the key press.

+

+ Returns:

+ false to let gtk handle the key action

+ """

+ if not self.get_focus_flag(): return False

+ return Actions.handle_key_press(event)

+

+ def _quit(self, window, event):

+ """

+ Handle the delete event from the main window.

+ Generated by pressing X to close, alt+f4, or right click+close.

+ This method in turns calls the state handler to quit.

+

+ Returns:

+ true

+ """

+ Actions.APPLICATION_QUIT()

+ return True

+

+ def _handle_action(self, action):

+ #print action

+ ##################################################

+ # Initalize/Quit

+ ##################################################

+ if action == Actions.APPLICATION_INITIALIZE:

+ for action in Actions.get_all_actions(): action.set_sensitive(False) #set all actions disabled

+ #enable a select few actions

+ for action in (

+ Actions.APPLICATION_QUIT, Actions.FLOW_GRAPH_NEW,

+ Actions.FLOW_GRAPH_OPEN, Actions.FLOW_GRAPH_SAVE_AS,

+ Actions.FLOW_GRAPH_CLOSE, Actions.ABOUT_WINDOW_DISPLAY,

+ Actions.FLOW_GRAPH_SCREEN_CAPTURE, Actions.HELP_WINDOW_DISPLAY,

+ Actions.TYPES_WINDOW_DISPLAY,

+ ): action.set_sensitive(True)

+ if not self.init_file_paths:

+ self.init_file_paths = Preferences.files_open()

+ if not self.init_file_paths: self.init_file_paths = ['']

+ for file_path in self.init_file_paths:

+ if file_path: self.main_window.new_page(file_path) #load pages from file paths

+ if Preferences.file_open() in self.init_file_paths:

+ self.main_window.new_page(Preferences.file_open(), show=True)

+ if not self.get_page(): self.main_window.new_page() #ensure that at least a blank page exists

+ elif action == Actions.APPLICATION_QUIT:

+ if self.main_window.close_pages():

+ gtk.main_quit()

+ exit(0)

+ ##################################################

+ # Selections

+ ##################################################

+ elif action == Actions.ELEMENT_SELECT:

+ pass #do nothing, update routines below

+ elif action == Actions.NOTHING_SELECT:

+ self.get_flow_graph().unselect()

+ ##################################################

+ # Enable/Disable

+ ##################################################

+ elif action == Actions.BLOCK_ENABLE:

+ if self.get_flow_graph().enable_selected(True):

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ self.get_page().set_saved(False)

+ elif action == Actions.BLOCK_DISABLE:

+ if self.get_flow_graph().enable_selected(False):

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ self.get_page().set_saved(False)

+ ##################################################

+ # Cut/Copy/Paste

+ ##################################################

+ elif action == Actions.BLOCK_CUT:

+ Actions.BLOCK_COPY()

+ Actions.ELEMENT_DELETE()

+ elif action == Actions.BLOCK_COPY:

+ self.clipboard = self.get_flow_graph().copy_to_clipboard()

+ elif action == Actions.BLOCK_PASTE:

+ if self.clipboard:

+ self.get_flow_graph().paste_from_clipboard(self.clipboard)

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ self.get_page().set_saved(False)

+ elif action == Actions.BLOCK_CREATE_HIER:

+ Actions.BLOCK_COPY()

+ self.main_window.new_page()

+ self.get_flow_graph().update()

+ ##################################################

+ # Move/Rotate/Delete/Create

+ ##################################################

+ elif action == Actions.BLOCK_MOVE:

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ self.get_page().set_saved(False)

+ elif action == Actions.BLOCK_ROTATE_CCW:

+ if self.get_flow_graph().rotate_selected(90):

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ self.get_page().set_saved(False)

+ elif action == Actions.BLOCK_ROTATE_CW:

+ if self.get_flow_graph().rotate_selected(-90):

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ self.get_page().set_saved(False)

+ elif action == Actions.ELEMENT_DELETE:

+ if self.get_flow_graph().remove_selected():

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ Actions.NOTHING_SELECT()

+ self.get_page().set_saved(False)

+ elif action == Actions.ELEMENT_CREATE:

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ Actions.NOTHING_SELECT()

+ self.get_page().set_saved(False)

+ elif action == Actions.BLOCK_INC_TYPE:

+ if self.get_flow_graph().type_controller_modify_selected(1):

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ self.get_page().set_saved(False)

+ elif action == Actions.BLOCK_DEC_TYPE:

+ if self.get_flow_graph().type_controller_modify_selected(-1):

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ self.get_page().set_saved(False)

+ elif action == Actions.PORT_CONTROLLER_INC:

+ if self.get_flow_graph().port_controller_modify_selected(1):

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ self.get_page().set_saved(False)

+ elif action == Actions.PORT_CONTROLLER_DEC:

+ if self.get_flow_graph().port_controller_modify_selected(-1):

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ self.get_page().set_saved(False)

+ ##################################################

+ # Window stuff

+ ##################################################

+ elif action == Actions.ABOUT_WINDOW_DISPLAY:

+ Dialogs.AboutDialog(self.get_flow_graph().get_parent())

+ elif action == Actions.HELP_WINDOW_DISPLAY:

+ Dialogs.HelpDialog()

+ elif action == Actions.TYPES_WINDOW_DISPLAY:

+ Dialogs.TypesDialog(self.get_flow_graph().get_parent())

+ elif action == Actions.ERRORS_WINDOW_DISPLAY:

+ Dialogs.ErrorsDialog(self.get_flow_graph())

+ ##################################################

+ # Param Modifications

+ ##################################################

+ elif action == Actions.BLOCK_PARAM_MODIFY:

+ selected_block = self.get_flow_graph().get_selected_block()

+ if selected_block:

+ if PropsDialog(selected_block).run():

+ #save the new state

+ self.get_flow_graph().update()

+ self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

+ self.get_page().set_saved(False)

+ else:

+ #restore the current state

+ n = self.get_page().get_state_cache().get_current_state()

+ self.get_flow_graph().import_data(n)

+ self.get_flow_graph().update()

+ ##################################################

+ # Undo/Redo

+ ##################################################

+ elif action == Actions.FLOW_GRAPH_UNDO:

+ n = self.get_page().get_state_cache().get_prev_state()

+ if n:

+ self.get_flow_graph().unselect()

+ self.get_flow_graph().import_data(n)

+ self.get_flow_graph().update()

+ self.get_page().set_saved(False)

+ elif action == Actions.FLOW_GRAPH_REDO:

+ n = self.get_page().get_state_cache().get_next_state()

+ if n:

+ self.get_flow_graph().unselect()

+ self.get_flow_graph().import_data(n)

+ self.get_flow_graph().update()

+ self.get_page().set_saved(False)

+ ##################################################

+ # New/Open/Save/Close

+ ##################################################

+ elif action == Actions.FLOW_GRAPH_NEW:

+ self.main_window.new_page()

+ elif action == Actions.FLOW_GRAPH_OPEN:

+ file_paths = OpenFlowGraphFileDialog(self.get_page().get_file_path()).run()

+ if file_paths: #open a new page for each file, show only the first

+ for i,file_path in enumerate(file_paths):

+ self.main_window.new_page(file_path, show=(i==0))

+ elif action == Actions.FLOW_GRAPH_CLOSE:

+ self.main_window.close_page()

+ elif action == Actions.FLOW_GRAPH_SAVE:

+ #read-only or undefined file path, do save-as

+ if self.get_page().get_read_only() or not self.get_page().get_file_path():

+ Actions.FLOW_GRAPH_SAVE_AS()

+ #otherwise try to save

+ else:

+ try:

+ ParseXML.to_file(self.get_flow_graph().export_data(), self.get_page().get_file_path())

+ self.get_flow_graph().grc_file_path = self.get_page().get_file_path()

+ self.get_page().set_saved(True)

+ except IOError:

+ Messages.send_fail_save(self.get_page().get_file_path())

+ self.get_page().set_saved(False)

+ elif action == Actions.FLOW_GRAPH_SAVE_AS:

+ file_path = SaveFlowGraphFileDialog(self.get_page().get_file_path()).run()

+ if file_path is not None:

+ self.get_page().set_file_path(file_path)

+ Actions.FLOW_GRAPH_SAVE()

+ elif action == Actions.FLOW_GRAPH_SCREEN_CAPTURE:

+ file_path = SaveImageFileDialog(self.get_page().get_file_path()).run()

+ if file_path is not None:

+ pixbuf = self.get_flow_graph().get_drawing_area().get_pixbuf()

+ pixbuf.save(file_path, IMAGE_FILE_EXTENSION[1:])

+ ##################################################

+ # Gen/Exec/Stop

+ ##################################################

+ elif action == Actions.FLOW_GRAPH_GEN:

+ if not self.get_page().get_proc():

+ if not self.get_page().get_saved() or not self.get_page().get_file_path():

+ Actions.FLOW_GRAPH_SAVE() #only save if file path missing or not saved

+ if self.get_page().get_saved() and self.get_page().get_file_path():

+ generator = self.get_page().get_generator()

+ try:

+ Messages.send_start_gen(generator.get_file_path())

+ generator.write()

+ except Exception,e: Messages.send_fail_gen(e)

+ else: self.generator = None

+ elif action == Actions.FLOW_GRAPH_EXEC:

+ if not self.get_page().get_proc():

+ Actions.FLOW_GRAPH_GEN()

+ if self.get_page().get_saved() and self.get_page().get_file_path():

+ ExecFlowGraphThread(self)

+ elif action == Actions.FLOW_GRAPH_KILL:

+ if self.get_page().get_proc():

+ try: self.get_page().get_proc().kill()

+ except: print "could not kill process: %d"%self.get_page().get_proc().pid

+ elif action == Actions.PAGE_CHANGE: #pass and run the global actions

+ pass

+ elif action == Actions.RELOAD_BLOCKS:

+ self.platform.loadblocks()

+ self.main_window.btwin.clear();

+ self.platform.load_block_tree(self.main_window.btwin);

+ elif action == Actions.OPEN_HIER:

+ bn = [];

+ for b in self.get_flow_graph().get_selected_blocks():

+ if b._grc_source:

+ self.main_window.new_page(b._grc_source, show=True);

+ elif action == Actions.BUSSIFY_SOURCES:

+ n = {'name':'bus', 'type':'bus'}

+ for b in self.get_flow_graph().get_selected_blocks():

+ b.bussify(n, 'source');

+ self.get_flow_graph()._old_selected_port = None;

+ self.get_flow_graph()._new_selected_port = None;

+ Actions.ELEMENT_CREATE();

+

+ elif action == Actions.BUSSIFY_SINKS:

+ n = {'name':'bus', 'type':'bus'}

+ for b in self.get_flow_graph().get_selected_blocks():

+ b.bussify(n, 'sink')

+ self.get_flow_graph()._old_selected_port = None;

+ self.get_flow_graph()._new_selected_port = None;

+ Actions.ELEMENT_CREATE();

+ else: print '!!! Action "%s" not handled !!!'%action

+ ##################################################

+ # Global Actions for all States

+ ##################################################

+ #update general buttons

+ Actions.ERRORS_WINDOW_DISPLAY.set_sensitive(not self.get_flow_graph().is_valid())

+ Actions.ELEMENT_DELETE.set_sensitive(bool(self.get_flow_graph().get_selected_elements()))

+ Actions.BLOCK_PARAM_MODIFY.set_sensitive(bool(self.get_flow_graph().get_selected_block()))

+ Actions.BLOCK_ROTATE_CCW.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))

+ Actions.BLOCK_ROTATE_CW.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))

+ #update cut/copy/paste

+ Actions.BLOCK_CUT.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))

+ Actions.BLOCK_COPY.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))

+ Actions.BLOCK_PASTE.set_sensitive(bool(self.clipboard))

+ #update enable/disable

+ Actions.BLOCK_ENABLE.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))

+ Actions.BLOCK_DISABLE.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))

+ Actions.BLOCK_CREATE_HIER.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))

+ Actions.OPEN_HIER.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))

+ Actions.BUSSIFY_SOURCES.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))

+ Actions.BUSSIFY_SINKS.set_sensitive(bool(self.get_flow_graph().get_selected_blocks()))

+ Actions.RELOAD_BLOCKS.set_sensitive(True)

+ #set the exec and stop buttons

+ self.update_exec_stop()

+ #saved status

+ Actions.FLOW_GRAPH_SAVE.set_sensitive(not self.get_page().get_saved())

+ self.main_window.update()

+ try: #set the size of the flow graph area (if changed)

+ new_size = self.get_flow_graph().get_option('window_size')

+ if self.get_flow_graph().get_size() != tuple(new_size):

+ self.get_flow_graph().set_size(*new_size)

+ except: pass

+ #draw the flow graph

+ self.get_flow_graph().update_selected()

+ self.get_flow_graph().queue_draw()

+ return True #action was handled

+

+ def update_exec_stop(self):

+ """

+ Update the exec and stop buttons.

+ Lock and unlock the mutex for race conditions with exec flow graph threads.

+ """

+ sensitive = self.get_flow_graph().is_valid() and not self.get_page().get_proc()

+ Actions.FLOW_GRAPH_GEN.set_sensitive(sensitive)

+ Actions.FLOW_GRAPH_EXEC.set_sensitive(sensitive)

+ Actions.FLOW_GRAPH_KILL.set_sensitive(self.get_page().get_proc() != None)

+ """Execute the flow graph as a new process and wait on it to finish."""

+

+ def __init__ (self, action_handler):

+ """

+ ExecFlowGraphThread constructor.

+

+ Args:

+ action_handler: an instance of an ActionHandler

+ """

+ Thread.__init__(self)

+ self.update_exec_stop = action_handler.update_exec_stop

+ self.flow_graph = action_handler.get_flow_graph()

+ #store page and dont use main window calls in run

+ self.page = action_handler.get_page()

+ Messages.send_start_exec(self.page.get_generator().get_file_path())

+ #get the popen

+ try:

+ self.p = self.page.get_generator().get_popen()

+ self.page.set_proc(self.p)

+ #update

+ self.update_exec_stop()

+ self.start()

+ except Exception, e:

+ Messages.send_verbose_exec(str(e))

+ Messages.send_end_exec()

+

+ def run(self):

+ """

+ Wait on the executing process by reading from its stdout.

+ Use gobject.idle_add when calling functions that modify gtk objects.

+ """

+ #handle completion

+ r = "\n"

+ while(r):

+ gobject.idle_add(Messages.send_verbose_exec, r)

+ r = os.read(self.p.stdout.fileno(), 1024)

+ gobject.idle_add(self.done)

+

+ def done(self):

+ """Perform end of execution tasks."""

+ Messages.send_end_exec()

+ self.page.set_proc(None)

+ self.update_exec_stop()

+ """

+ Call the action associated with the key press event.

+ Both the key value and the mask must have a match.

+

+ Args:

+ event: a gtk key press event

+

+ Returns:

+ true if handled

+ """

+ _used_mods_mask = reduce(lambda x, y: x | y, [mod_mask for keyval, mod_mask in _actions_keypress_dict], NO_MODS_MASK)

+ #extract the key value and the consumed modifiers

+ keyval, egroup, level, consumed = _keymap.translate_keyboard_state(

+ event.hardware_keycode, event.state, event.group)

+ #get the modifier mask and ignore irrelevant modifiers

+ mod_mask = event.state & ~consumed & _used_mods_mask

+ #look up the keypress and call the action

+ try: _actions_keypress_dict[(keyval, mod_mask)]()

+ except KeyError: return False #not handled

+ return True #handled here

+ """

+ A custom Action class based on gtk.Action.

+ Pass additional arguments such as keypresses.

+ Register actions and keypresses with this module.

+ """

+ def __init__(self, keypresses=(), name=None, label=None, tooltip=None, stock_id=None):

+ """

+ Create a new Action instance.

+

+ Args:

+ key_presses: a tuple of (keyval1, mod_mask1, keyval2, mod_mask2, ...)

+ the: regular gtk.Action parameters (defaults to None)

+ """

+ if name is None: name = label

+ gtk.Action.__init__(self,

+ name=name, label=label,

+ tooltip=tooltip, stock_id=stock_id,

+ )

+ #register this action

+ _all_actions_list.append(self)

+ for i in range(len(keypresses)/2):

+ keyval, mod_mask = keypresses[i*2:(i+1)*2]

+ #register this keypress

+ if _actions_keypress_dict.has_key((keyval, mod_mask)):

+ raise KeyError('keyval/mod_mask pair already registered "%s"'%str((keyval, mod_mask)))

+ _actions_keypress_dict[(keyval, mod_mask)] = self

+ #set the accelerator group, and accelerator path

+ #register the key name and mod mask with the accelerator path

+ if label is None: continue #dont register accel

+ accel_path = '<main>/'+self.get_name()

+ self.set_accel_group(get_accel_group())

+ self.set_accel_path(accel_path)

+ gtk.accel_map_add_entry(accel_path, keyval, mod_mask)

+ def __str__(self):

+ """

+ The string representation should be the name of the action id.

+ Try to find the action id for this action by searching this module.

+ """

+ try:

+ import Actions

+ return filter(lambda attr: getattr(Actions, attr) == self, dir(Actions))[0]

+ except: return self.get_name()

+ def __repr__(self): return str(self)

+ def __call__(self):

+ """

+ Emit the activate signal when called with ().

+ """

+ self.emit('activate')

+ label='_New',

+ tooltip='Create a new flow graph',

+ stock_id=gtk.STOCK_NEW,

+ keypresses=(gtk.keysyms.n, gtk.gdk.CONTROL_MASK),

+ label='_Open',

+ tooltip='Open an existing flow graph',

+ stock_id=gtk.STOCK_OPEN,

+ keypresses=(gtk.keysyms.o, gtk.gdk.CONTROL_MASK),

+ label='_Save',

+ tooltip='Save the current flow graph',

+ stock_id=gtk.STOCK_SAVE,

+ keypresses=(gtk.keysyms.s, gtk.gdk.CONTROL_MASK),

+ label='Save _As',

+ tooltip='Save the current flow graph as...',

+ stock_id=gtk.STOCK_SAVE_AS,

+ keypresses=(gtk.keysyms.s, gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK),

+ label='_Close',

+ tooltip='Close the current flow graph',

+ stock_id=gtk.STOCK_CLOSE,

+ keypresses=(gtk.keysyms.w, gtk.gdk.CONTROL_MASK),

+ label='_Quit',

+ tooltip='Quit program',

+ stock_id=gtk.STOCK_QUIT,

+ keypresses=(gtk.keysyms.q, gtk.gdk.CONTROL_MASK),

+ label='_Undo',

+ tooltip='Undo a change to the flow graph',

+ stock_id=gtk.STOCK_UNDO,

+ keypresses=(gtk.keysyms.z, gtk.gdk.CONTROL_MASK),

+ label='_Redo',

+ tooltip='Redo a change to the flow graph',

+ stock_id=gtk.STOCK_REDO,

+ keypresses=(gtk.keysyms.y, gtk.gdk.CONTROL_MASK),

+ label='_Delete',

+ tooltip='Delete the selected blocks',

+ stock_id=gtk.STOCK_DELETE,

+ keypresses=(gtk.keysyms.Delete, NO_MODS_MASK),

+ label='Rotate Counterclockwise',

+ tooltip='Rotate the selected blocks 90 degrees to the left',

+ stock_id=gtk.STOCK_GO_BACK,

+ keypresses=(gtk.keysyms.Left, NO_MODS_MASK),

+ label='Rotate Clockwise',

+ tooltip='Rotate the selected blocks 90 degrees to the right',

+ stock_id=gtk.STOCK_GO_FORWARD,

+ keypresses=(gtk.keysyms.Right, NO_MODS_MASK),

+ label='_Properties',

+ tooltip='Modify params for the selected block',

+ stock_id=gtk.STOCK_PROPERTIES,

+ keypresses=(gtk.keysyms.Return, NO_MODS_MASK),

+ label='E_nable',

+ tooltip='Enable the selected blocks',

+ stock_id=gtk.STOCK_CONNECT,

+ keypresses=(gtk.keysyms.e, NO_MODS_MASK),

+ label='D_isable',

+ tooltip='Disable the selected blocks',

+ stock_id=gtk.STOCK_DISCONNECT,

+ keypresses=(gtk.keysyms.d, NO_MODS_MASK),

+ label='C_reate Hier',

+ tooltip='Create hier block from selected blocks',

+ stock_id=gtk.STOCK_CONNECT,

+# keypresses=(gtk.keysyms.c, NO_MODS_MASK),

+ label='Cu_t',

+ tooltip='Cut',

+ stock_id=gtk.STOCK_CUT,

+ keypresses=(gtk.keysyms.x, gtk.gdk.CONTROL_MASK),

+ label='_Copy',

+ tooltip='Copy',

+ stock_id=gtk.STOCK_COPY,

+ keypresses=(gtk.keysyms.c, gtk.gdk.CONTROL_MASK),

+ label='_Paste',

+ tooltip='Paste',

+ stock_id=gtk.STOCK_PASTE,

+ keypresses=(gtk.keysyms.v, gtk.gdk.CONTROL_MASK),

+ label='_Errors',

+ tooltip='View flow graph errors',

+ stock_id=gtk.STOCK_DIALOG_ERROR,

+ label='_About',

+ tooltip='About this program',

+ stock_id=gtk.STOCK_ABOUT,

+ label='_Help',

+ tooltip='Usage tips',

+ stock_id=gtk.STOCK_HELP,

+ keypresses=(gtk.keysyms.F1, NO_MODS_MASK),

+ label='_Types',

+ tooltip='Types color mapping',

+ stock_id=gtk.STOCK_DIALOG_INFO,

+ label='_Generate',

+ tooltip='Generate the flow graph',

+ stock_id=gtk.STOCK_CONVERT,

+ keypresses=(gtk.keysyms.F5, NO_MODS_MASK),

+ label='_Execute',

+ tooltip='Execute the flow graph',

+ stock_id=gtk.STOCK_EXECUTE,

+ keypresses=(gtk.keysyms.F6, NO_MODS_MASK),

+ label='_Kill',

+ tooltip='Kill the flow graph',

+ stock_id=gtk.STOCK_STOP,

+ keypresses=(gtk.keysyms.F7, NO_MODS_MASK),

+ label='S_creen Capture',

+ tooltip='Create a screen capture of the flow graph',

+ stock_id=gtk.STOCK_PRINT,

+ keypresses=(gtk.keysyms.Print, NO_MODS_MASK),

+ keypresses=(gtk.keysyms.minus, NO_MODS_MASK, gtk.keysyms.KP_Subtract, NO_MODS_MASK),

+ keypresses=(gtk.keysyms.plus, NO_MODS_MASK, gtk.keysyms.KP_Add, NO_MODS_MASK),

+ keypresses=(gtk.keysyms.Down, NO_MODS_MASK),

+ keypresses=(gtk.keysyms.Up, NO_MODS_MASK),

+ label='Reload _Blocks',

+ tooltip='Reload Blocks',

+ stock_id=gtk.STOCK_REFRESH

+ label='Open H_ier',

+ tooltip='Open the source of the selected hierarchical block',

+ stock_id=gtk.STOCK_JUMP_TO,

+ label='Toggle So_urce Bus',

+ tooltip='Gang source ports into a single bus port',

+ stock_id=gtk.STOCK_JUMP_TO,

+ label='Toggle S_ink Bus',

+ tooltip='Gang sink ports into a single bus port',

+ stock_id=gtk.STOCK_JUMP_TO,

+ Actions.FLOW_GRAPH_NEW,

+ Actions.FLOW_GRAPH_OPEN,

+ Actions.FLOW_GRAPH_SAVE,

+ Actions.FLOW_GRAPH_CLOSE,

+ None,

+ Actions.FLOW_GRAPH_SCREEN_CAPTURE,

+ None,

+ Actions.BLOCK_CUT,

+ Actions.BLOCK_COPY,

+ Actions.BLOCK_PASTE,

+ Actions.ELEMENT_DELETE,

+ None,

+ Actions.FLOW_GRAPH_UNDO,

+ Actions.FLOW_GRAPH_REDO,

+ None,

+ Actions.ERRORS_WINDOW_DISPLAY,

+ Actions.FLOW_GRAPH_GEN,

+ Actions.FLOW_GRAPH_EXEC,

+ Actions.FLOW_GRAPH_KILL,

+ None,

+ Actions.BLOCK_ROTATE_CCW,

+ Actions.BLOCK_ROTATE_CW,

+ None,

+ Actions.BLOCK_ENABLE,

+ Actions.BLOCK_DISABLE,

+ (gtk.Action('File', '_File', None, None), [

+ Actions.FLOW_GRAPH_NEW,

+ Actions.FLOW_GRAPH_OPEN,

+ None,

+ Actions.FLOW_GRAPH_SAVE,

+ Actions.FLOW_GRAPH_SAVE_AS,

+ None,

+ Actions.FLOW_GRAPH_SCREEN_CAPTURE,

+ None,

+ Actions.FLOW_GRAPH_CLOSE,

+ Actions.APPLICATION_QUIT,

+ ]),

+ (gtk.Action('Edit', '_Edit', None, None), [

+ Actions.FLOW_GRAPH_UNDO,

+ Actions.FLOW_GRAPH_REDO,

+ None,

+ Actions.BLOCK_CUT,

+ Actions.BLOCK_COPY,

+ Actions.BLOCK_PASTE,

+ Actions.ELEMENT_DELETE,

+ None,

+ Actions.BLOCK_ROTATE_CCW,

+ Actions.BLOCK_ROTATE_CW,

+ None,

+ Actions.BLOCK_ENABLE,

+ Actions.BLOCK_DISABLE,

+ None,

+ Actions.BLOCK_PARAM_MODIFY,

+ ]),

+ (gtk.Action('View', '_View', None, None), [

+ Actions.ERRORS_WINDOW_DISPLAY,

+ ]),

+ (gtk.Action('Build', '_Build', None, None), [

+ Actions.FLOW_GRAPH_GEN,

+ Actions.FLOW_GRAPH_EXEC,

+ Actions.FLOW_GRAPH_KILL,

+ ]),

+ (gtk.Action('Help', '_Help', None, None), [

+ Actions.HELP_WINDOW_DISPLAY,

+ Actions.TYPES_WINDOW_DISPLAY,

+ None,

+ Actions.ABOUT_WINDOW_DISPLAY,

+ ]),

+ """The gtk toolbar with actions added from the toolbar list."""

+ def __init__(self):

+ """

+ Parse the list of action names in the toolbar list.

+ Look up the action for each name in the action list and add it to the toolbar.

+ """

+ gtk.Toolbar.__init__(self)

+ self.set_style(gtk.TOOLBAR_ICONS)

+ for action in TOOLBAR_LIST:

+ if action: #add a tool item

+ self.add(action.create_tool_item())

+ #this reset of the tooltip property is required (after creating the tool item) for the tooltip to show

+ action.set_property('tooltip', action.get_property('tooltip'))

+ else: self.add(gtk.SeparatorToolItem())

+ """The gtk menu bar with actions added from the menu bar list."""

+ def __init__(self):

+ """

+ Parse the list of submenus from the menubar list.

+ For each submenu, get a list of action names.

+ Look up the action for each name in the action list and add it to the submenu.

+ Add the submenu to the menu bar.

+ """

+ gtk.MenuBar.__init__(self)

+ for main_action, actions in MENU_BAR_LIST:

+ #create the main menu item

+ main_menu_item = main_action.create_menu_item()

+ self.append(main_menu_item)

+ #create the menu

+ main_menu = gtk.Menu()

+ main_menu_item.set_submenu(main_menu)

+ for action in actions:

+ if action: #append a menu item

+ main_menu.append(action.create_menu_item())

+ else: main_menu.append(gtk.SeparatorMenuItem())

+ main_menu.show_all() #this show all is required for the separators to show

+ BLOCK_LABEL_PADDING, \

+ PORT_SEPARATION, LABEL_SEPARATION, \

+ PORT_BORDER_SEPARATION, POSSIBLE_ROTATIONS

+ """The graphical signal block."""

+ def __init__(self):

+ """

+ Block contructor.

+ Add graphics related params to the block.

+ """

+ #add the position param

+ self.get_params().append(self.get_parent().get_parent().Param(

+ block=self,

+ n=odict({

+ 'name': 'GUI Coordinate',

+ 'key': '_coordinate',

+ 'type': 'raw',

+ 'value': '(0, 0)',

+ 'hide': 'all',

+ })

+ ))

+ self.get_params().append(self.get_parent().get_parent().Param(

+ block=self,

+ n=odict({

+ 'name': 'GUI Rotation',

+ 'key': '_rotation',

+ 'type': 'raw',

+ 'value': '0',

+ 'hide': 'all',

+ })

+ ))

+ Element.__init__(self)

+ def get_coordinate(self):

+ """

+ Get the coordinate from the position param.

+

+ Returns:

+ the coordinate tuple (x, y) or (0, 0) if failure

+ """

+ try: #should evaluate to tuple

+ coor = eval(self.get_param('_coordinate').get_value())

+ x, y = map(int, coor)

+ fgW,fgH = self.get_parent().get_size()

+ if x <= 0:

+ x = 0

+ elif x >= fgW - BORDER_PROXIMITY_SENSITIVITY:

+ x = fgW - BORDER_PROXIMITY_SENSITIVITY

+ if y <= 0:

+ y = 0

+ elif y >= fgH - BORDER_PROXIMITY_SENSITIVITY:

+ y = fgH - BORDER_PROXIMITY_SENSITIVITY

+ return (x, y)

+ except:

+ self.set_coordinate((0, 0))

+ return (0, 0)

+ def set_coordinate(self, coor):

+ """

+ Set the coordinate into the position param.

+

+ Args:

+ coor: the coordinate tuple (x, y)

+ """

+ self.get_param('_coordinate').set_value(str(coor))

+ def get_rotation(self):

+ """

+ Get the rotation from the position param.

+

+ Returns:

+ the rotation in degrees or 0 if failure

+ """

+ try: #should evaluate to dict

+ rotation = eval(self.get_param('_rotation').get_value())

+ return int(rotation)

+ except:

+ self.set_rotation(POSSIBLE_ROTATIONS[0])

+ return POSSIBLE_ROTATIONS[0]

+ def set_rotation(self, rot):

+ """

+ Set the rotation into the position param.

+

+ Args:

+ rot: the rotation in degrees

+ """

+ self.get_param('_rotation').set_value(str(rot))

+ def create_shapes(self):

+ """Update the block, parameters, and ports when a change occurs."""

+ Element.create_shapes(self)

+ if self.is_horizontal(): self.add_area((0, 0), (self.W, self.H))

+ elif self.is_vertical(): self.add_area((0, 0), (self.H, self.W))

+ def create_labels(self):

+ """Create the labels for the signal block."""

+ Element.create_labels(self)

+ self._bg_color = self.get_enabled() and Colors.BLOCK_ENABLED_COLOR or Colors.BLOCK_DISABLED_COLOR

+ layouts = list()

+ #create the main layout

+ layout = gtk.DrawingArea().create_pango_layout('')

+ layouts.append(layout)

+ layout.set_markup(Utils.parse_template(BLOCK_MARKUP_TMPL, block=self))

+ self.label_width, self.label_height = layout.get_pixel_size()

+ #display the params

+ markups = [param.get_markup() for param in self.get_params() if param.get_hide() not in ('all', 'part')]

+ if markups:

+ layout = gtk.DrawingArea().create_pango_layout('')

+ layout.set_spacing(LABEL_SEPARATION*pango.SCALE)

+ layout.set_markup('\n'.join(markups))

+ layouts.append(layout)

+ w,h = layout.get_pixel_size()

+ self.label_width = max(w, self.label_width)

+ self.label_height += h + LABEL_SEPARATION

+ width = self.label_width

+ height = self.label_height

+ #setup the pixmap

+ pixmap = self.get_parent().new_pixmap(width, height)

+ gc = pixmap.new_gc()

+ gc.set_foreground(self._bg_color)

+ pixmap.draw_rectangle(gc, True, 0, 0, width, height)

+ #draw the layouts

+ h_off = 0

+ for i,layout in enumerate(layouts):

+ w,h = layout.get_pixel_size()

+ if i == 0: w_off = (width-w)/2

+ else: w_off = 0

+ pixmap.draw_layout(gc, w_off, h_off, layout)

+ h_off = h + h_off + LABEL_SEPARATION

+ #create vertical and horizontal pixmaps

+ self.horizontal_label = pixmap

+ if self.is_vertical():

+ self.vertical_label = self.get_parent().new_pixmap(height, width)

+ Utils.rotate_pixmap(gc, self.horizontal_label, self.vertical_label)

+ #calculate width and height needed

+ self.W = self.label_width + 2*BLOCK_LABEL_PADDING

+ self.H = max(*(

+ [self.label_height+2*BLOCK_LABEL_PADDING] + [2*PORT_BORDER_SEPARATION + \

+ sum([port.H + PORT_SEPARATION for port in ports]) - PORT_SEPARATION

+ for ports in (self.get_sources_gui(), self.get_sinks_gui())] +

+ [4*PORT_BORDER_SEPARATION + \

+ sum([(port.H) + PORT_SEPARATION for port in ports]) - PORT_SEPARATION

+ for ports in ([i for i in self.get_sources_gui() if i.get_type() == 'bus'], [i for i in self.get_sinks_gui() if i.get_type() == 'bus'])]

+ ))

+ def draw(self, gc, window):

+ """

+ Draw the signal block with label and inputs/outputs.

+

+ Args:

+ gc: the graphics context

+ window: the gtk window to draw on

+ """

+ x, y = self.get_coordinate()

+ #draw main block

+ Element.draw(

+ self, gc, window, bg_color=self._bg_color,

+ border_color=self.is_highlighted() and Colors.HIGHLIGHT_COLOR or Colors.BORDER_COLOR,

+ )

+ #draw label image

+ if self.is_horizontal():

+ window.draw_drawable(gc, self.horizontal_label, 0, 0, x+BLOCK_LABEL_PADDING, y+(self.H-self.label_height)/2, -1, -1)

+ elif self.is_vertical():

+ window.draw_drawable(gc, self.vertical_label, 0, 0, x+(self.H-self.label_height)/2, y+BLOCK_LABEL_PADDING, -1, -1)

+ #draw ports

+ for port in self.get_ports_gui():

+ port.draw(gc, window)

+ def what_is_selected(self, coor, coor_m=None):

+ """

+ Get the element that is selected.

+

+ Args:

+ coor: the (x,y) tuple

+ coor_m: the (x_m, y_m) tuple

+

+ Returns:

+ this block, a port, or None

+ """

+ for port in self.get_ports_gui():

+ port_selected = port.what_is_selected(coor, coor_m)

+ if port_selected: return port_selected

+ return Element.what_is_selected(self, coor, coor_m)

+ """The block selection panel."""

+

+ def __init__(self, platform, get_flow_graph):

+ """

+ BlockTreeWindow constructor.

+ Create a tree view of the possible blocks in the platform.

+ The tree view nodes will be category names, the leaves will be block names.

+ A mouse double click or button press action will trigger the add block event.

+

+ Args:

+ platform: the particular platform will all block prototypes

+ get_flow_graph: get the selected flow graph

+ """

+ gtk.VBox.__init__(self)

+ self.platform = platform

+ self.get_flow_graph = get_flow_graph

+ #make the tree model for holding blocks

+ self.treestore = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)

+ self.treeview = gtk.TreeView(self.treestore)

+ self.treeview.set_enable_search(False) #disable pop up search box

+ self.treeview.add_events(gtk.gdk.BUTTON_PRESS_MASK)

+ self.treeview.connect('button-press-event', self._handle_mouse_button_press)

+ selection = self.treeview.get_selection()

+ selection.set_mode('single')

+ selection.connect('changed', self._handle_selection_change)

+ renderer = gtk.CellRendererText()

+ column = gtk.TreeViewColumn('Blocks', renderer, text=NAME_INDEX)

+ self.treeview.append_column(column)

+ #setup the search

+ self.treeview.set_enable_search(True)

+ self.treeview.set_search_equal_func(self._handle_search)

+ #try to enable the tooltips (available in pygtk 2.12 and above)

+ try: self.treeview.set_tooltip_column(DOC_INDEX)

+ except: pass

+ column.set_sort_column_id(0)

+ #setup drag and drop

+ self.treeview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, DND_TARGETS, gtk.gdk.ACTION_COPY)

+ self.treeview.connect('drag-data-get', self._handle_drag_get_data)

+ #make the scrolled window to hold the tree view

+ scrolled_window = gtk.ScrolledWindow()

+ scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)

+ scrolled_window.add_with_viewport(self.treeview)

+ scrolled_window.set_size_request(DEFAULT_BLOCKS_WINDOW_WIDTH, -1)

+ self.pack_start(scrolled_window)

+ #add button

+ self.add_button = gtk.Button(None, gtk.STOCK_ADD)

+ self.add_button.connect('clicked', self._handle_add_button)

+ self.pack_start(self.add_button, False)

+ #map categories to iters, automatic mapping for root

+ self._categories = {tuple(): None}

+ #add blocks and categories

+ self.platform.load_block_tree(self)

+ #initialize

+ self._update_add_button()

+

+ def clear(self):

+ self.treestore.clear();

+ self._categories = {tuple(): None}

+

+

+ ############################################################

+ ## Block Tree Methods

+ ############################################################

+ def add_block(self, category, block=None):

+ """

+ Add a block with category to this selection window.

+ Add only the category when block is None.

+

+ Args:

+ category: the category list or path string

+ block: the block object or None

+ """

+ if isinstance(category, str): category = category.split('/')

+ category = tuple(filter(lambda x: x, category)) #tuple is hashable

+ #add category and all sub categories

+ for i, cat_name in enumerate(category):

+ sub_category = category[:i+1]

+ if sub_category not in self._categories:

+ iter = self.treestore.insert_before(self._categories[sub_category[:-1]], None)

+ self.treestore.set_value(iter, NAME_INDEX, '[ %s ]'%cat_name)

+ self.treestore.set_value(iter, KEY_INDEX, '')

+ self.treestore.set_value(iter, DOC_INDEX, Utils.parse_template(CAT_MARKUP_TMPL, cat=cat_name))

+ self._categories[sub_category] = iter

+ #add block

+ if block is None: return

+ iter = self.treestore.insert_before(self._categories[category], None)

+ self.treestore.set_value(iter, NAME_INDEX, block.get_name())

+ self.treestore.set_value(iter, KEY_INDEX, block.get_key())

+ self.treestore.set_value(iter, DOC_INDEX, Utils.parse_template(DOC_MARKUP_TMPL, doc=block.get_doc()))

+

+ ############################################################

+ ## Helper Methods

+ ############################################################

+ def _get_selected_block_key(self):

+ """

+ Get the currently selected block key.

+

+ Returns:

+ the key of the selected block or a empty string

+ """

+ selection = self.treeview.get_selection()

+ treestore, iter = selection.get_selected()

+ return iter and treestore.get_value(iter, KEY_INDEX) or ''

+

+ def _update_add_button(self):

+ """

+ Update the add button's sensitivity.

+ The button should be active only if a block is selected.

+ """

+ key = self._get_selected_block_key()

+ self.add_button.set_sensitive(bool(key))

+

+ def _add_selected_block(self):

+ """

+ Add the selected block with the given key to the flow graph.

+ """

+ key = self._get_selected_block_key()

+ if key: self.get_flow_graph().add_new_block(key)

+

+ ############################################################

+ ## Event Handlers

+ ############################################################

+ def _handle_search(self, model, column, key, iter):

+ #determine which blocks match the search key

+ blocks = self.get_flow_graph().get_parent().get_blocks()

+ matching_blocks = filter(lambda b: key in b.get_key() or key in b.get_name().lower(), blocks)

+ #remove the old search category

+ try: self.treestore.remove(self._categories.pop((self._search_category, )))

+ except (KeyError, AttributeError): pass #nothing to remove

+ #create a search category

+ if not matching_blocks: return

+ self._search_category = 'Search: %s'%key

+ for block in matching_blocks: self.add_block(self._search_category, block)

+ #expand the search category

+ path = self.treestore.get_path(self._categories[(self._search_category, )])

+ self.treeview.collapse_all()

+ self.treeview.expand_row(path, open_all=False)

+

+ def _handle_drag_get_data(self, widget, drag_context, selection_data, info, time):

+ """

+ Handle a drag and drop by setting the key to the selection object.

+ This will call the destination handler for drag and drop.

+ Only call set when the key is valid to ignore DND from categories.

+ """

+ key = self._get_selected_block_key()

+ if key: selection_data.set(selection_data.target, 8, key)

+

+ def _handle_mouse_button_press(self, widget, event):

+ """

+ Handle the mouse button press.

+ If a left double click is detected, call add selected block.

+ """

+ if event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS:

+ self._add_selected_block()

+

+ def _handle_selection_change(self, selection):

+ """

+ Handle a selection change in the tree view.

+ If a selection changes, set the add button sensitive.

+ """

+ self._update_add_button()

+

+ def _handle_add_button(self, widget):

+ """

+ Handle the add button clicked signal.

+ Call add selected block.

+ """

+ self._add_selected_block()

+ """

+ A graphical connection for ports.

+ The connection has 2 parts, the arrow and the wire.

+ The coloring of the arrow and wire exposes the status of 3 states:

+ enabled/disabled, valid/invalid, highlighted/non-highlighted.

+ The wire coloring exposes the enabled and highlighted states.

+ The arrow coloring exposes the enabled and valid states.

+ """

+ def __init__(self): Element.__init__(self)

+ def get_coordinate(self):

+ """

+ Get the 0,0 coordinate.

+ Coordinates are irrelevant in connection.

+

+ Returns:

+ 0, 0

+ """

+ return (0, 0)

+ def get_rotation(self):

+ """

+ Get the 0 degree rotation.

+ Rotations are irrelevant in connection.

+

+ Returns:

+ 0

+ """

+ return 0

+ def create_shapes(self):

+ """Precalculate relative coordinates."""

+ Element.create_shapes(self)

+ self._sink_rot = None

+ self._source_rot = None

+ self._sink_coor = None

+ self._source_coor = None

+ #get the source coordinate

+ try:

+ connector_length = self.get_source().get_connector_length()

+ except:

+ return

+ self.x1, self.y1 = Utils.get_rotated_coordinate((connector_length, 0), self.get_source().get_rotation())

+ #get the sink coordinate

+ connector_length = self.get_sink().get_connector_length() + CONNECTOR_ARROW_HEIGHT

+ self.x2, self.y2 = Utils.get_rotated_coordinate((-connector_length, 0), self.get_sink().get_rotation())

+ #build the arrow

+ self.arrow = [(0, 0),

+ Utils.get_rotated_coordinate((-CONNECTOR_ARROW_HEIGHT, -CONNECTOR_ARROW_BASE/2), self.get_sink().get_rotation()),

+ Utils.get_rotated_coordinate((-CONNECTOR_ARROW_HEIGHT, CONNECTOR_ARROW_BASE/2), self.get_sink().get_rotation()),

+ ]

+ self._update_after_move()

+ if not self.get_enabled(): self._arrow_color = Colors.CONNECTION_DISABLED_COLOR

+ elif not self.is_valid(): self._arrow_color = Colors.CONNECTION_ERROR_COLOR

+ else: self._arrow_color = Colors.CONNECTION_ENABLED_COLOR

+ def _update_after_move(self):

+ """Calculate coordinates."""

+ self.clear() #FIXME do i want this here?

+ #source connector

+ source = self.get_source()

+ X, Y = source.get_connector_coordinate()

+ x1, y1 = self.x1 + X, self.y1 + Y

+ self.add_line((x1, y1), (X, Y))

+ #sink connector

+ sink = self.get_sink()

+ X, Y = sink.get_connector_coordinate()

+ x2, y2 = self.x2 + X, self.y2 + Y

+ self.add_line((x2, y2), (X, Y))

+ #adjust arrow

+ self._arrow = [(x+X, y+Y) for x,y in self.arrow]

+ #add the horizontal and vertical lines in this connection

+ if abs(source.get_connector_direction() - sink.get_connector_direction()) == 180:

+ #2 possible point sets to create a 3-line connector

+ mid_x, mid_y = (x1 + x2)/2.0, (y1 + y2)/2.0

+ points = [((mid_x, y1), (mid_x, y2)), ((x1, mid_y), (x2, mid_y))]

+ #source connector -> points[0][0] should be in the direction of source (if possible)

+ if Utils.get_angle_from_coordinates((x1, y1), points[0][0]) != source.get_connector_direction(): points.reverse()

+ #points[0][0] -> sink connector should not be in the direction of sink

+ if Utils.get_angle_from_coordinates(points[0][0], (x2, y2)) == sink.get_connector_direction(): points.reverse()

+ #points[0][0] -> source connector should not be in the direction of source

+ if Utils.get_angle_from_coordinates(points[0][0], (x1, y1)) == source.get_connector_direction(): points.reverse()

+ #create 3-line connector

+ p1, p2 = map(int, points[0][0]), map(int, points[0][1])

+ self.add_line((x1, y1), p1)

+ self.add_line(p1, p2)

+ self.add_line((x2, y2), p2)

+ else:

+ #2 possible points to create a right-angled connector

+ points = [(x1, y2), (x2, y1)]

+ #source connector -> points[0] should be in the direction of source (if possible)

+ if Utils.get_angle_from_coordinates((x1, y1), points[0]) != source.get_connector_direction(): points.reverse()

+ #points[0] -> sink connector should not be in the direction of sink

+ if Utils.get_angle_from_coordinates(points[0], (x2, y2)) == sink.get_connector_direction(): points.reverse()

+ #points[0] -> source connector should not be in the direction of source

+ if Utils.get_angle_from_coordinates(points[0], (x1, y1)) == source.get_connector_direction(): points.reverse()

+ #create right-angled connector

+ self.add_line((x1, y1), points[0])

+ self.add_line((x2, y2), points[0])

+ def draw(self, gc, window):

+ """

+ Draw the connection.

+

+ Args:

+ gc: the graphics context

+ window: the gtk window to draw on

+ """

+ sink = self.get_sink()

+ source = self.get_source()

+ #check for changes

+ if self._sink_rot != sink.get_rotation() or self._source_rot != source.get_rotation(): self.create_shapes()

+ elif self._sink_coor != sink.get_coordinate() or self._source_coor != source.get_coordinate():

+ try:

+ self._update_after_move()

+ except:

+ return

+ #cache values

+ self._sink_rot = sink.get_rotation()

+ self._source_rot = source.get_rotation()

+ self._sink_coor = sink.get_coordinate()

+ self._source_coor = source.get_coordinate()

+ #draw

+ if self.is_highlighted(): border_color = Colors.HIGHLIGHT_COLOR

+ elif self.get_enabled(): border_color = Colors.CONNECTION_ENABLED_COLOR

+ else: border_color = Colors.CONNECTION_DISABLED_COLOR

+ Element.draw(self, gc, window, bg_color=None, border_color=border_color)

+ #draw arrow on sink port

+ try:

+ gc.set_foreground(self._arrow_color)

+ window.draw_polygon(gc, True, self._arrow)

+ except:

+ return

+ """A non editable gtk text view."""

+

+ def __init__(self, text=''):

+ """

+ TextDisplay constructor.

+

+ Args:

+ text: the text to display (string)

+ """

+ text_buffer = gtk.TextBuffer()

+ text_buffer.set_text(text)

+ self.set_text = text_buffer.set_text

+ self.insert = lambda line: text_buffer.insert(text_buffer.get_end_iter(), line)

+ gtk.TextView.__init__(self, text_buffer)

+ self.set_editable(False)

+ self.set_cursor_visible(False)

+ self.set_wrap_mode(gtk.WRAP_WORD_CHAR)

+ """

+ Create a modal message dialog and run it.

+

+ Args:

+ type: the type of message: gtk.MESSAGE_INFO, gtk.MESSAGE_WARNING, gtk.MESSAGE_QUESTION or gtk.MESSAGE_ERROR

+ buttons: the predefined set of buttons to use:

+ gtk.BUTTONS_NONE, gtk.BUTTONS_OK, gtk.BUTTONS_CLOSE, gtk.BUTTONS_CANCEL, gtk.BUTTONS_YES_NO, gtk.BUTTONS_OK_CANCEL

+

+ Args:

+ tittle: the title of the window (string)

+ markup: the message text with pango markup

+

+ Returns:

+ the gtk response from run()

+ """

+ message_dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL, type, buttons)

+ if title: message_dialog.set_title(title)

+ if markup: message_dialog.set_markup(markup)

+ response = message_dialog.run()

+ message_dialog.destroy()

+ return response

+ type=gtk.MESSAGE_ERROR,

+ buttons=gtk.BUTTONS_CLOSE,

+ title='Flow Graph Errors',

+ markup=Utils.parse_template(ERRORS_MARKUP_TMPL, errors=flowgraph.get_error_messages()),

+ """A cute little about dialog."""

+

+ def __init__(self, platform):

+ """AboutDialog constructor."""

+ gtk.AboutDialog.__init__(self)

+ self.set_name(platform.get_name())

+ self.set_version(platform.get_version())

+ self.set_license(platform.get_license())

+ self.set_copyright(platform.get_license().splitlines()[0])

+ self.set_website(platform.get_website())

+ self.run()

+ self.destroy()

+ type=gtk.MESSAGE_INFO,

+ buttons=gtk.BUTTONS_CLOSE,

+ title='Help',

+ markup="""\

+ #set $max_len = max([len(color[0]) for color in $colors]) + 10

+ #for $title, $color_spec in $colors

+ #end for

+ type=gtk.MESSAGE_INFO,

+ buttons=gtk.BUTTONS_CLOSE,

+ title='Types',

+ markup=Utils.parse_template(COLORS_DIALOG_MARKUP_TMPL, colors=platform.get_colors()))

+ """

+ DrawingArea is the gtk pixel map that graphical elements may draw themselves on.

+ The drawing area also responds to mouse and key events.

+ """

+ def __init__(self, flow_graph):

+ """

+ DrawingArea contructor.

+ Connect event handlers.

+

+ Args:

+ main_window: the main_window containing all flow graphs

+ """

+ self.ctrl_mask = False

+ 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)

+ self.connect('button-press-event', self._handle_mouse_button_press)

+ self.connect('button-release-event', self._handle_mouse_button_release)

+ self.add_events(

+ gtk.gdk.BUTTON_PRESS_MASK | \

+ gtk.gdk.POINTER_MOTION_MASK | \

+ gtk.gdk.BUTTON_RELEASE_MASK | \

+ gtk.gdk.LEAVE_NOTIFY_MASK | \

+ gtk.gdk.ENTER_NOTIFY_MASK

+ )

+ #setup drag and drop

+ self.drag_dest_set(gtk.DEST_DEFAULT_ALL, DND_TARGETS, gtk.gdk.ACTION_COPY)

+ self.connect('drag-data-received', self._handle_drag_data_received)

+ #setup the focus flag

+ self._focus_flag = False

+ self.get_focus_flag = lambda: self._focus_flag

+ 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)

+ def get_pixbuf(self):

+ width, height = self._pixmap.get_size()

+ pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, 0, 8, width, height)

+ pixbuf.get_from_drawable(self._pixmap, self._pixmap.get_colormap(), 0, 0, 0, 0, width, height)

+ return pixbuf

+ ##########################################################################

+ ## Handlers

+ ##########################################################################

+ def _handle_drag_data_received(self, widget, drag_context, x, y, selection_data, info, time):

+ """

+ Handle a drag and drop by adding a block at the given coordinate.

+ """

+ 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

+ if event.button == 1: self._flow_graph.handle_mouse_selector_press(

+ double_click=(event.type == gtk.gdk._2BUTTON_PRESS),

+ coordinate=(event.x, event.y),

+ )

+ if event.button == 3: self._flow_graph.handle_mouse_context_press(

+ coordinate=(event.x, event.y),

+ event=event,

+ )

+ def _handle_mouse_button_release(self, widget, event):

+ """

+ Forward button release information to the flow graph.

+ """

+ self.ctrl_mask = event.state & gtk.gdk.CONTROL_MASK

+ if event.button == 1: self._flow_graph.handle_mouse_selector_release(

+ coordinate=(event.x, event.y),

+ )

+ def _handle_mouse_motion(self, widget, event):

+ """

+ Forward mouse motion information to the flow graph.

+ """

+ self.ctrl_mask = event.state & gtk.gdk.CONTROL_MASK

+ 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.

+ Create a new pixmap for background buffer.

+ """

+ self._pixmap = self.new_pixmap(*self.get_size_request())

+ def _handle_window_expose(self, widget, event):

+ """

+ Called when window is exposed, or queue_draw is called.

+ Double buffering: draw to pixmap, then draw pixmap to window.

+ """

+ gc = self.window.new_gc()

+ self._flow_graph.draw(gc, self._pixmap)

+ self.window.draw_drawable(gc, self._pixmap, 0, 0, 0, 0, -1, -1)

+ """

+ GraphicalElement is the base class for all graphical elements.

+ It contains an X,Y coordinate, a list of rectangular areas that the element occupies,

+ and methods to detect selection of those areas.

+ """

+ def __init__(self):

+ """

+ Make a new list of rectangular areas and lines, and set the coordinate and the rotation.

+ """

+ self.set_rotation(POSSIBLE_ROTATIONS[0])

+ self.set_coordinate((0, 0))

+ self.clear()

+ self.set_highlighted(False)

+ def is_horizontal(self, rotation=None):

+ """

+ Is this element horizontal?

+ If rotation is None, use this element's rotation.

+

+ Args:

+ rotation: the optional rotation

+

+ Returns:

+ true if rotation is horizontal

+ """

+ rotation = rotation or self.get_rotation()

+ return rotation in (0, 180)

+ def is_vertical(self, rotation=None):

+ """

+ Is this element vertical?

+ If rotation is None, use this element's rotation.

+

+ Args:

+ rotation: the optional rotation

+

+ Returns:

+ true if rotation is vertical

+ """

+ rotation = rotation or self.get_rotation()

+ return rotation in (90, 270)

+ def create_labels(self):

+ """

+ Create labels (if applicable) and call on all children.

+ Call this base method before creating labels in the element.

+ """

+ for child in self.get_children():child.create_labels()

+ def create_shapes(self):

+ """

+ Create shapes (if applicable) and call on all children.

+ Call this base method before creating shapes in the element.

+ """

+ self.clear()

+ for child in self.get_children(): child.create_shapes()

+ def draw(self, gc, window, border_color, bg_color):

+ """

+ Draw in the given window.

+

+ Args:

+ gc: the graphics context

+ window: the gtk window to draw on

+ border_color: the color for lines and rectangle borders

+ bg_color: the color for the inside of the rectangle

+ """

+ X,Y = self.get_coordinate()

+ for (rX,rY),(W,H) in self._areas_list:

+ aX = X + rX

+ aY = Y + rY

+ gc.set_foreground(bg_color)

+ window.draw_rectangle(gc, True, aX, aY, W, H)

+ gc.set_foreground(border_color)

+ window.draw_rectangle(gc, False, aX, aY, W, H)

+ for (x1, y1),(x2, y2) in self._lines_list:

+ gc.set_foreground(border_color)

+ window.draw_line(gc, X+x1, Y+y1, X+x2, Y+y2)

+ def rotate(self, rotation):

+ """

+ Rotate all of the areas by 90 degrees.

+

+ Args:

+ rotation: multiple of 90 degrees

+ """

+ self.set_rotation((self.get_rotation() + rotation)%360)

+ def clear(self):

+ """Empty the lines and areas."""

+ self._areas_list = list()

+ self._lines_list = list()

+ def set_coordinate(self, coor):

+ """

+ Set the reference coordinate.

+

+ Args:

+ coor: the coordinate tuple (x,y)

+ """

+ self.coor = coor

+ def get_parent(self):

+ """

+ Get the parent of this element.

+

+ Returns:

+ the parent

+ """

+ return self.parent

+ def set_highlighted(self, highlighted):

+ """

+ Set the highlight status.

+

+ Args:

+ highlighted: true to enable highlighting

+ """

+ self.highlighted = highlighted

+ def is_highlighted(self):

+ """

+ Get the highlight status.

+

+ Returns:

+ true if highlighted

+ """

+ return self.highlighted

+ def get_coordinate(self):

+ """Get the coordinate.

+

+ Returns:

+ the coordinate tuple (x,y)

+ """

+ return self.coor

+ def move(self, delta_coor):

+ """

+ Move the element by adding the delta_coor to the current coordinate.

+

+ Args:

+ delta_coor: (delta_x,delta_y) tuple

+ """

+ deltaX, deltaY = delta_coor

+ X, Y = self.get_coordinate()

+ self.set_coordinate((X+deltaX, Y+deltaY))

+ def add_area(self, rel_coor, area):

+ """

+ Add an area to the area list.

+ An area is actually a coordinate relative to the main coordinate

+ with a width/height pair relative to the area coordinate.

+ A positive width is to the right of the coordinate.

+ A positive height is above the coordinate.

+ The area is associated with a rotation.

+

+ Args:

+ rel_coor: (x,y) offset from this element's coordinate

+ area: (width,height) tuple

+ """

+ self._areas_list.append((rel_coor, area))

+ def add_line(self, rel_coor1, rel_coor2):

+ """

+ Add a line to the line list.

+ A line is defined by 2 relative coordinates.

+ Lines must be horizontal or vertical.

+ The line is associated with a rotation.

+

+ Args:

+ rel_coor1: relative (x1,y1) tuple

+ rel_coor2: relative (x2,y2) tuple

+ """

+ self._lines_list.append((rel_coor1, rel_coor2))

+ def what_is_selected(self, coor, coor_m=None):

+ """

+ One coordinate specified:

+ Is this element selected at given coordinate?

+ ie: is the coordinate encompassed by one of the areas or lines?

+ Both coordinates specified:

+ Is this element within the rectangular region defined by both coordinates?

+ ie: do any area corners or line endpoints fall within the region?

+

+ Args:

+ coor: the selection coordinate, tuple x, y

+ coor_m: an additional selection coordinate.

+

+ Returns:

+ self if one of the areas/lines encompasses coor, else None.

+ """

+ #function to test if p is between a and b (inclusive)

+ in_between = lambda p, a, b: p >= min(a, b) and p <= max(a, b)

+ #relative coordinate

+ x, y = [a-b for a,b in zip(coor, self.get_coordinate())]

+ if coor_m:

+ x_m, y_m = [a-b for a,b in zip(coor_m, self.get_coordinate())]

+ #handle rectangular areas

+ for (x1,y1), (w,h) in self._areas_list:

+ if in_between(x1, x, x_m) and in_between(y1, y, y_m) or \

+ in_between(x1+w, x, x_m) and in_between(y1, y, y_m) or \

+ in_between(x1, x, x_m) and in_between(y1+h, y, y_m) or \

+ in_between(x1+w, x, x_m) and in_between(y1+h, y, y_m):

+ return self

+ #handle horizontal or vertical lines

+ for (x1, y1), (x2, y2) in self._lines_list:

+ if in_between(x1, x, x_m) and in_between(y1, y, y_m) or \

+ in_between(x2, x, x_m) and in_between(y2, y, y_m):

+ return self

+ return None

+ else:

+ #handle rectangular areas

+ for (x1,y1), (w,h) in self._areas_list:

+ if in_between(x, x1, x1+w) and in_between(y, y1, y1+h): return self

+ #handle horizontal or vertical lines

+ for (x1, y1), (x2, y2) in self._lines_list:

+ if x1 == x2: x1, x2 = x1-LINE_SELECT_SENSITIVITY, x2+LINE_SELECT_SENSITIVITY

+ if y1 == y2: y1, y2 = y1-LINE_SELECT_SENSITIVITY, y2+LINE_SELECT_SENSITIVITY

+ if in_between(x, x1, x2) and in_between(y, y1, y2): return self

+ return None

+ def get_rotation(self):

+ """

+ Get the rotation in degrees.

+

+ Returns:

+ the rotation

+ """

+ return self.rotation

+ def set_rotation(self, rotation):

+ """

+ Set the rotation in degrees.

+

+ Args:

+ rotation: the rotation"""

+ if rotation not in POSSIBLE_ROTATIONS:

+ raise Exception('"%s" is not one of the possible rotations: (%s)'%(rotation, POSSIBLE_ROTATIONS))

+ self.rotation = rotation

+ DEFAULT_FILE_PATH, IMAGE_FILE_EXTENSION, \

+ NEW_FLOGRAPH_TITLE

+ filter = gtk.FileFilter()

+ filter.set_name('Flow Graph Files')

+ filter.add_pattern('*'+Preferences.file_extension())

+ return filter

+ filter = gtk.FileFilter()

+ filter.set_name('Image Files')

+ filter.add_pattern('*'+IMAGE_FILE_EXTENSION)

+ return filter

+ filter = gtk.FileFilter()

+ filter.set_name('All Files')

+ filter.add_pattern('*')

+ return filter

+ """

+ A wrapper class for the gtk file chooser dialog.

+ Implement a file chooser dialog with only necessary parameters.

+ """

+

+ def __init__(self, action, title):

+ """

+ FileDialogHelper contructor.

+ Create a save or open dialog with cancel and ok buttons.

+ Use standard settings: no multiple selection, local files only, and the * filter.

+

+ Args:

+ action: gtk.FILE_CHOOSER_ACTION_OPEN or gtk.FILE_CHOOSER_ACTION_SAVE

+ title: the title of the dialog (string)

+ """

+ ok_stock = {gtk.FILE_CHOOSER_ACTION_OPEN : 'gtk-open', gtk.FILE_CHOOSER_ACTION_SAVE : 'gtk-save'}[action]

+ gtk.FileChooserDialog.__init__(self, title, None, action, ('gtk-cancel', gtk.RESPONSE_CANCEL, ok_stock, gtk.RESPONSE_OK))

+ self.set_select_multiple(False)

+ self.set_local_only(True)

+ self.add_filter(get_all_files_filter())

+ """A dialog box to save or open flow graph files. This is a base class, do not use."""

+

+ def __init__(self, current_file_path=''):

+ """

+ FileDialog constructor.

+

+ Args:

+ current_file_path: the current directory or path to the open flow graph

+ """

+ if not current_file_path: current_file_path = path.join(DEFAULT_FILE_PATH, NEW_FLOGRAPH_TITLE + Preferences.file_extension())

+ if self.type == OPEN_FLOW_GRAPH:

+ FileDialogHelper.__init__(self, gtk.FILE_CHOOSER_ACTION_OPEN, 'Open a Flow Graph from a File...')

+ self.add_and_set_filter(get_flow_graph_files_filter())

+ self.set_select_multiple(True)

+ elif self.type == SAVE_FLOW_GRAPH:

+ FileDialogHelper.__init__(self, gtk.FILE_CHOOSER_ACTION_SAVE, 'Save a Flow Graph to a File...')

+ self.add_and_set_filter(get_flow_graph_files_filter())

+ self.set_current_name(path.basename(current_file_path)) #show the current filename

+ elif self.type == SAVE_IMAGE:

+ FileDialogHelper.__init__(self, gtk.FILE_CHOOSER_ACTION_SAVE, 'Save a Flow Graph Screen Shot...')

+ self.add_and_set_filter(get_image_files_filter())

+ current_file_path = current_file_path + IMAGE_FILE_EXTENSION

+ self.set_current_name(path.basename(current_file_path)) #show the current filename

+ self.set_current_folder(path.dirname(current_file_path)) #current directory

+

+ def add_and_set_filter(self, filter):

+ """

+ Add the gtk file filter to the list of filters and set it as the default file filter.

+

+ Args:

+ filter: a gtk file filter.

+ """

+ self.add_filter(filter)

+ self.set_filter(filter)

+

+ def get_rectified_filename(self):

+ """

+ Run the dialog and get the filename.

+ If this is a save dialog and the file name is missing the extension, append the file extension.

+ If the file name with the extension already exists, show a overwrite dialog.

+ If this is an open dialog, return a list of filenames.

+

+ Returns:

+ the complete file path

+ """

+ if gtk.FileChooserDialog.run(self) != gtk.RESPONSE_OK: return None #response was cancel

+ #############################################

+ # Handle Save Dialogs

+ #############################################

+ if self.type in (SAVE_FLOW_GRAPH, SAVE_IMAGE):

+ filename = self.get_filename()

+ extension = {

+ SAVE_FLOW_GRAPH: Preferences.file_extension(),

+ SAVE_IMAGE: IMAGE_FILE_EXTENSION,

+ }[self.type]

+ #append the missing file extension if the filter matches

+ if path.splitext(filename)[1].lower() != extension: filename += extension

+ self.set_current_name(path.basename(filename)) #show the filename with extension

+ if path.exists(filename): #ask the user to confirm overwrite

+ if MessageDialogHelper(

+ gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, 'Confirm Overwrite!',

+ Utils.parse_template(FILE_OVERWRITE_MARKUP_TMPL, filename=filename),

+ ) == gtk.RESPONSE_NO: return self.get_rectified_filename()

+ return filename

+ #############################################

+ # Handle Open Dialogs

+ #############################################

+ elif self.type in (OPEN_FLOW_GRAPH,):

+ filenames = self.get_filenames()

+ for filename in filenames:

+ if not path.exists(filename): #show a warning and re-run

+ MessageDialogHelper(

+ gtk.MESSAGE_WARNING, gtk.BUTTONS_CLOSE, 'Cannot Open!',

+ Utils.parse_template(FILE_DNE_MARKUP_TMPL, filename=filename),

+ )

+ return self.get_rectified_filename()

+ return filenames

+

+ def run(self):

+ """

+ Get the filename and destroy the dialog.

+

+ Returns:

+ the filename or None if a close/cancel occured.

+ """

+ filename = self.get_rectified_filename()

+ self.destroy()

+ return filename

+ """

+ FlowGraph is the data structure to store graphical signal blocks,

+ graphical inputs and outputs,

+ and the connections between inputs and outputs.

+ """

+

+ def __init__(self):

+ """

+ FlowGraph contructor.

+ Create a list for signal blocks and connections. Connect mouse handlers.

+ """

+ Element.__init__(self)

+ #when is the flow graph selected? (used by keyboard event handler)

+ self.is_selected = lambda: bool(self.get_selected_elements())

+ #important vars dealing with mouse event tracking

+ self.element_moved = False

+ self.mouse_pressed = False

+ self.unselect()

+ self.press_coor = (0, 0)

+ #selected ports

+ self._old_selected_port = None

+ self._new_selected_port = None

+ #context menu

+ self._context_menu = gtk.Menu()

+ for action in [

+ Actions.BLOCK_CUT,

+ Actions.BLOCK_COPY,

+ Actions.BLOCK_PASTE,

+ Actions.ELEMENT_DELETE,

+ Actions.BLOCK_ROTATE_CCW,

+ Actions.BLOCK_ROTATE_CW,

+ Actions.BLOCK_ENABLE,

+ Actions.BLOCK_DISABLE,

+ Actions.BLOCK_PARAM_MODIFY,

+ Actions.BLOCK_CREATE_HIER,

+ Actions.OPEN_HIER,

+ Actions.BUSSIFY_SOURCES,

+ Actions.BUSSIFY_SINKS,

+ ]: self._context_menu.append(action.create_menu_item())

+

+ ###########################################################################

+ # Access Drawing Area

+ ###########################################################################

+ def get_drawing_area(self): return self.drawing_area

+ def queue_draw(self): self.get_drawing_area().queue_draw()

+ def get_size(self): return self.get_drawing_area().get_size_request()

+ def set_size(self, *args): self.get_drawing_area().set_size_request(*args)

+ def get_scroll_pane(self): return self.drawing_area.get_parent()

+ def get_ctrl_mask(self): return self.drawing_area.ctrl_mask

+ def new_pixmap(self, *args): return self.get_drawing_area().new_pixmap(*args)

+

+ def add_new_block(self, key, coor=None):

+ """

+ Add a block of the given key to this flow graph.

+

+ Args:

+ key: the block key

+ coor: an optional coordinate or None for random

+ """

+ id = self._get_unique_id(key)

+ #calculate the position coordinate

+ h_adj = self.get_scroll_pane().get_hadjustment()

+ v_adj = self.get_scroll_pane().get_vadjustment()

+ if coor is None: coor = (

+ int(random.uniform(.25, .75)*h_adj.page_size + h_adj.get_value()),

+ int(random.uniform(.25, .75)*v_adj.page_size + v_adj.get_value()),

+ )

+ #get the new block

+ block = self.get_new_block(key)

+ block.set_coordinate(coor)

+ block.set_rotation(0)

+ block.get_param('id').set_value(id)

+ Actions.ELEMENT_CREATE()

+ return id

+

+ ###########################################################################

+ # Copy Paste

+ ###########################################################################

+ def copy_to_clipboard(self):

+ """

+ Copy the selected blocks and connections into the clipboard.

+

+ Returns:

+ the clipboard

+ """

+ #get selected blocks

+ blocks = self.get_selected_blocks()

+ if not blocks: return None

+ #calc x and y min

+ x_min, y_min = blocks[0].get_coordinate()

+ for block in blocks:

+ x, y = block.get_coordinate()

+ x_min = min(x, x_min)

+ y_min = min(y, y_min)

+ #get connections between selected blocks

+ connections = filter(

+ lambda c: c.get_source().get_parent() in blocks and c.get_sink().get_parent() in blocks,

+ self.get_connections(),

+ )

+ clipboard = (

+ (x_min, y_min),

+ [block.export_data() for block in blocks],

+ [connection.export_data() for connection in connections],

+ )

+ return clipboard

+

+ def paste_from_clipboard(self, clipboard):

+ """

+ Paste the blocks and connections from the clipboard.

+

+ Args:

+ clipboard: the nested data of blocks, connections

+ """

+ selected = set()

+ (x_min, y_min), blocks_n, connections_n = clipboard

+ old_id2block = dict()

+ #recalc the position

+ h_adj = self.get_scroll_pane().get_hadjustment()

+ v_adj = self.get_scroll_pane().get_vadjustment()

+ x_off = h_adj.get_value() - x_min + h_adj.page_size/4

+ y_off = v_adj.get_value() - y_min + v_adj.page_size/4

+ #create blocks

+ for block_n in blocks_n:

+ block_key = block_n.find('key')

+ if block_key == 'options': continue

+ block = self.get_new_block(block_key)

+ selected.add(block)

+ #set params

+ params_n = block_n.findall('param')

+ for param_n in params_n:

+ param_key = param_n.find('key')

+ param_value = param_n.find('value')

+ #setup id parameter

+ if param_key == 'id':

+ old_id2block[param_value] = block

+ #if the block id is not unique, get a new block id

+ if param_value in [bluck.get_id() for bluck in self.get_blocks()]:

+ param_value = self._get_unique_id(param_value)

+ #set value to key

+ block.get_param(param_key).set_value(param_value)

+ #move block to offset coordinate

+ block.move((x_off, y_off))

+ #update before creating connections

+ self.update()

+ #create connections

+ for connection_n in connections_n:

+ source = old_id2block[connection_n.find('source_block_id')].get_source(connection_n.find('source_key'))

+ sink = old_id2block[connection_n.find('sink_block_id')].get_sink(connection_n.find('sink_key'))

+ self.connect(source, sink)

+ #set all pasted elements selected

+ for block in selected: selected = selected.union(set(block.get_connections()))

+ self._selected_elements = list(selected)

+

+ ###########################################################################

+ # Modify Selected

+ ###########################################################################

+ def type_controller_modify_selected(self, direction):

+ """

+ Change the registered type controller for the selected signal blocks.

+

+ Args:

+ direction: +1 or -1

+

+ Returns:

+ true for change

+ """

+ return any([sb.type_controller_modify(direction) for sb in self.get_selected_blocks()])

+

+ def port_controller_modify_selected(self, direction):

+ """

+ Change port controller for the selected signal blocks.

+

+ Args:

+ direction: +1 or -1

+

+ Returns:

+ true for changed

+ """

+ return any([sb.port_controller_modify(direction) for sb in self.get_selected_blocks()])

+

+ def enable_selected(self, enable):

+ """

+ Enable/disable the selected blocks.

+

+ Args:

+ enable: true to enable

+

+ Returns:

+ true if changed

+ """

+ changed = False

+ for selected_block in self.get_selected_blocks():

+ if selected_block.get_enabled() != enable:

+ selected_block.set_enabled(enable)

+ changed = True

+ return changed

+

+ def move_selected(self, delta_coordinate):

+ """

+ Move the element and by the change in coordinates.

+

+ Args:

+ delta_coordinate: the change in coordinates

+ """

+ for selected_block in self.get_selected_blocks():

+ selected_block.move(delta_coordinate)

+ self.element_moved = True

+

+ def rotate_selected(self, rotation):

+ """

+ Rotate the selected blocks by multiples of 90 degrees.

+

+ Args:

+ rotation: the rotation in degrees

+

+ Returns:

+ true if changed, otherwise false.

+ """

+ if not self.get_selected_blocks(): return False

+ #initialize min and max coordinates

+ min_x, min_y = self.get_selected_block().get_coordinate()

+ max_x, max_y = self.get_selected_block().get_coordinate()

+ #rotate each selected block, and find min/max coordinate

+ for selected_block in self.get_selected_blocks():

+ selected_block.rotate(rotation)

+ #update the min/max coordinate

+ x, y = selected_block.get_coordinate()

+ min_x, min_y = min(min_x, x), min(min_y, y)

+ max_x, max_y = max(max_x, x), max(max_y, y)

+ #calculate center point of slected blocks

+ ctr_x, ctr_y = (max_x + min_x)/2, (max_y + min_y)/2

+ #rotate the blocks around the center point

+ for selected_block in self.get_selected_blocks():

+ x, y = selected_block.get_coordinate()

+ x, y = Utils.get_rotated_coordinate((x - ctr_x, y - ctr_y), rotation)

+ selected_block.set_coordinate((x + ctr_x, y + ctr_y))

+ return True

+

+ def remove_selected(self):

+ """

+ Remove selected elements

+

+ Returns:

+ true if changed.

+ """

+ changed = False

+ for selected_element in self.get_selected_elements():

+ self.remove_element(selected_element)

+ changed = True

+ return changed

+

+ def draw(self, gc, window):

+ """

+ Draw the background and grid if enabled.

+ Draw all of the elements in this flow graph onto the pixmap.

+ Draw the pixmap to the drawable window of this flow graph.

+ """

+ W,H = self.get_size()

+ #draw the background

+ gc.set_foreground(Colors.FLOWGRAPH_BACKGROUND_COLOR)

+ window.draw_rectangle(gc, True, 0, 0, W, H)

+ #draw multi select rectangle

+ if self.mouse_pressed and (not self.get_selected_elements() or self.get_ctrl_mask()):

+ #coordinates

+ x1, y1 = self.press_coor

+ x2, y2 = self.get_coordinate()

+ #calculate top-left coordinate and width/height

+ x, y = int(min(x1, x2)), int(min(y1, y2))

+ w, h = int(abs(x1 - x2)), int(abs(y1 - y2))

+ #draw

+ gc.set_foreground(Colors.HIGHLIGHT_COLOR)

+ window.draw_rectangle(gc, True, x, y, w, h)

+ gc.set_foreground(Colors.BORDER_COLOR)

+ window.draw_rectangle(gc, False, x, y, w, h)

+ #draw blocks on top of connections

+ for element in self.get_connections() + self.get_blocks():

+ element.draw(gc, window)

+ #draw selected blocks on top of selected connections

+ for selected_element in self.get_selected_connections() + self.get_selected_blocks():

+ selected_element.draw(gc, window)

+

+ def update_selected(self):

+ """

+ Remove deleted elements from the selected elements list.

+ Update highlighting so only the selected are highlighted.

+ """

+ selected_elements = self.get_selected_elements()

+ elements = self.get_elements()

+ #remove deleted elements

+ for selected in selected_elements:

+ if selected in elements: continue

+ selected_elements.remove(selected)

+ if self._old_selected_port and self._old_selected_port.get_parent() not in elements:

+ self._old_selected_port = None

+ if self._new_selected_port and self._new_selected_port.get_parent() not in elements:

+ self._new_selected_port = None

+ #update highlighting

+ for element in elements:

+ element.set_highlighted(element in selected_elements)

+

+ def update(self):

+ """

+ Call the top level rewrite and validate.

+ Call the top level create labels and shapes.

+ """

+ self.rewrite()

+ self.validate()

+ self.create_labels()

+ self.create_shapes()

+

+ ##########################################################################

+ ## Get Selected

+ ##########################################################################

+ def unselect(self):

+ """

+ Set selected elements to an empty set.

+ """

+ self._selected_elements = []

+

+ def what_is_selected(self, coor, coor_m=None):

+ """

+ What is selected?

+ At the given coordinate, return the elements found to be selected.

+ If coor_m is unspecified, return a list of only the first element found to be selected:

+ Iterate though the elements backwards since top elements are at the end of the list.

+ If an element is selected, place it at the end of the list so that is is drawn last,

+ and hence on top. Update the selected port information.

+

+ Args:

+ coor: the coordinate of the mouse click

+ coor_m: the coordinate for multi select

+

+ Returns:

+ the selected blocks and connections or an empty list

+ """

+ selected_port = None

+ selected = set()

+ #check the elements

+ for element in reversed(self.get_elements()):

+ selected_element = element.what_is_selected(coor, coor_m)

+ if not selected_element: continue

+ #update the selected port information

+ if selected_element.is_port():

+ if not coor_m: selected_port = selected_element

+ selected_element = selected_element.get_parent()

+ selected.add(selected_element)

+ #place at the end of the list

+ self.get_elements().remove(element)

+ self.get_elements().append(element)

+ #single select mode, break

+ if not coor_m: break

+ #update selected ports

+ self._old_selected_port = self._new_selected_port

+ self._new_selected_port = selected_port

+ return list(selected)

+

+ def get_selected_connections(self):

+ """

+ Get a group of selected connections.

+

+ Returns:

+ sub set of connections in this flow graph

+ """

+ selected = set()

+ for selected_element in self.get_selected_elements():

+ if selected_element.is_connection(): selected.add(selected_element)

+ return list(selected)

+

+ def get_selected_blocks(self):

+ """

+ Get a group of selected blocks.

+

+ Returns:

+ sub set of blocks in this flow graph

+ """

+ selected = set()

+ for selected_element in self.get_selected_elements():

+ if selected_element.is_block(): selected.add(selected_element)

+ return list(selected)

+

+ def get_selected_block(self):

+ """

+ Get the selected block when a block or port is selected.

+

+ Returns:

+ a block or None

+ """

+ return self.get_selected_blocks() and self.get_selected_blocks()[0] or None

+

+ def get_selected_elements(self):

+ """

+ Get the group of selected elements.

+

+ Returns:

+ sub set of elements in this flow graph

+ """

+ return self._selected_elements

+

+ def get_selected_element(self):

+ """

+ Get the selected element.

+

+ Returns:

+ a block, port, or connection or None

+ """

+ return self.get_selected_elements() and self.get_selected_elements()[0] or None

+

+ def update_selected_elements(self):

+ """

+ Update the selected elements.

+ The update behavior depends on the state of the mouse button.

+ When the mouse button pressed the selection will change when

+ the control mask is set or the new selection is not in the current group.

+ When the mouse button is released the selection will change when

+ the mouse has moved and the control mask is set or the current group is empty.

+ Attempt to make a new connection if the old and ports are filled.

+ If the control mask is set, merge with the current elements.

+ """

+ selected_elements = None

+ if self.mouse_pressed:

+ new_selections = self.what_is_selected(self.get_coordinate())

+ #update the selections if the new selection is not in the current selections

+ #allows us to move entire selected groups of elements

+ if self.get_ctrl_mask() or not (

+ new_selections and new_selections[0] in self.get_selected_elements()

+ ): selected_elements = new_selections

+ else: #called from a mouse release

+ if not self.element_moved and (not self.get_selected_elements() or self.get_ctrl_mask()):

+ selected_elements = self.what_is_selected(self.get_coordinate(), self.press_coor)

+ #this selection and the last were ports, try to connect them

+ if self._old_selected_port and self._new_selected_port and \

+ self._old_selected_port is not self._new_selected_port:

+ try:

+ self.connect(self._old_selected_port, self._new_selected_port)

+ Actions.ELEMENT_CREATE()

+ except: Messages.send_fail_connection()

+ self._old_selected_port = None

+ self._new_selected_port = None

+ return

+ #update selected elements

+ if selected_elements is None: return

+ old_elements = set(self.get_selected_elements())

+ self._selected_elements = list(set(selected_elements))

+ new_elements = set(self.get_selected_elements())

+ #if ctrl, set the selected elements to the union - intersection of old and new

+ if self.get_ctrl_mask():

+ self._selected_elements = list(

+ set.union(old_elements, new_elements) - set.intersection(old_elements, new_elements)

+ )

+ Actions.ELEMENT_SELECT()

+

+ ##########################################################################

+ ## Event Handlers

+ ##########################################################################

+ def handle_mouse_context_press(self, coordinate, event):

+ """

+ The context mouse button was pressed:

+ If no elements were selected, perform re-selection at this coordinate.

+ Then, show the context menu at the mouse click location.

+ """

+ selections = self.what_is_selected(coordinate)

+ if not set(selections).intersection(self.get_selected_elements()):

+ self.set_coordinate(coordinate)

+ self.mouse_pressed = True

+ self.update_selected_elements()

+ self.mouse_pressed = False

+ self._context_menu.popup(None, None, None, event.button, event.time)

+

+ def handle_mouse_selector_press(self, double_click, coordinate):

+ """

+ The selector mouse button was pressed:

+ Find the selected element. Attempt a new connection if possible.

+ Open the block params window on a double click.

+ Update the selection state of the flow graph.

+ """

+ self.press_coor = coordinate

+ self.set_coordinate(coordinate)

+ self.time = 0

+ self.mouse_pressed = True

+ if double_click: self.unselect()

+ self.update_selected_elements()

+ #double click detected, bring up params dialog if possible

+ if double_click and self.get_selected_block():

+ self.mouse_pressed = False

+ Actions.BLOCK_PARAM_MODIFY()

+

+ def handle_mouse_selector_release(self, coordinate):

+ """

+ The selector mouse button was released:

+ Update the state, handle motion (dragging).

+ And update the selected flowgraph elements.

+ """

+ self.set_coordinate(coordinate)

+ self.time = 0

+ self.mouse_pressed = False

+ if self.element_moved:

+ Actions.BLOCK_MOVE()

+ self.element_moved = False

+ self.update_selected_elements()

+

+ def handle_mouse_motion(self, coordinate):

+ """

+ The mouse has moved, respond to mouse dragging.

+ Move a selected element to the new coordinate.

+ Auto-scroll the scroll bars at the boundaries.

+ """

+ #to perform a movement, the mouse must be pressed

+ # (no longer checking pending events via gtk.events_pending() - always true in Windows)

+ if not self.mouse_pressed: return

+ #perform autoscrolling

+ width, height = self.get_size()

+ x, y = coordinate

+ h_adj = self.get_scroll_pane().get_hadjustment()

+ v_adj = self.get_scroll_pane().get_vadjustment()

+ for pos, length, adj, adj_val, adj_len in (

+ (x, width, h_adj, h_adj.get_value(), h_adj.page_size),

+ (y, height, v_adj, v_adj.get_value(), v_adj.page_size),

+ ):

+ #scroll if we moved near the border

+ if pos-adj_val > adj_len-SCROLL_PROXIMITY_SENSITIVITY and adj_val+SCROLL_DISTANCE < length-adj_len:

+ adj.set_value(adj_val+SCROLL_DISTANCE)

+ adj.emit('changed')

+ elif pos-adj_val < SCROLL_PROXIMITY_SENSITIVITY:

+ adj.set_value(adj_val-SCROLL_DISTANCE)

+ adj.emit('changed')

+ #remove the connection if selected in drag event

+ if len(self.get_selected_elements()) == 1 and self.get_selected_element().is_connection():

+ Actions.ELEMENT_DELETE()

+ #move the selected elements and record the new coordinate

+ X, Y = self.get_coordinate()

+ if not self.get_ctrl_mask(): self.move_selected((int(x - X), int(y - Y)))

+ self.set_coordinate((x, y))

+ #queue draw for animation

+ self.queue_draw()

+ NEW_FLOGRAPH_TITLE, DEFAULT_REPORTS_WINDOW_WIDTH

+ """The topmost window with menus, the tool bar, and other major windows."""

+ def __init__(self, platform):

+ """

+ MainWindow contructor

+ Setup the menu, toolbar, flowgraph editor notebook, block selection window...

+ """

+ self._platform = platform

+ #setup window

+ gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)

+ vbox = gtk.VBox()

+ self.hpaned = gtk.HPaned()

+ self.add(vbox)

+ #create the menu bar and toolbar

+ self.add_accel_group(Actions.get_accel_group())

+ vbox.pack_start(Bars.MenuBar(), False)

+ vbox.pack_start(Bars.Toolbar(), False)

+ vbox.pack_start(self.hpaned)

+ #create the notebook

+ self.notebook = gtk.Notebook()

+ self.page_to_be_closed = None

+ self.current_page = None

+ self.notebook.set_show_border(False)

+ self.notebook.set_scrollable(True) #scroll arrows for page tabs

+ self.notebook.connect('switch-page', self._handle_page_change)

+ #setup containers

+ self.flow_graph_vpaned = gtk.VPaned()

+ #flow_graph_box.pack_start(self.scrolled_window)

+ self.flow_graph_vpaned.pack1(self.notebook)

+ self.hpaned.pack1(self.flow_graph_vpaned)

+ self.btwin = BlockTreeWindow(platform, self.get_flow_graph);

+ self.hpaned.pack2(self.btwin, False) #dont allow resize

+ #create the reports window

+ self.text_display = TextDisplay()

+ #house the reports in a scrolled window

+ self.reports_scrolled_window = gtk.ScrolledWindow()

+ self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)

+ self.reports_scrolled_window.add_with_viewport(self.text_display)

+ self.reports_scrolled_window.set_size_request(-1, DEFAULT_REPORTS_WINDOW_WIDTH)

+ self.flow_graph_vpaned.pack2(self.reports_scrolled_window, False) #dont allow resize

+ #load preferences and show the main window

+ Preferences.load(platform)

+ self.resize(*Preferences.main_window_size())

+ self.flow_graph_vpaned.set_position(Preferences.reports_window_position())

+ self.hpaned.set_position(Preferences.blocks_window_position())

+ self.show_all()

+ ############################################################

+ # Event Handlers

+ ############################################################

+ def _quit(self, window, event):

+ """

+ Handle the delete event from the main window.

+ Generated by pressing X to close, alt+f4, or right click+close.

+ This method in turns calls the state handler to quit.

+

+ Returns:

+ true

+ """

+ Actions.APPLICATION_QUIT()

+ return True

+ def _handle_page_change(self, notebook, page, page_num):

+ """

+ Handle a page change. When the user clicks on a new tab,

+ reload the flow graph to update the vars window and

+ call handle states (select nothing) to update the buttons.

+

+ Args:

+ notebook: the notebook

+ page: new page

+ page_num: new page number

+ """

+ self.current_page = self.notebook.get_nth_page(page_num)

+ Messages.send_page_switch(self.current_page.get_file_path())

+ Actions.PAGE_CHANGE()

+ ############################################################

+ # Report Window

+ ############################################################

+ def add_report_line(self, line):

+ """

+ Place line at the end of the text buffer, then scroll its window all the way down.

+

+ Args:

+ line: the new text

+ """

+ self.text_display.insert(line)

+ vadj = self.reports_scrolled_window.get_vadjustment()

+ vadj.set_value(vadj.upper)

+ vadj.emit('changed')

+ ############################################################

+ # Pages: create and close

+ ############################################################

+ def new_page(self, file_path='', show=False):

+ """

+ Create a new notebook page.

+ Set the tab to be selected.

+

+ Args:

+ file_path: optional file to load into the flow graph

+ show: true if the page should be shown after loading

+ """

+ #if the file is already open, show the open page and return

+ if file_path and file_path in self._get_files(): #already open

+ page = self.notebook.get_nth_page(self._get_files().index(file_path))

+ self._set_page(page)

+ return

+ try: #try to load from file

+ if file_path: Messages.send_start_load(file_path)

+ flow_graph = self._platform.get_new_flow_graph()

+ flow_graph.grc_file_path = file_path;

+ #print flow_graph

+ page = NotebookPage(

+ self,

+ flow_graph=flow_graph,

+ file_path=file_path,

+ )

+ if file_path: Messages.send_end_load()

+ except Exception, e: #return on failure

+ Messages.send_fail_load(e)

+ if isinstance(e, KeyError) and str(e) == "'options'":

+ # This error is unrecoverable, so crash gracefully

+ exit(-1)

+ return

+ #add this page to the notebook

+ self.notebook.append_page(page, page.get_tab())

+ try: self.notebook.set_tab_reorderable(page, True)

+ except: pass #gtk too old

+ self.notebook.set_tab_label_packing(page, False, False, gtk.PACK_START)

+ #only show if blank or manual

+ if not file_path or show: self._set_page(page)

+ def close_pages(self):

+ """

+ Close all the pages in this notebook.

+

+ Returns:

+ true if all closed

+ """

+ open_files = filter(lambda file: file, self._get_files()) #filter blank files

+ open_file = self.get_page().get_file_path()

+ #close each page

+ for page in self._get_pages():

+ self.page_to_be_closed = page

+ self.close_page(False)

+ if self.notebook.get_n_pages(): return False

+ #save state before closing

+ Preferences.files_open(open_files)

+ Preferences.file_open(open_file)

+ Preferences.main_window_size(self.get_size())

+ Preferences.reports_window_position(self.flow_graph_vpaned.get_position())

+ Preferences.blocks_window_position(self.hpaned.get_position())

+ Preferences.save()

+ return True

+ def close_page(self, ensure=True):

+ """

+ Close the current page.

+ If the notebook becomes empty, and ensure is true,

+ call new page upon exit to ensure that at least one page exists.

+

+ Args:

+ ensure: boolean

+ """

+ if not self.page_to_be_closed: self.page_to_be_closed = self.get_page()

+ #show the page if it has an executing flow graph or is unsaved

+ if self.page_to_be_closed.get_proc() or not self.page_to_be_closed.get_saved():

+ self._set_page(self.page_to_be_closed)

+ #unsaved? ask the user

+ if not self.page_to_be_closed.get_saved() and self._save_changes():

+ Actions.FLOW_GRAPH_SAVE() #try to save

+ if not self.page_to_be_closed.get_saved(): #still unsaved?

+ self.page_to_be_closed = None #set the page to be closed back to None

+ return

+ #stop the flow graph if executing

+ if self.page_to_be_closed.get_proc(): Actions.FLOW_GRAPH_KILL()

+ #remove the page

+ self.notebook.remove_page(self.notebook.page_num(self.page_to_be_closed))

+ if ensure and self.notebook.get_n_pages() == 0: self.new_page() #no pages, make a new one

+ self.page_to_be_closed = None #set the page to be closed back to None

+ ############################################################

+ # Misc

+ ############################################################

+ def update(self):

+ """

+ Set the title of the main window.

+ Set the titles on the page tabs.

+ Show/hide the reports window.

+

+ Args:

+ title: the window title

+ """

+ gtk.Window.set_title(self, Utils.parse_template(MAIN_WINDOW_TITLE_TMPL,

+ basename=os.path.basename(self.get_page().get_file_path()),

+ dirname=os.path.dirname(self.get_page().get_file_path()),

+ new_flowgraph_title=NEW_FLOGRAPH_TITLE,

+ read_only=self.get_page().get_read_only(),

+ saved=self.get_page().get_saved(),

+ platform_name=self._platform.get_name(),

+ )

+ )

+ #set tab titles

+ for page in self._get_pages(): page.set_markup(

+ Utils.parse_template(PAGE_TITLE_MARKUP_TMPL,

+ #get filename and strip out file extension

+ title=os.path.splitext(os.path.basename(page.get_file_path()))[0],

+ read_only=page.get_read_only(), saved=page.get_saved(),

+ new_flowgraph_title=NEW_FLOGRAPH_TITLE,

+ )

+ )

+ #show/hide notebook tabs

+ self.notebook.set_show_tabs(len(self._get_pages()) > 1)

+ def get_page(self):

+ """

+ Get the selected page.

+

+ Returns:

+ the selected page

+ """

+ return self.current_page

+ def get_flow_graph(self):

+ """

+ Get the selected flow graph.

+

+ Returns:

+ the selected flow graph

+ """

+ return self.get_page().get_flow_graph()

+ def get_focus_flag(self):

+ """

+ Get the focus flag from the current page.

+

+ Returns:

+ the focus flag

+ """

+ return self.get_page().get_drawing_area().get_focus_flag()

+ ############################################################

+ # Helpers

+ ############################################################

+ def _set_page(self, page):

+ """

+ Set the current page.

+

+ Args:

+ page: the page widget

+ """

+ self.current_page = page

+ self.notebook.set_current_page(self.notebook.page_num(self.current_page))

+ def _save_changes(self):

+ """

+ Save changes to flow graph?

+

+ Returns:

+ true if yes

+ """

+ return MessageDialogHelper(

+ gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, 'Unsaved Changes!',

+ 'Would you like to save changes before closing?'

+ ) == gtk.RESPONSE_YES

+ def _get_files(self):

+ """

+ Get the file names for all the pages, in order.

+

+ Returns:

+ list of file paths

+ """

+ return map(lambda page: page.get_file_path(), self._get_pages())

+ def _get_pages(self):

+ """

+ Get a list of all pages in the notebook.

+

+ Returns:

+ list of pages

+ """

+ return [self.notebook.get_nth_page(page_num) for page_num in range(self.notebook.get_n_pages())]

+ """

+ Append the given messenger to the list of messengers.

+

+ Args:

+ messenger: a method thats takes a string

+ """

+ MESSENGERS_LIST.append(messenger)

+ """

+ Give the message to each of the messengers.

+

+ Args:

+ message: a message string

+ """

+ for messenger in MESSENGERS_LIST: messenger(message)

+ send("""<<< Welcome to %s %s >>>\n"""%(platform.get_name(), platform.get_version()))

+ send('\nShowing: "%s"\n'%file_path)

+################# functions for loading flow graphs ########################################

+ send('\nLoading: "%s"'%file_path + '\n')

+ send('>>> Error: %s\n'%error)

+ traceback.print_exc()

+ send('>>> Done\n')

+ send('Error: %s\n'%error)

+ send('>>> Failure\n')

+ traceback.print_exc()

+################# functions for generating flow graphs ########################################

+ send('\nGenerating: "%s"'%file_path + '\n')

+ send('Generate Error: %s\n'%error)

+ send('>>> Failure\n')

+ traceback.print_exc()

+################# functions for executing flow graphs ########################################

+ send('\nExecuting: "%s"'%file_path + '\n')

+ send(verbose)

+ send('\n>>> Done\n')

+################# functions for saving flow graphs ########################################

+ send('>>> Error: Cannot save: %s\n'%file_path)

+################# functions for connections ########################################

+ send('>>> Error: Cannot create connection.\n')

+################# functions for preferences ########################################

+ send('>>> Error: Cannot load preferences file: "%s"\n'%prefs_file_path)

+ send('>>> Error: Cannot save preferences file: "%s"\n'%prefs_file_path)

+################# functions for warning ########################################

+ send('>>> Warning: %s\n'%warning)

+ """A page in the notebook."""

+

+ def __init__(self, main_window, flow_graph, file_path=''):

+ """

+ Page constructor.

+

+ Args:

+ main_window: main window

+ file_path: path to a flow graph file

+ """

+ self._flow_graph = flow_graph

+ self.set_proc(None)

+ #import the file

+ self.main_window = main_window

+ self.set_file_path(file_path)

+ initial_state = flow_graph.get_parent().parse_flow_graph(file_path)

+ self.state_cache = StateCache(initial_state)

+ self.set_saved(True)

+ #import the data to the flow graph

+ self.get_flow_graph().import_data(initial_state)

+ #initialize page gui

+ gtk.HBox.__init__(self, False, 0)

+ self.show()

+ #tab box to hold label and close button

+ self.tab = gtk.HBox(False, 0)

+ #setup tab label

+ self.label = gtk.Label()

+ self.tab.pack_start(self.label, False)

+ #setup button image

+ image = gtk.Image()

+ image.set_from_stock('gtk-close', gtk.ICON_SIZE_MENU)

+ #setup image box

+ image_box = gtk.HBox(False, 0)

+ image_box.pack_start(image, True, False, 0)

+ #setup the button

+ button = gtk.Button()

+ button.connect("clicked", self._handle_button)

+ button.set_relief(gtk.RELIEF_NONE)

+ button.add(image_box)

+ #button size

+ w, h = gtk.icon_size_lookup_for_settings(button.get_settings(), gtk.ICON_SIZE_MENU)

+ 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 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):

+ """

+ Get the generator object for this flow graph.

+

+ Returns:

+ generator

+ """

+ return self.get_flow_graph().get_parent().get_generator()(

+ self.get_flow_graph(),

+ self.get_file_path(),

+ )

+

+ def _handle_button(self, button):

+ """

+ The button was clicked.

+ Make the current page selected, then close.

+

+ Args:

+ the: button

+ """

+ self.main_window.page_to_be_closed = self

+ Actions.FLOW_GRAPH_CLOSE()

+

+ def set_markup(self, markup):

+ """

+ Set the markup in this label.

+

+ Args:

+ markup: the new markup text

+ """

+ self.label.set_markup(markup)

+

+ def get_tab(self):

+ """

+ Get the gtk widget for this page's tab.

+

+ Returns:

+ gtk widget

+ """

+ return self.tab

+

+ def get_proc(self):

+ """

+ Get the subprocess for the flow graph.

+

+ Returns:

+ the subprocess object

+ """

+ return self.process

+

+ def set_proc(self, process):

+ """

+ Set the subprocess object.

+

+ Args:

+ process: the new subprocess

+ """

+ self.process = process

+

+ def get_flow_graph(self):

+ """

+ Get the flow graph.

+

+ Returns:

+ the flow graph

+ """

+ return self._flow_graph

+

+ def get_read_only(self):

+ """

+ Get the read-only state of the file.

+ Always false for empty path.

+

+ Returns:

+ true for read-only

+ """

+ if not self.get_file_path(): return False

+ return os.path.exists(self.get_file_path()) and \

+ not os.access(self.get_file_path(), os.W_OK)

+

+ def get_file_path(self):

+ """

+ Get the file path for the flow graph.

+

+ Returns:

+ the file path or ''

+ """

+ return self.file_path

+

+ def set_file_path(self, file_path=''):

+ """

+ Set the file path, '' for no file path.

+

+ Args:

+ file_path: file path string

+ """

+ if file_path: self.file_path = os.path.abspath(file_path)

+ else: self.file_path = ''

+

+ def get_saved(self):

+ """

+ Get the saved status for the flow graph.

+

+ Returns:

+ true if saved

+ """

+ return self.saved

+

+ def set_saved(self, saved=True):

+ """

+ Set the saved status.

+

+ Args:

+ saved: boolean status

+ """

+ self.saved = saved

+

+ def get_state_cache(self):

+ """

+ Get the state cache for the flow graph.

+

+ Returns:

+ the state cache

+ """

+ return self.state_cache

+ """The base class for an input parameter inside the input parameters dialog."""

+

+ def __init__(self, param, callback=None):

+ gtk.HBox.__init__(self)

+ self.param = param

+ self._callback = callback

+ self.label = gtk.Label() #no label, markup is added by set_markup

+ self.label.set_size_request(150, -1)

+ self.pack_start(self.label, False)

+ self.set_markup = lambda m: self.label.set_markup(m)

+ self.tp = None

+ #connect events

+ self.connect('show', self._update_gui)

+ def set_color(self, color): pass

+ def set_tooltip_text(self, text): pass

+

+ def _update_gui(self, *args):

+ """

+ Set the markup, color, tooltip, show/hide.

+ """

+ #set the markup

+ has_cb = \

+ hasattr(self.param.get_parent(), 'get_callbacks') and \

+ filter(lambda c: self.param.get_key() in c, self.param.get_parent()._callbacks)

+ self.set_markup(Utils.parse_template(PARAM_LABEL_MARKUP_TMPL, param=self.param, has_cb=has_cb))

+ #set the color

+ self.set_color(self.param.get_color())

+ #set the tooltip

+ self.set_tooltip_text(

+ Utils.parse_template(TIP_MARKUP_TMPL, param=self.param).strip(),

+ )

+ #show/hide

+ if self.param.get_hide() == 'all': self.hide_all()

+ else: self.show_all()

+

+ def _handle_changed(self, *args):

+ """

+ Handle a gui change by setting the new param value,

+ calling the callback (if applicable), and updating.

+ """

+ #set the new value

+ self.param.set_value(self.get_text())

+ #call the callback

+ if self._callback: self._callback(*args)

+ else: self.param.validate()

+ #gui update

+ self._update_gui()

+ """Provide an entry box for strings and numbers."""

+

+ def __init__(self, *args, **kwargs):

+ InputParam.__init__(self, *args, **kwargs)

+ self._input = gtk.Entry()

+ self._input.set_text(self.param.get_value())

+ self._input.connect('changed', self._handle_changed)

+ self.pack_start(self._input, True)

+ def get_text(self): return self._input.get_text()

+ def set_color(self, color):

+ self._input.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))

+ self._input.modify_text(gtk.STATE_NORMAL, Colors.PARAM_ENTRY_TEXT_COLOR)

+ def set_tooltip_text(self, text): self._input.set_tooltip_text(text)

+ """Provide an entry box for Enum types with a drop down menu."""

+

+ def __init__(self, *args, **kwargs):

+ InputParam.__init__(self, *args, **kwargs)

+ self._input = gtk.combo_box_new_text()

+ for option in self.param.get_options(): self._input.append_text(option.get_name())

+ self._input.set_active(self.param.get_option_keys().index(self.param.get_value()))

+ self._input.connect('changed', self._handle_changed)

+ self.pack_start(self._input, False)

+ def get_text(self): return self.param.get_option_keys()[self._input.get_active()]

+ def set_tooltip_text(self, text): self._input.set_tooltip_text(text)

+ """Provide an entry box and drop down menu for Raw Enum types."""

+

+ def __init__(self, *args, **kwargs):

+ InputParam.__init__(self, *args, **kwargs)

+ self._input = gtk.combo_box_entry_new_text()

+ for option in self.param.get_options(): self._input.append_text(option.get_name())

+ try: self._input.set_active(self.param.get_option_keys().index(self.param.get_value()))

+ except:

+ self._input.set_active(-1)

+ self._input.get_child().set_text(self.param.get_value())

+ self._input.connect('changed', self._handle_changed)

+ self._input.get_child().connect('changed', self._handle_changed)

+ self.pack_start(self._input, False)

+ def get_text(self):

+ if self._input.get_active() == -1: return self._input.get_child().get_text()

+ return self.param.get_option_keys()[self._input.get_active()]

+ def set_tooltip_text(self, text):

+ if self._input.get_active() == -1: #custom entry

+ self._input.get_child().set_tooltip_text(text)

+ else: self._input.set_tooltip_text(text)

+ def set_color(self, color):

+ if self._input.get_active() == -1: #custom entry, use color

+ self._input.get_child().modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))

+ self._input.get_child().modify_text(gtk.STATE_NORMAL, Colors.PARAM_ENTRY_TEXT_COLOR)

+ else: #from enum, make pale background

+ self._input.get_child().modify_base(gtk.STATE_NORMAL, Colors.ENTRYENUM_CUSTOM_COLOR)

+ self._input.get_child().modify_text(gtk.STATE_NORMAL, Colors.PARAM_ENTRY_TEXT_COLOR)

+ #set $max_len = 100

+ #set $string = str($string)

+ #if len($string) > $max_len

+ #else

+ #end if

+ #for $error_msg in $param.get_error_messages()

+ #end for

+ """The graphical parameter."""

+

+ def __init__(self): Element.__init__(self)

+

+ def get_input(self, *args, **kwargs):

+ """

+ Get the graphical gtk class to represent this parameter.

+ An enum requires and combo parameter.

+ A non-enum with options gets a combined entry/combo parameter.

+ All others get a standard entry parameter.

+

+ Returns:

+ gtk input class

+ """

+ if self.is_enum(): return EnumParam(self, *args, **kwargs)

+ if self.get_options(): return EnumEntryParam(self, *args, **kwargs)

+ return EntryParam(self, *args, **kwargs)

+

+ def get_markup(self):

+ """

+ Get the markup for this param.

+

+ Returns:

+ a pango markup string

+ """

+ return Utils.parse_template(PARAM_MARKUP_TMPL, param=self)

+ def __init__(self): Element.__init__(self)

+ PORT_SEPARATION, CONNECTOR_EXTENSION_MINIMAL, \

+ CONNECTOR_EXTENSION_INCREMENT, \

+ PORT_LABEL_PADDING, PORT_MIN_WIDTH

+ """The graphical port."""

+

+ def __init__(self):

+ """

+ Port contructor.

+ Create list of connector coordinates.

+ """

+ Element.__init__(self)

+ self.connector_coordinates = dict()

+

+ def create_shapes(self):

+ """Create new areas and labels for the port."""

+ Element.create_shapes(self)

+ #get current rotation

+ rotation = self.get_rotation()

+ #get all sibling ports

+ if self.is_source(): ports = self.get_parent().get_sources_gui()

+ elif self.is_sink(): ports = self.get_parent().get_sinks_gui()

+ #get the max width

+ self.W = max([port.W for port in ports] + [PORT_MIN_WIDTH])

+ #get a numeric index for this port relative to its sibling ports

+ try:

+ index = ports.index(self)

+ except:

+ if hasattr(self, '_connector_length'):

+ del self._connector_length;

+ return

+ length = len(ports)

+ #reverse the order of ports for these rotations

+ if rotation in (180, 270): index = length-index-1

+ offset = (self.get_parent().H - length*self.H - (length-1)*PORT_SEPARATION)/2

+ #create areas and connector coordinates

+ if (self.is_sink() and rotation == 0) or (self.is_source() and rotation == 180):

+ x = -1*self.W

+ y = (PORT_SEPARATION+self.H)*index+offset

+ self.add_area((x, y), (self.W, self.H))

+ self._connector_coordinate = (x-1, y+self.H/2)

+ elif (self.is_source() and rotation == 0) or (self.is_sink() and rotation == 180):

+ x = self.get_parent().W

+ y = (PORT_SEPARATION+self.H)*index+offset

+ self.add_area((x, y), (self.W, self.H))

+ self._connector_coordinate = (x+1+self.W, y+self.H/2)

+ elif (self.is_source() and rotation == 90) or (self.is_sink() and rotation == 270):

+ y = -1*self.W

+ x = (PORT_SEPARATION+self.H)*index+offset

+ self.add_area((x, y), (self.H, self.W))

+ self._connector_coordinate = (x+self.H/2, y-1)

+ elif (self.is_sink() and rotation == 90) or (self.is_source() and rotation == 270):

+ y = self.get_parent().W

+ x = (PORT_SEPARATION+self.H)*index+offset

+ self.add_area((x, y), (self.H, self.W))

+ self._connector_coordinate = (x+self.H/2, y+1+self.W)

+ #the connector length

+ self._connector_length = CONNECTOR_EXTENSION_MINIMAL + CONNECTOR_EXTENSION_INCREMENT*index

+ def modify_height(self, start_height):

+ type_dict = {'bus':(lambda a: a * 3)};

+

+ if self.get_type() in type_dict:

+ return type_dict[self.get_type()](start_height);

+ else:

+ return start_height;

+

+ def create_labels(self):

+ """Create the labels for the socket."""

+ Element.create_labels(self)

+ self._bg_color = Colors.get_color(self.get_color())

+ #create the layout

+ layout = gtk.DrawingArea().create_pango_layout('')

+ layout.set_markup(Utils.parse_template(PORT_MARKUP_TMPL, port=self))

+ self.w, self.h = layout.get_pixel_size()

+ self.W, self.H = 2*PORT_LABEL_PADDING+self.w, 2*PORT_LABEL_PADDING+self.h

+ self.H = self.modify_height(self.H);

+ #create the pixmap

+ pixmap = self.get_parent().get_parent().new_pixmap(self.w, self.h)

+ gc = pixmap.new_gc()

+ gc.set_foreground(self._bg_color)

+ pixmap.draw_rectangle(gc, True, 0, 0, self.w, self.h)

+ pixmap.draw_layout(gc, 0, 0, layout)

+ #create vertical and horizontal pixmaps

+ self.horizontal_label = pixmap

+ if self.is_vertical():

+ self.vertical_label = self.get_parent().get_parent().new_pixmap(self.h, self.w)

+ Utils.rotate_pixmap(gc, self.horizontal_label, self.vertical_label)

+

+ def draw(self, gc, window):

+ """

+ Draw the socket with a label.

+

+ Args:

+ gc: the graphics context

+ window: the gtk window to draw on

+ """

+ Element.draw(

+ self, gc, window, bg_color=self._bg_color,

+ border_color=self.is_highlighted() and Colors.HIGHLIGHT_COLOR or Colors.BORDER_COLOR,

+ )

+ X,Y = self.get_coordinate()

+ (x,y),(w,h) = self._areas_list[0] #use the first area's sizes to place the labels

+ if self.is_horizontal():

+ window.draw_drawable(gc, self.horizontal_label, 0, 0, x+X+(self.W-self.w)/2, y+Y+(self.H-self.h)/2, -1, -1)

+ elif self.is_vertical():

+ window.draw_drawable(gc, self.vertical_label, 0, 0, x+X+(self.H-self.h)/2, y+Y+(self.W-self.w)/2, -1, -1)

+

+ def get_connector_coordinate(self):

+ """

+ Get the coordinate where connections may attach to.

+

+ Returns:

+ the connector coordinate (x, y) tuple

+ """

+ x,y = self._connector_coordinate

+ X,Y = self.get_coordinate()

+ return (x+X, y+Y)

+

+ def get_connector_direction(self):

+ """

+ Get the direction that the socket points: 0,90,180,270.

+ This is the rotation degree if the socket is an output or

+ the rotation degree + 180 if the socket is an input.

+

+ Returns:

+ the direction in degrees

+ """

+ if self.is_source(): return self.get_rotation()

+ elif self.is_sink(): return (self.get_rotation() + 180)%360

+

+ def get_connector_length(self):

+ """

+ Get the length of the connector.

+ The connector length increases as the port index changes.

+

+ Returns:

+ the length in pixels

+ """

+ return self._connector_length

+

+ def get_rotation(self):

+ """

+ Get the parent's rotation rather than self.

+

+ Returns:

+ the parent's rotation

+ """

+ return self.get_parent().get_rotation()

+

+ def move(self, delta_coor):

+ """

+ Move the parent rather than self.

+

+ Args:

+ delta_corr: the (delta_x, delta_y) tuple

+ """

+ self.get_parent().move(delta_coor)

+

+ def rotate(self, direction):

+ """

+ Rotate the parent rather than self.

+

+ Args:

+ direction: degrees to rotate

+ """

+ self.get_parent().rotate(direction)

+

+ def get_coordinate(self):

+ """

+ Get the parent's coordinate rather than self.

+

+ Returns:

+ the parents coordinate

+ """

+ return self.get_parent().get_coordinate()

+

+ def set_highlighted(self, highlight):

+ """

+ Set the parent highlight rather than self.

+

+ Args:

+ highlight: true to enable highlighting

+ """

+ self.get_parent().set_highlighted(highlight)

+

+ def is_highlighted(self):

+ """

+ Get the parent's is highlight rather than self.

+

+ Returns:

+ the parent's highlighting status

+ """

+ return self.get_parent().is_highlighted()

+ global _platform

+ _platform = platform

+ #create sections

+ _config_parser.add_section('main')

+ _config_parser.add_section('files_open')

+ try: _config_parser.read(_prefs_file())

+ except: pass

+ try: _config_parser.write(open(_prefs_file(), 'w'))

+ except: pass

+ if size is not None:

+ _config_parser.set('main', 'main_window_width', size[0])

+ _config_parser.set('main', 'main_window_height', size[1])

+ else:

+ try: return (

+ _config_parser.getint('main', 'main_window_width'),

+ _config_parser.getint('main', 'main_window_height'),

+ )

+ except: return (1, 1)

+ if file is not None: _config_parser.set('main', 'file_open', file)

+ else:

+ try: return _config_parser.get('main', 'file_open')

+ except: return ''

+ if files is not None:

+ _config_parser.remove_section('files_open') #clear section

+ _config_parser.add_section('files_open')

+ for i, file in enumerate(files):

+ _config_parser.set('files_open', 'file_open_%d'%i, file)

+ else:

+ files = list()

+ i = 0

+ while True:

+ try: files.append(_config_parser.get('files_open', 'file_open_%d'%i))

+ except: return files

+ i = i + 1

+ if pos is not None: _config_parser.set('main', 'reports_window_position', pos)

+ else:

+ try: return _config_parser.getint('main', 'reports_window_position') or 1 #greater than 0

+ except: return -1

+ if pos is not None: _config_parser.set('main', 'blocks_window_position', pos)

+ else:

+ try: return _config_parser.getint('main', 'blocks_window_position') or 1 #greater than 0

+ except: return -1

+ """

+ Get a title label for the params window.

+ The title will be bold, underlined, and left justified.

+

+ Args:

+ title: the text of the title

+

+ Returns:

+ a gtk object

+ """

+ label = gtk.Label()

+ label.set_markup('\n<b><span underline="low">%s</span>:</b>\n'%title)

+ hbox = gtk.HBox()

+ hbox.pack_start(label, False, False, padding=11)

+ return hbox

+ """

+ A dialog to set block parameters, view errors, and view documentation.

+ """

+ def __init__(self, block):

+ """

+ Properties dialog contructor.

+

+ Args:

+ block: a block instance

+ """

+ self._hash = 0

+ LABEL_SPACING = 7

+ gtk.Dialog.__init__(self,

+ title='Properties: %s'%block.get_name(),

+ buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT),

+ )

+ self._block = block

+ self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)

+ vbox = gtk.VBox()

+ #Create the scrolled window to hold all the parameters

+ scrolled_window = gtk.ScrolledWindow()

+ scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)

+ scrolled_window.add_with_viewport(vbox)

+ self.vbox.pack_start(scrolled_window, True)

+ #Params box for block parameters

+ self._params_box = gtk.VBox()

+ self._params_box.pack_start(get_title_label('Parameters'), False)

+ self._input_object_params = list()

+ #Error Messages for the block

+ self._error_box = gtk.VBox()

+ self._error_messages_text_display = TextDisplay()

+ self._error_box.pack_start(gtk.Label(), False, False, LABEL_SPACING)

+ self._error_box.pack_start(get_title_label('Error Messages'), False)

+ self._error_box.pack_start(self._error_messages_text_display, False)

+ #Docs for the block

+ self._docs_box = err_box = gtk.VBox()

+ self._docs_text_display = TextDisplay()

+ self._docs_box.pack_start(gtk.Label(), False, False, LABEL_SPACING)

+ self._docs_box.pack_start(get_title_label('Documentation'), False)

+ self._docs_box.pack_start(self._docs_text_display, False)

+ #Add the boxes

+ vbox.pack_start(self._params_box, False)

+ vbox.pack_start(self._error_box, False)

+ vbox.pack_start(self._docs_box, False)

+ #connect events

+ self.connect('key-press-event', self._handle_key_press)

+ self.connect('show', self._update_gui)

+ #show all (performs initial gui update)

+ self.show_all()

+ def _params_changed(self):

+ """

+ Have the params in this dialog changed?

+ Ex: Added, removed, type change, hide change...

+ To the props dialog, the hide setting of 'none' and 'part' are identical.

+ Therfore, the props dialog only cares if the hide setting is/not 'all'.

+ Make a hash that uniquely represents the params' state.

+

+ Returns:

+ true if changed

+ """

+ old_hash = self._hash

+ #create a tuple of things from each param that affects the params box

+ self._hash = hash(tuple([(

+ hash(param), param.get_type(), param.get_hide() == 'all',

+ ) for param in self._block.get_params()]))

+ return self._hash != old_hash

+ def _handle_changed(self, *args):

+ """

+ A change occured within a param:

+ Rewrite/validate the block and update the gui.

+ """

+ #update for the block

+ self._block.rewrite()

+ self._block.validate()

+ self._update_gui()

+ def _update_gui(self, *args):

+ """

+ Repopulate the parameters box (if changed).

+ Update all the input parameters.

+ Update the error messages box.

+ Hide the box if there are no errors.

+ Update the documentation block.

+ Hide the box if there are no docs.

+ """

+ #update the params box

+ if self._params_changed():

+ #hide params box before changing

+ self._params_box.hide_all()

+ #empty the params box

+ for io_param in list(self._input_object_params):

+ self._params_box.remove(io_param)

+ self._input_object_params.remove(io_param)

+ io_param.destroy()

+ #repopulate the params box

+ for param in self._block.get_params():

+ if param.get_hide() == 'all': continue

+ io_param = param.get_input(self._handle_changed)

+ self._input_object_params.append(io_param)

+ self._params_box.pack_start(io_param, False)

+ #show params box with new params

+ self._params_box.show_all()

+ #update the errors box

+ if self._block.is_valid(): self._error_box.hide()

+ else: self._error_box.show()

+ messages = '\n\n'.join(self._block.get_error_messages())

+ self._error_messages_text_display.set_text(messages)

+ #update the docs box

+ if self._block.get_doc(): self._docs_box.show()

+ else: self._docs_box.hide()

+ self._docs_text_display.set_text(self._block.get_doc())

+ def _handle_key_press(self, widget, event):

+ """

+ Handle key presses from the keyboard.

+ Call the ok response when enter is pressed.

+

+ Returns:

+ false to forward the keypress

+ """

+ if event.keyval == gtk.keysyms.Return:

+ self.response(gtk.RESPONSE_ACCEPT)

+ return True #handled here

+ return False #forward the keypress

+ def run(self):

+ """

+ Run the dialog and get its response.

+

+ Returns:

+ true if the response was accept

+ """

+ response = gtk.Dialog.run(self)

+ self.destroy()

+ return response == gtk.RESPONSE_ACCEPT

+ """

+ The state cache is an interface to a list to record data/states and to revert to previous states.

+ States are recorded into the list in a circular fassion by using an index for the current state,

+ and counters for the range where states are stored.

+ """

+ def __init__(self, initial_state):

+ """

+ StateCache constructor.

+

+ Args:

+ initial_state: the intial state (nested data)

+ """

+ self.states = [None] * STATE_CACHE_SIZE #fill states

+ self.current_state_index = 0

+ self.num_prev_states = 0

+ self.num_next_states = 0

+ self.states[0] = initial_state

+ self.update_actions()

+ def save_new_state(self, state):

+ """

+ Save a new state.

+ Place the new state at the next index and add one to the number of previous states.

+

+ Args:

+ state: the new state

+ """

+ self.current_state_index = (self.current_state_index + 1)%STATE_CACHE_SIZE

+ self.states[self.current_state_index] = state

+ self.num_prev_states = self.num_prev_states + 1

+ if self.num_prev_states == STATE_CACHE_SIZE: self.num_prev_states = STATE_CACHE_SIZE - 1

+ self.num_next_states = 0

+ self.update_actions()

+ def get_current_state(self):

+ """

+ Get the state at the current index.

+

+ Returns:

+ the current state (nested data)

+ """

+ self.update_actions()

+ return self.states[self.current_state_index]

+ def get_prev_state(self):

+ """

+ Get the previous state and decrement the current index.

+

+ Returns:

+ the previous state or None

+ """

+ if self.num_prev_states > 0:

+ self.current_state_index = (self.current_state_index + STATE_CACHE_SIZE -1)%STATE_CACHE_SIZE

+ self.num_next_states = self.num_next_states + 1

+ self.num_prev_states = self.num_prev_states - 1

+ return self.get_current_state()

+ return None

+ def get_next_state(self):

+ """

+ Get the nest state and increment the current index.

+

+ Returns:

+ the next state or None

+ """

+ if self.num_next_states > 0:

+ self.current_state_index = (self.current_state_index + 1)%STATE_CACHE_SIZE

+ self.num_next_states = self.num_next_states - 1

+ self.num_prev_states = self.num_prev_states + 1

+ return self.get_current_state()

+ return None

+ def update_actions(self):

+ """

+ Update the undo and redo actions based on the number of next and prev states.

+ """

+ Actions.FLOW_GRAPH_REDO.set_sensitive(self.num_next_states != 0)

+ Actions.FLOW_GRAPH_UNDO.set_sensitive(self.num_prev_states != 0)

+ """

+ Load the destination pixmap with a rotated version of the source pixmap.

+ The source pixmap will be loaded into a pixbuf, rotated, and drawn to the destination pixmap.

+ The pixbuf is a client-side drawable, where a pixmap is a server-side drawable.

+

+ Args:

+ gc: the graphics context

+ src_pixmap: the source pixmap

+ dst_pixmap: the destination pixmap

+ angle: the angle to rotate by

+ """

+ width, height = src_pixmap.get_size()

+ pixbuf = gtk.gdk.Pixbuf(

+ colorspace=gtk.gdk.COLORSPACE_RGB,

+ has_alpha=False, bits_per_sample=8,

+ width=width, height=height,

+ )

+ pixbuf.get_from_drawable(src_pixmap, src_pixmap.get_colormap(), 0, 0, 0, 0, -1, -1)

+ pixbuf = pixbuf.rotate_simple(angle)

+ dst_pixmap.draw_pixbuf(gc, pixbuf, 0, 0, 0, 0)

+ """

+ Rotate the coordinate by the given rotation.

+

+ Args:

+ coor: the coordinate x, y tuple

+ rotation: the angle in degrees

+

+ Returns:

+ the rotated coordinates

+ """

+ #handles negative angles

+ rotation = (rotation + 360)%360

+ if rotation not in POSSIBLE_ROTATIONS:

+ raise ValueError('unusable rotation angle "%s"'%str(rotation))

+ #determine the number of degrees to rotate

+ cos_r, sin_r = {

+ 0: (1, 0),

+ 90: (0, 1),

+ 180: (-1, 0),

+ 270: (0, -1),

+ }[rotation]

+ x, y = coor

+ return (x*cos_r + y*sin_r, -x*sin_r + y*cos_r)

+ """

+ Given two points, calculate the vector direction from point1 to point2, directions are multiples of 90 degrees.

+

+ Args:

+ (x1,y1): the coordinate of point 1

+ (x2,y2): the coordinate of point 2

+

+ Returns:

+ the direction in degrees

+ """

+ if y1 == y2:#0 or 180

+ if x2 > x1: return 0

+ else: return 180

+ else:#90 or 270

+ if y2 > y1: return 270

+ else: return 90

+ """

+ Parse the template string with the given args.

+ Pass in the xml encode method for pango escape chars.

+

+ Args:

+ tmpl_str: the template as a string

+

+ Returns:

+ a string of the parsed template

+ """

+ kwargs['encode'] = gobject.markup_escape_text

+ #try:

+ # cat = str(Template(tmpl_str, kwargs))

+ #except TypeError:

+ # print 'guppy'

+ # print tmpl_str

+ # print str(kwargs['param'].get_error_messages())

+ return str(Template(tmpl_str, kwargs))