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

* 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

"""

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

"""

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:

# keeping track of coordinates for pasting later

coords = self.get_flow_graph().get_selected_blocks()[0].get_coordinate()

x,y = coords

y_min = y

pads = [];

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

(x,y) = block.get_coordinate()

if x < x_min:

x_min = x

# Get id of connected blocks

source_id = connection.get_source().get_parent().get_id()

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

if self.get_flow_graph().get_block(source_id) not in self.get_flow_graph().get_selected_blocks():

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

# Remove the default samp_rate variable block that is created

remove_me = self.get_flow_graph().get_block("samp_rate")

# Add the param blocks along the top of the window

# Connect the pad to the proper sinks

new_connection = self.get_flow_graph().connect(pad_source,sink)

self.get_flow_graph().update()

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

# Move/Rotate/Delete/Create

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

def __init__ (self, action_handler):

"""

ExecFlowGraphThread constructor.

Args:

action_handler: an instance of an ActionHandler

"""

"""

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

"""

def get_coordinate(self):

"""

Get the coordinate from the position param.

Returns:

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

"""

def set_coordinate(self, coor):

"""

Set the coordinate into the position param.

Args:

coor: the coordinate tuple (x, y)

"""

def get_rotation(self):

"""

Get the rotation from the position param.

Returns:

the rotation in degrees or 0 if failure

"""

def set_rotation(self, rot):

"""

Set the rotation into the position param.

Args:

rot: the rotation in degrees

"""

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

[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

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

"""

"""

Get the 0,0 coordinate.

Coordinates are irrelevant in connection.

Returns:

0, 0

"""

"""

Get the 0 degree rotation.

Rotations are irrelevant in connection.

Returns:

0

"""

def draw(self, gc, window):

"""

Draw the connection.

Args:

gc: the graphics context

window: the gtk window to draw on

def __init__(self, text=''):

"""

TextDisplay constructor.

Args:

text: the text to display (string)

"""

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

"""

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

"""

"""

DrawingArea contructor.

Connect event handlers.

Args:

main_window: the main_window containing all flow graphs

"""

"""

Is this element horizontal?

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

Args:

rotation: the optional rotation

Returns:

true if rotation is horizontal

"""

"""

Is this element vertical?

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

Args:

rotation: the optional rotation

Returns:

true if rotation is vertical

"""

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

def rotate(self, rotation):

"""

Rotate all of the areas by 90 degrees.

Args:

rotation: multiple of 90 degrees

"""

def set_coordinate(self, coor):

"""

Set the reference coordinate.

Args:

coor: the coordinate tuple (x,y)

"""

def get_parent(self):

"""

Get the parent of this element.

Returns:

the parent

"""

def set_highlighted(self, highlighted):

"""

Set the highlight status.

Args:

highlighted: true to enable highlighting

"""

def is_highlighted(self):

"""

Get the highlight status.

Returns:

true if highlighted

"""

def get_coordinate(self):

"""Get the coordinate.

Returns:

the coordinate tuple (x,y)

"""

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

"""

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

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

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.

"""

def get_rotation(self):

"""

Get the rotation in degrees.

Returns:

the rotation

"""

def set_rotation(self, rotation):

"""

Set the rotation in degrees.

Args:

rotation: the rotation"""

if rotation not in POSSIBLE_ROTATIONS:

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)

def __init__(self, current_file_path=''):

"""

FileDialog constructor.

Args:

current_file_path: the current directory or path to the 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.

Args:

filter: a gtk file 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.

Returns:

the complete file path

"""

def run(self):

"""

Get the filename and destroy the dialog.

Returns:

the filename or None if a close/cancel occured.

"""

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

def copy_to_clipboard(self):

"""

Copy the selected blocks and connections into the clipboard.

Returns:

the clipboard

"""

def paste_from_clipboard(self, clipboard):

"""

Paste the blocks and connections from the clipboard.

Args:

clipboard: the nested data of blocks, connections

"""

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

"""

def port_controller_modify_selected(self, direction):

"""

Change port controller for the selected signal blocks.

Args:

direction: +1 or -1

Returns:

true for changed

"""

def enable_selected(self, enable):

"""

Enable/disable the selected blocks.

Args:

enable: true to enable

Returns:

true if changed

"""

def move_selected(self, delta_coordinate):

"""

Move the element and by the change in coordinates.

Args:

delta_coordinate: the change in coordinates

"""

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.

"""

def remove_selected(self):

"""

Remove selected elements

Returns:

true if changed.

"""

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

"""

def get_selected_connections(self):

"""

Get a group of selected connections.

Returns:

sub set of connections in this flow graph

"""

def get_selected_blocks(self):

"""

Get a group of selected blocks.

Returns:

sub set of blocks in this flow graph

"""

def get_selected_block(self):

"""

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

Returns:

a block or None

"""

def get_selected_elements(self):

"""

Get the group of selected elements.

Returns:

sub set of elements in this flow graph

"""

def get_selected_element(self):

"""

Get the selected element.

