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.

"""

self.clipboard = None

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

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

"""

if not self.get_focus_flag(): return False

return Actions.handle_key_press(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.

"""

Actions.APPLICATION_QUIT()

return True

def __init__ (self, action_handler):

"""

ExecFlowGraphThread constructor.

"""

Thread.__init__(self)

self.update_exec_stop = action_handler.update_exec_stop

"""

Call the action associated with the key press event.

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

"""

_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

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

"""

Create a new Action instance.

"""

if name is None: name = label

gtk.Action.__init__(self,

def get_coordinate(self):

"""

Get the coordinate from the position param.

"""

try: #should evaluate to tuple

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

def set_coordinate(self, coor):

"""

Set the coordinate into the position param.

"""

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

def get_rotation(self):

"""

Get the rotation from the position param.

"""

try: #should evaluate to dict

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

def set_rotation(self, rot):

"""

Set the rotation into the position param.

"""

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

def draw(self, gc, window):

"""

Draw the signal block with label and inputs/outputs.

"""

x, y = self.get_coordinate()

#draw main block

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

"""

Get the element that is selected.

"""

for port in self.get_ports():

port_selected = port.what_is_selected(coor, coor_m)

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.

"""

gtk.VBox.__init__(self)

self.platform = platform

"""

Add a block with category to this selection window.

Add only the category when block is None.

"""

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

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

def _get_selected_block_key(self):

"""

Get the currently selected block key.

"""

selection = self.treeview.get_selection()

treestore, iter = selection.get_selected()

"""

Get the 0,0 coordinate.

Coordinates are irrelevant in connection.

"""

return (0, 0)

"""

Get the 0 degree rotation.

Rotations are irrelevant in connection.

"""

return 0

def draw(self, gc, window):

"""

Draw the connection.

"""

sink = self.get_sink()

source = self.get_source()

def __init__(self, text=''):

"""

TextDisplay constructor.

"""

text_buffer = gtk.TextBuffer()

text_buffer.set_text(text)

def MessageDialogHelper(type, buttons, title=None, markup=None):

"""

Create a modal message dialog and run it.

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

"""

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

if title: message_dialog.set_title(title)

"""

DrawingArea contructor.

Connect event handlers.

"""

self.ctrl_mask = False

self._flow_graph = flow_graph

"""

Is this element horizontal?

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

"""

rotation = rotation or self.get_rotation()

return rotation in (0, 180)

"""

Is this element vertical?

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

"""

rotation = rotation or self.get_rotation()

return rotation in (90, 270)

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

"""

Draw in the given window.

"""

X,Y = self.get_coordinate()

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

def rotate(self, rotation):

"""

Rotate all of the areas by 90 degrees.

"""

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

def set_coordinate(self, coor):

"""

Set the reference coordinate.

"""

self.coor = coor

def get_parent(self):

"""

Get the parent of this element.

"""

return self.parent

def set_highlighted(self, highlighted):

"""

Set the highlight status.

"""

self.highlighted = highlighted

def is_highlighted(self):

"""

Get the highlight status.

"""

return self.highlighted

def get_coordinate(self):

"""Get the coordinate.

"""

return self.coor

def move(self, delta_coor):

"""

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

"""

deltaX, deltaY = delta_coor

X, Y = self.get_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.

"""

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

A line is defined by 2 relative coordinates.

Lines must be horizontal or vertical.

The line is associated with a rotation.

"""

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

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?

"""

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

def get_rotation(self):

"""

Get the rotation in degrees.

"""

return self.rotation

def set_rotation(self, rotation):

"""

Set the rotation in degrees.

if rotation not in POSSIBLE_ROTATIONS:

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

self.rotation = rotation

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.

"""

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

def __init__(self, current_file_path=''):

"""

FileDialog constructor.

"""

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:

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.

"""

self.add_filter(filter)

self.set_filter(filter)

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.

"""

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

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

def run(self):

"""

Get the filename and destroy the dialog.

"""

filename = self.get_rectified_filename()

self.destroy()

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

"""

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

"""

id = self._get_unique_id(key)

#calculate the position coordinate

def copy_to_clipboard(self):

"""

Copy the selected blocks and connections into the clipboard.

"""

#get selected blocks

blocks = self.get_selected_blocks()

def paste_from_clipboard(self, clipboard):

"""

Paste the blocks and connections from the clipboard.

"""

selected = set()

(x_min, y_min), blocks_n, connections_n = clipboard

def type_controller_modify_selected(self, direction):

"""

Change the registered type controller for the selected signal blocks.

"""

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.

"""

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

def enable_selected(self, enable):

"""

Enable/disable the selected blocks.

"""

changed = False

for selected_block in self.get_selected_blocks():

def move_selected(self, delta_coordinate):

"""

Move the element and by the change in coordinates.

"""

for selected_block in self.get_selected_blocks():

selected_block.move(delta_coordinate)

def rotate_selected(self, rotation):

"""

Rotate the selected blocks by multiples of 90 degrees.

"""

if not self.get_selected_blocks(): return False

#initialize min and max coordinates

def remove_selected(self):

"""

Remove selected elements

"""

changed = False

for selected_element in self.get_selected_elements():

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.

"""

selected_port = None

selected = set()

def get_selected_connections(self):

"""

Get a group of selected connections.

"""

selected = set()

for selected_element in self.get_selected_elements():

def get_selected_blocks(self):

"""

Get a group of selected blocks.

"""

selected = set()

for selected_element in self.get_selected_elements():

def get_selected_block(self):

"""

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

"""

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

def get_selected_elements(self):

"""

Get the group of selected elements.

"""

return self._selected_elements

def get_selected_element(self):

"""

Get the selected element.

"""

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

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.

"""

Actions.APPLICATION_QUIT()

return True

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.

"""

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

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

def add_report_line(self, line):

"""

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

"""

self.text_display.insert(line)

vadj = self.reports_scrolled_window.get_vadjustment()

"""

Create a new notebook page.

Set the tab to be selected.

"""

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

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

def close_pages(self):

"""

Close all the pages in this notebook.

"""

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

open_file = self.get_page().get_file_path()

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.

"""

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

Set the title of the main window.

Set the titles on the page tabs.

Show/hide the reports window.

"""

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

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

def get_page(self):

"""

Get the selected page.

"""

return self.current_page

def get_flow_graph(self):

"""

Get the selected flow graph.

"""

return self.get_page().get_flow_graph()

def get_focus_flag(self):

"""

Get the focus flag from the current page.

"""

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

def _set_page(self, page):

"""

Set the current page.

"""

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?

"""

return MessageDialogHelper(

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

def _get_files(self):

"""

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

"""

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

def _get_pages(self):

"""

Get a list of all pages in the notebook.

"""

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

def register_messenger(messenger):

"""

Append the given messenger to the list of messengers.

"""

MESSENGERS_LIST.append(messenger)

def send(message):

"""

Give the message to each of the messengers.

"""

for messenger in MESSENGERS_LIST: messenger(message)

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

"""

Page constructor.

"""

self._flow_graph = flow_graph

self.set_proc(None)

def get_generator(self):

"""

Get the generator object for this flow graph.

"""

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

self.get_flow_graph(),

"""

The button was clicked.

Make the current page selected, then close.

"""

self.main_window.page_to_be_closed = self

Actions.FLOW_GRAPH_CLOSE()

def set_markup(self, markup):

"""

Set the markup in this label.

"""

self.label.set_markup(markup)

def get_tab(self):

"""

Get the gtk widget for this page's tab.

"""

return self.tab

def get_proc(self):

"""

Get the subprocess for the flow graph.

"""

return self.process

def set_proc(self, process):

"""

Set the subprocess object.

"""

self.process = process

def get_flow_graph(self):

"""

Get the flow graph.

"""

return self._flow_graph

"""

Get the read-only state of the file.

Always false for empty path.

"""

if not self.get_file_path(): return False

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

def get_file_path(self):

"""

Get the file path for the flow graph.

"""

return self.file_path

def set_file_path(self, file_path=''):

"""

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

"""

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.

"""

return self.saved

def set_saved(self, saved=True):

"""

Set the saved status.

"""

self.saved = saved

def get_state_cache(self):

"""

Get the state cache for the flow graph.

"""

return self.state_cache

An enum requires and combo parameter.

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

All others get a standard entry parameter.

"""

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

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

def get_markup(self):

"""

Get the markup for this param.

"""

return Utils.parse_template(PARAM_MARKUP_TMPL, param=self)

def draw(self, gc, window):

"""

Draw the socket with a label.

"""

Element.draw(

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

def get_connector_coordinate(self):

"""

Get the coordinate where connections may attach to.

"""

x,y = self._connector_coordinate

X,Y = self.get_coordinate()

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.

"""

if self.is_source(): return self.get_rotation()

elif self.is_sink(): return (self.get_rotation() + 180)%360

"""

Get the length of the connector.

The connector length increases as the port index changes.

"""

return self._connector_length

def get_rotation(self):

"""

Get the parent's rotation rather than self.

"""

return self.get_parent().get_rotation()

def move(self, delta_coor):

"""

Move the parent rather than self.

"""

self.get_parent().move(delta_coor)

def rotate(self, direction):

"""

Rotate the parent rather than self.

"""

self.get_parent().rotate(direction)

def get_coordinate(self):

"""

Get the parent's coordinate rather than self.

"""

return self.get_parent().get_coordinate()

def set_highlighted(self, highlight):

"""

Set the parent highlight rather than self.

"""

self.get_parent().set_highlighted(highlight)

def is_highlighted(self):

"""

Get the parent's is highlight rather than self.

"""

return self.get_parent().is_highlighted()

"""

Get a title label for the params window.

The title will be bold, underlined, and left justified.

"""

label = gtk.Label()

label.set_markup('\n<b><span underline="low">%s</span>:</b>\n'%title)

def __init__(self, block):

"""

Properties dialog contructor.

"""

self._hash = 0

LABEL_SPACING = 7

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.

"""

old_hash = self._hash

#create a tuple of things from each param that affects the params box

"""

Handle key presses from the keyboard.

Call the ok response when enter is pressed.

"""

if event.keyval == gtk.keysyms.Return:

self.response(gtk.RESPONSE_ACCEPT)

def run(self):

"""

Run the dialog and get its response.

"""

response = gtk.Dialog.run(self)

self.destroy()

def __init__(self, initial_state):

"""

StateCache constructor.

"""

self.states = [None] * STATE_CACHE_SIZE #fill states

self.current_state_index = 0

"""

Save a new state.

Place the new state at the next index and add one to the number of previous states.

"""

self.current_state_index = (self.current_state_index + 1)%STATE_CACHE_SIZE

self.states[self.current_state_index] = state

def get_current_state(self):

"""

Get the state at the current index.

"""

self.update_actions()

return self.states[self.current_state_index]

def get_prev_state(self):

"""

Get the previous state and decrement the current index.

"""

if self.num_prev_states > 0:

self.current_state_index = (self.current_state_index + STATE_CACHE_SIZE -1)%STATE_CACHE_SIZE

def get_next_state(self):

"""

Get the nest state and increment the current index.

"""

if self.num_next_states > 0:

self.current_state_index = (self.current_state_index + 1)%STATE_CACHE_SIZE

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.

"""

width, height = src_pixmap.get_size()

pixbuf = gtk.gdk.Pixbuf(

def get_rotated_coordinate(coor, rotation):

"""

Rotate the coordinate by the given rotation.

"""

#handles negative angles

rotation = (rotation + 360)%360

def get_angle_from_coordinates((x1,y1), (x2,y2)):

"""

Given two points, calculate the vector direction from point1 to point2, directions are multiples of 90 degrees.

"""

if y1 == y2:#0 or 180

if x2 > x1: return 0

"""

Parse the template string with the given args.

Pass in the xml encode method for pango escape chars.

"""

kwargs['encode'] = gobject.markup_escape_text

return str(Template(tmpl_str, kwargs))