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_focus_flag = self.main_window.get_focus_flag

#setup the messages

Messages.register_messenger(self.main_window.add_report_line)

def _handle_action(self, action, *args):

#print action

##################################################

# Initialize/Quit

##################################################

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)

self.main_window.btwin.search_entry.hide()

elif action == Actions.ELEMENT_SELECT:

pass #do nothing, update routines below

elif action == Actions.NOTHING_SELECT:

elif action == Actions.SELECT_ALL:

##################################################

# Enable/Disable

##################################################

elif action == Actions.BLOCK_ENABLE:

elif action == Actions.BLOCK_DISABLE:

elif action == Actions.BLOCK_BYPASS:

##################################################

# Cut/Copy/Paste

##################################################

Actions.BLOCK_COPY()

Actions.ELEMENT_DELETE()

elif action == Actions.BLOCK_COPY:

elif action == Actions.BLOCK_PASTE:

if self.clipboard:

##################################################

# Create heir block

##################################################

elif action == Actions.BLOCK_CREATE_HIER:

# keeping track of coordinates for pasting later

x,y = coords

x_min = x

y_min = y

params = [];

# Save the state of the leaf blocks

# Check for string variables within the blocks

for param in block.get_params():

# If a block parameter exists that is a variable, create a parameter for it

if param.get_value() == variable.get_id():

params.append(param.get_value())

# If a block parameter exists that is a parameter, create a parameter for it

if param.get_value() == flow_param.get_id():

params.append(param.get_value())

sink_id = connection.get_sink().get_parent().get_id()

# If connected block is not in the list of selected blocks create a pad for it

pads.append({'key': connection.get_sink().get_key(), 'coord': connection.get_source().get_coordinate(), 'block_id' : block.get_id(), 'direction': 'source'})

pads.append({'key': connection.get_source().get_key(), 'coord': connection.get_sink().get_coordinate(), 'block_id' : block.get_id(), 'direction': 'sink'})

self.main_window.new_page()

Actions.BLOCK_PASTE()

coords = (x_min,y_min)

# Set flow graph to heir block type

top_block.get_param('generate_options').set_value('hb')

# this needs to be a unique name

top_block.get_param('id').set_value('new_heir')

# Remove the default samp_rate variable block that is created

# Add the param blocks along the top of the window

x_pos = 150

for param in params:

param_block.get_param('id').set_value(param)

x_pos = x_pos + 100

if pad['direction'] == 'sink':

# Add new PAD_SINK block to the canvas

# setup the references to the sink and source

pad_sink = pad_block.get_sinks()[0]

source = source_block.get_source(pad['key'])

# Ensure the port types match

pad_block.type_controller_modify(1)

# Connect the pad to the proper sinks

elif pad['direction'] == 'source':

# setup the references to the sink and source

pad_source = pad_block.get_sources()[0]

sink = sink_block.get_sink(pad['key'])

# Ensure the port types match

pad_block.type_controller_modify(1)

# Connect the pad to the proper sinks

# update the new heir block flow graph

##################################################

# Move/Rotate/Delete/Create

##################################################

elif action == Actions.BLOCK_MOVE:

elif action in Actions.BLOCK_ALIGNMENTS:

elif action == Actions.BLOCK_ROTATE_CCW:

elif action == Actions.BLOCK_ROTATE_CW:

elif action == Actions.ELEMENT_DELETE:

Actions.NOTHING_SELECT()

elif action == Actions.ELEMENT_CREATE:

Actions.NOTHING_SELECT()

elif action == Actions.BLOCK_INC_TYPE:

elif action == Actions.BLOCK_DEC_TYPE:

elif action == Actions.PORT_CONTROLLER_INC:

elif action == Actions.PORT_CONTROLLER_DEC:

##################################################

# Window stuff

##################################################

elif action == Actions.ABOUT_WINDOW_DISPLAY:

Dialogs.AboutDialog(platform.config)

elif action == Actions.HELP_WINDOW_DISPLAY:

Dialogs.HelpDialog()

elif action == Actions.TYPES_WINDOW_DISPLAY:

elif action == Actions.ERRORS_WINDOW_DISPLAY:

elif action == Actions.TOGGLE_REPORTS_WINDOW:

if action.get_active():

self.main_window.reports_scrolled_window.show()

elif action == Actions.CLEAR_REPORTS:

self.main_window.text_display.clear()

elif action == Actions.SAVE_REPORTS:

if file_path is not None:

self.main_window.text_display.save(file_path)

elif action == Actions.TOGGLE_HIDE_DISABLED_BLOCKS:

elif action == Actions.TOGGLE_SHOW_FLOWGRAPH_COMPLEXITY:

action.save_to_preferences()

for page in self.main_window.get_pages():

elif action == Actions.TOGGLE_HIDE_VARIABLES:

Actions.NOTHING_SELECT()

action.save_to_preferences()

# Param Modifications

##################################################

elif action == Actions.BLOCK_PARAM_MODIFY:

if selected_block:

self.dialog = PropsDialog(selected_block)

response = gtk.RESPONSE_APPLY

while response == gtk.RESPONSE_APPLY: # rerun the dialog if Apply was hit

response = self.dialog.run()

if response in (gtk.RESPONSE_APPLY, gtk.RESPONSE_ACCEPT):

else: # restore the current state

if response == gtk.RESPONSE_APPLY:

# null action, that updates the main window

Actions.ELEMENT_SELECT()

self.dialog.destroy()

self.dialog = None

elif action == Actions.EXTERNAL_UPDATE:

if self.dialog is not None:

self.dialog.update_gui(force=True)

##################################################

# View Parser Errors

##################################################

# Undo/Redo

##################################################

elif action == Actions.FLOW_GRAPH_UNDO:

if n:

elif action == Actions.FLOW_GRAPH_REDO:

if n:

##################################################

# New/Open/Save/Close

##################################################

elif action == Actions.FLOW_GRAPH_NEW:

self.main_window.new_page()

if args:

elif action == Actions.FLOW_GRAPH_OPEN:

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

self.main_window.close_page()

elif action == Actions.FLOW_GRAPH_SAVE:

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

Actions.FLOW_GRAPH_SAVE_AS()

#otherwise try to save

else:

try:

except IOError:

elif action == Actions.FLOW_GRAPH_SAVE_AS:

if file_path is not None:

Actions.FLOW_GRAPH_SAVE()

Preferences.add_recent_file(file_path)

self.main_window.tool_bar.refresh_submenus()

self.main_window.menu_bar.refresh_submenus()

elif action == Actions.FLOW_GRAPH_SCREEN_CAPTURE:

if file_path is not None:

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

##################################################

# Gen/Exec/Stop

##################################################

elif action == Actions.FLOW_GRAPH_GEN:

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

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:

Actions.FLOW_GRAPH_GEN()

xterm = self.platform.config.xterm_executable

if Preferences.xterm_missing() != xterm:

if not os.path.exists(xterm):

Dialogs.MissingXTermDialog(xterm)

Preferences.xterm_missing(xterm)

Executor.ExecFlowGraphThread(self)

elif action == Actions.FLOW_GRAPH_KILL:

try:

except:

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

pass

elif action == Actions.RELOAD_BLOCKS:

self.main_window.btwin.search_entry.show()

self.main_window.btwin.search_entry.grab_focus()

elif action == Actions.OPEN_HIER:

if b._grc_source:

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

elif action == Actions.BUSSIFY_SOURCES:

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

b.bussify(n, 'source')

Actions.ELEMENT_CREATE()

elif action == Actions.BUSSIFY_SINKS:

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

b.bussify(n, 'sink')

Actions.ELEMENT_CREATE()

elif action == Actions.TOOLS_RUN_FDESIGN:

##################################################

# Global Actions for all States

##################################################

#update general buttons

Actions.BLOCK_PARAM_MODIFY.set_sensitive(bool(selected_block))

Actions.BLOCK_ROTATE_CCW.set_sensitive(bool(selected_blocks))

Actions.BLOCK_ROTATE_CW.set_sensitive(bool(selected_blocks))

#set the exec and stop buttons

self.update_exec_stop()

#saved status

self.main_window.update()

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

self.platform.config.default_canvas_size)

except: pass

#draw the flow graph

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.

"""

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() is not None)