Returns:

a block, port, or connection 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.

Returns:

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.

Args:

notebook: the notebook

page: new page

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

"""

"""

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

def close_pages(self):

"""

Close all the pages in this notebook.

Returns:

true if all closed

"""

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

"""

Set the title of the main window.

Set the titles on the page tabs.

Show/hide the reports window.

Args:

title: the window title

"""

def get_page(self):

"""

Get the selected page.

Returns:

the selected page

"""

def get_flow_graph(self):

"""

Get the selected flow graph.

Returns:

the selected flow graph

"""

def _set_page(self, page):

"""

Set the current page.

Args:

page: the page widget

"""

def _save_changes(self):

"""

Save changes to flow graph?

Returns:

true if yes

"""

def _get_files(self):

"""

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

Returns:

list of file paths

"""

def _get_pages(self):

"""

Get a list of all pages in the notebook.

Returns:

list of pages

"""

def register_messenger(messenger):

"""

Append the given messenger to the list of messengers.

Args:

messenger: a method thats takes a string

"""

def send(message):

"""

Give the message to each of the messengers.

Args:

message: a message string

"""

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

"""

Page constructor.

Args:

main_window: main window

file_path: path to a flow graph file

def get_generator(self):

"""

Get the generator object for this flow graph.

Returns:

generator

"""

"""

The button was clicked.

Make the current page selected, then close.

Args:

the: button

"""

def set_markup(self, markup):

"""

Set the markup in this label.

Args:

markup: the new markup text

"""

def get_tab(self):

"""

Get the gtk widget for this page's tab.

Returns:

gtk widget

"""

def get_proc(self):

"""

Get the subprocess for the flow graph.

Returns:

the subprocess object

"""

def set_proc(self, process):

"""

Set the subprocess object.

Args:

process: the new subprocess

"""

def get_flow_graph(self):

"""

Get the flow graph.

Returns:

the flow graph

"""

"""

Get the read-only state of the file.

Always false for empty path.

Returns:

true for read-only

"""

def get_file_path(self):

"""

Get the file path for the flow graph.

Returns:

the file path or ''

"""

def set_file_path(self, file_path=''):

"""

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

Args:

file_path: file path string

"""

def get_saved(self):

"""

Get the saved status for the flow graph.

Returns:

true if saved

"""

def set_saved(self, saved=True):

"""

Set the saved status.

Args:

saved: boolean status

"""

def get_state_cache(self):

"""

Get the state cache for the flow graph.

Returns:

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

Returns:

gtk input class

"""

def get_markup(self):

"""

Get the markup for this param.

Returns:

a pango markup string

"""

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:

def draw(self, gc, window):

"""

Draw the socket with a label.

Args:

gc: the graphics context

window: the gtk window to draw on

def get_connector_coordinate(self):

"""

Get the coordinate where connections may attach to.

Returns:

the connector coordinate (x, y) tuple

"""

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

"""

"""

Get the length of the connector.

The connector length increases as the port index changes.

Returns:

the length in pixels

"""

def get_rotation(self):

"""

Get the parent's rotation rather than self.

Returns:

the parent's rotation

"""

def move(self, delta_coor):

"""

Move the parent rather than self.

Args:

delta_corr: the (delta_x, delta_y) tuple

"""

def rotate(self, direction):

"""

Rotate the parent rather than self.

Args:

direction: degrees to rotate

"""

def get_coordinate(self):

"""

Get the parent's coordinate rather than self.

Returns:

the parents coordinate

"""

def set_highlighted(self, highlight):

"""

Set the parent highlight rather than self.

Args:

highlight: true to enable highlighting

"""

def is_highlighted(self):

"""

Get the parent's is highlight rather than self.

Returns:

the parent's highlighting status

"""

"""

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

"""

def __init__(self, block):

"""

Properties dialog constructor.

Args:

block: a block instance

"""

To the props dialog, the hide setting of 'none' and 'part' are identical.

Therefore, 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

"""

"""

Handle key presses from the keyboard.

Call the ok response when enter is pressed.

Returns:

false to forward the keypress

"""

def run(self):

"""

Run the dialog and get its response.

Returns:

true if the response was accept

"""

def __init__(self, initial_state):

"""

StateCache constructor.

Args:

initial_state: the intial state (nested data)

"""

"""

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

"""

def get_current_state(self):

"""

Get the state at the current index.

Returns:

the current state (nested data)

"""

def get_prev_state(self):

"""

Get the previous state and decrement the current index.

Returns:

the previous state or None

"""

def get_next_state(self):

"""

Get the nest state and increment the current index.

Returns:

the next state or None

"""

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

def get_rotated_coordinate(coor, rotation):

"""

Rotate the coordinate by the given rotation.

Args:

coor: the coordinate x, y tuple

rotation: the angle in degrees

Returns:

the rotated coordinates

"""

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.

Args:

(x1,y1): the coordinate of point 1

(x2,y2): the coordinate of point 2

Returns:

the direction in degrees

"""

"""

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

"""