<name>Packet Decoder</name>

<key>blks2_packet_decoder</key>

<category>Deprecated</category>

<import>from grc_gnuradio import blks2 as grc_blks2</import>

<make>grc_blks2.packet_demod_$(type.fcn)(grc_blks2.packet_decoder(

access_code=$access_code,

<name>Packet Encoder</name>

<key>blks2_packet_encoder</key>

<category>Deprecated</category>

<import>from grc_gnuradio import blks2 as grc_blks2</import>

<make>grc_blks2.packet_mod_$(type.fcn)(grc_blks2.packet_encoder(

samples_per_symbol=$samples_per_symbol,

namespace gr {

namespace digital {

* \ingroup ofdm_blk

* \ingroup equalizers_blk

*/

namespace gr {

namespace digital {

* \ingroup ofdm_blk

* \ingroup equalizers_blk

*

namespace gr {

namespace digital {

* \ingroup ofdm_blk

* \ingroup equalizers_blk

*

self.\$(id).set_bandwidth(\$bw$(n), $n)

\#end if

#if $sourk == 'source'

\#if \$dc_offs_enb$(n)()

self.\$(id).set_auto_dc_offset(\$dc_offs_enb$(n), $n)

\#end if

self.\$(id).set_gain(\$gain$(n), $n)

\#end if

</callback>

<callback>set_antenna(\$ant$(n), $n)</callback>

<callback>set_bandwidth(\$bw$(n), $n)</callback>

#end for

</param>

#if $sourk == 'source'

<param>

<name>Ch$(n): Enable DC Offset Correction</name>

<key>dc_offs_enb$(n)</key>

<value>""</value>

</param>

"""

TSBTAG_PARAM = """ <param>

<name>TSB tag name</name>

<key>len_tag_name</key>

else: raise Exception, 'is %s a source or sink?'%file

params = ''.join([parse_tmpl(PARAMS_TMPL, n=n, sourk=sourk) for n in range(max_num_channels)])

if sourk == 'sink':

params += TSBTAG_PARAM

lentag_arg = TSBTAG_ARG

*/

virtual ::uhd::dict<std::string, std::string> get_usrp_info(size_t chan = 0) = 0;

/*!

* Enable/disable the automatic DC offset correction.

* The automatic correction subtracts out the long-run average.

namespace gr {

namespace uhd {

class usrp_block_impl : virtual public usrp_block

{

public:

namespace gr {

namespace uhd {

usrp_sink::sptr

usrp_sink::make(const ::uhd::device_addr_t &device_addr,

const ::uhd::io_type_t &io_type,

return _dev->get_rx_bandwidth_range(chan);

}

void

usrp_source_impl::set_auto_dc_offset(const bool enable, size_t chan)

{

::uhd::sensor_value_t get_sensor(const std::string &name, size_t chan);

std::vector<std::string> get_sensor_names(size_t chan);

::uhd::usrp::dboard_iface::sptr get_dboard_iface(size_t chan);

// Set Commands

void set_subdev_spec(const std::string &spec, size_t mboard);

void set_iq_balance(const std::complex<double> &correction, size_t chan);

void set_stream_args(const ::uhd::stream_args_t &stream_args);

void set_start_time(const ::uhd::time_spec_t &time);

void issue_stream_cmd(const ::uhd::stream_cmd_t &cmd);

void flush(void);

////////////////////////////////////////////////////////////////////////

%{

static const size_t ALL_MBOARDS = uhd::usrp::multi_usrp::ALL_MBOARDS;

%}

static const size_t ALL_MBOARDS;

%{

#include <uhd/version.hpp>

#

# This file is part of GNU Radio

#

#make sure our local CMake Modules path comes first

list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_SOURCE_DIR}/cmake/Modules)

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

# Compiler specific setup

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

set(GR_REQUIRED_COMPONENTS RUNTIME)

find_package(Gnuradio "3.7.2" REQUIRED)

list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_SOURCE_DIR}/cmake/Modules)

if(NOT CPPUNIT_FOUND)

message(FATAL_ERROR "CppUnit required to compile howto")

#

# This file is part of GNU Radio

#

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

# Install built library files

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

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

# Build and register unit test

)

GR_ADD_TEST(test_howto test-howto)

if self._info['lang'] is None:

while self._info['lang'] not in ['cpp', 'python']:

self._info['lang'] = raw_input("Language (python/cpp): ")

print "Language: %s" % {'cpp': 'C++', 'python': 'Python'}[self._info['lang']]

<import>import time</import>

<import>import threading</import>

<var_make>self.$(id) = $(id) = $value</var_make>

def _$(id)_probe():

while True:

#set $obj = 'self' + ('.' + $block_id() if $block_id() else '')

time.sleep(1.0 / ($poll_rate))

_$(id)_thread = threading.Thread(target=_$(id)_probe)

_$(id)_thread.daemon = True

<callback>self.set_$(id)($value)</callback>

<param>

<name>Block ID</name>

<key>block_id</key>

<value>my_block_0</value>

<value>10</value>

<type>real</type>

</param>

<doc>

Periodically probe a function and set its value to this variable.

BLOCK_FLAG_NEED_QT_GUI, BLOCK_FLAG_NEED_WX_GUI,

ADVANCED_PARAM_TAB, DEFAULT_PARAM_TAB,

BLOCK_FLAG_THROTTLE, BLOCK_FLAG_DISABLE_BYPASS,

BLOCK_ENABLED, BLOCK_BYPASSED, BLOCK_DISABLED

)

from . Element import Element

def _get_keys(lst):

# indistinguishable from normal GR blocks. Make explicit

# checks for them here since they have no work function or

# buffers to manage.

"virtual_source", "virtual_sink", "pad_source", "pad_sink")

# Disable blocks that are virtual/pads or variables

self._flags += BLOCK_FLAG_DISABLE_BYPASS

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

block=self,

n=odict({'name': 'Block Alias',

})

))

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

block=self,

n=odict({'name': 'Core Affinity',

'tab': ADVANCED_PARAM_TAB

})

))

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

block=self,

n=odict({'name': 'Min Output Buffer',

self.add_error_message('Check "{}" did not evaluate.'.format(check))

# For variables check the value (only if var_value is used

value = self._var_value

try:

value = self.get_var_value()

"""

Resolve all import statements.

Split each import statement at newlines.

Filter empty imports.

Returns:

def bypass_disabled(self):

return BLOCK_FLAG_DISABLE_BYPASS in self._flags

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

# Access Params

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

BLOCK_FLAG_DISABLE_BYPASS = 'disable_bypass'

BLOCK_FLAG_NEED_QT_GUI = 'need_qt_gui'

BLOCK_FLAG_NEED_WX_GUI = 'need_wx_gui'

# Block States

BLOCK_DISABLED = 0

is_flow_graph = False

is_block = False

is_dummy_block = False

is_connection = False

is_port = False

is_param = False

import imp

import time

from itertools import ifilter, chain

import re

from .Element import Element

from .utils import odict, expr_utils

_parameter_matcher = re.compile('^(parameter)$')

_monitors_searcher = re.compile('(ctrlport_monitor)')

_bussink_searcher = re.compile('^(bus_sink)$')

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

def get_imports(self):

"""

Returns:

a set of import statements

"""

def get_variables(self):

"""

Get a list of all variables in this flow graph namespace.

Returns:

a sorted list of variable blocks in order of dependency (indep -> dep)

"""

return expr_utils.sort_objects(variables, methodcaller('get_id'), methodcaller('get_var_make'))

def get_parameters(self):

"""

Returns:

"""

parameters = filter(lambda b: _parameter_matcher.match(b.get_key()), self.iter_enabled_blocks())

return parameters

)

def send_xml_errors_if_any(xml_failures):

if xml_failures:

send('\nXML parser: Found {0} erroneous XML file{1} while loading the '

filter(lambda b: b.get_enabled() and not b.get_bypassed(), fg.blocks),

lambda b: b.get_id(), _get_block_sort_text

)

# List of regular blocks (all blocks minus the special ones)

blocks = filter(lambda b: b not in (imports + parameters), blocks_all)

connection_templates = fg.get_parent().connection_templates

msgs = filter(lambda c: c.is_msg(), fg.get_enabled_connections())

# List of variable names

var_ids = [var.get_id() for var in parameters + variables]

replace_dict = dict((var_id, 'self.' + var_id) for var_id in var_ids)

callbacks_all = []

for block in blocks_all:

callbacks_all.extend(expr_utils.expr_replace(cb, replace_dict) for cb in block.get_callbacks())

# Map var id to callbacks

callbacks = {}

for var_id in var_ids:

# Load the namespace

namespace = {

'title': title,

"""

import string

class graph(object):

return self._graph[node_key]

"""

Split up an expression by non alphanumeric characters, including underscore.

Leave strings in-tact.

tok = ''

quote = ''

for char in expr:

if char == quote:

quote = ''

tok += char

Returns:

a new expression with the prepend

"""

for i, es in enumerate(expr_splits):

if es in replace_dict.keys():

expr_splits[i] = replace_dict[es]

sorted_ids = sort_variables(id2expr)

# Return list of sorted objects

return [id2obj[id] for id in sorted_ids]

from . import Dialogs, Preferences, Actions, Executor, Constants

from .FileDialogs import (OpenFlowGraphFileDialog, SaveFlowGraphFileDialog,

OpenQSSFileDialog)

from .MainWindow import MainWindow

from .ParserErrorsDialog import ParserErrorsDialog

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.send_init(platform)

#initialize

self.init_file_paths = file_paths

Actions.APPLICATION_INITIALIZE()

def _handle_key_press(self, widget, event):

def _handle_action(self, action, *args):

#print action

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

# Initialize/Quit

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

self.init_file_paths = filter(os.path.exists, Preferences.get_open_files())

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

for file_path in self.init_file_paths:

if Preferences.file_open() in self.init_file_paths:

# Disable all actions, then re-enable a few

for action in Actions.get_all_actions():

Actions.FLOW_GRAPH_CLOSE, Actions.ABOUT_WINDOW_DISPLAY,

Actions.FLOW_GRAPH_SCREEN_CAPTURE, Actions.HELP_WINDOW_DISPLAY,

Actions.TYPES_WINDOW_DISPLAY, Actions.TOGGLE_BLOCKS_WINDOW,

Actions.TOOLS_RUN_FDESIGN, Actions.TOGGLE_SCROLL_LOCK,

Actions.TOGGLE_AUTO_HIDE_PORT_LABELS, Actions.TOGGLE_SNAP_TO_GRID,

Actions.TOGGLE_SHOW_BLOCK_COMMENTS,

Actions.TOGGLE_SHOW_CODE_PREVIEW_TAB,

Actions.TOGGLE_SHOW_FLOWGRAPH_COMPLEXITY,

Actions.FLOW_GRAPH_OPEN_QSS_THEME,

Actions.SELECT_ALL,

):

action.set_sensitive(True)

if ParseXML.xml_failures:

Messages.send_xml_errors_if_any(ParseXML.xml_failures)

Actions.XML_PARSER_ERRORS_DISPLAY.set_sensitive(True)

elif action == Actions.APPLICATION_QUIT:

gtk.main_quit()

exit(0)

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

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

# Copy the selected blocks and paste them into a new page

# then move the flowgraph to a reasonable position

Actions.BLOCK_COPY()

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 == 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:

action.save_to_preferences()

elif action == Actions.TOGGLE_BLOCKS_WINDOW:

action.save_to_preferences()

elif action == Actions.TOGGLE_SCROLL_LOCK:

active = action.get_active()

if active:

action.save_to_preferences()

if file_path is not None:

elif action == Actions.TOGGLE_HIDE_DISABLED_BLOCKS:

Actions.NOTHING_SELECT()

elif action == Actions.TOGGLE_AUTO_HIDE_PORT_LABELS:

action.save_to_preferences()

page.get_flow_graph().create_shapes()

action.save_to_preferences()

action.save_to_preferences()

action.save_to_preferences()

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:

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

Preferences.add_recent_file(file_path)

elif action == Actions.FLOW_GRAPH_OPEN_QSS_THEME:

file_paths = OpenQSSFileDialog(self.platform.config.install_prefix +

except Exception as e:

Messages.send("Failed to save QSS preference: " + str(e))

elif action == Actions.FLOW_GRAPH_CLOSE:

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)

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

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)

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.platform.load_blocks()

Actions.XML_PARSER_ERRORS_DISPLAY.set_sensitive(bool(

ParseXML.xml_failures))

Messages.send_xml_errors_if_any(ParseXML.xml_failures)

# Force a redraw of the graph, by getting the current state and re-importing it

elif action == Actions.FIND_BLOCKS:

elif action == Actions.OPEN_HIER:

if b._grc_source:

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

#update cut/copy/paste

Actions.BLOCK_CUT.set_sensitive(bool(selected_blocks))

Actions.BLOCK_COPY.set_sensitive(bool(selected_blocks))

#set the exec and stop buttons

self.update_exec_stop()

#saved status

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)

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

"""

def __repr__(self): return str(self)

"""

Emit the activate signal when called with ().

"""

self.emit('activate')

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

PAGE_CHANGE = Action()

EXTERNAL_UPDATE = Action()

FLOW_GRAPH_NEW = Action(

label='_New',

tooltip='Create a new flow graph',

stock_id=gtk.STOCK_GO_FORWARD,

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

)

BLOCK_PARAM_MODIFY = Action(

label='_Properties',

tooltip='Modify params for the selected block',

stock_id=gtk.STOCK_MISSING_IMAGE,

keypresses=(gtk.keysyms.d, gtk.gdk.CONTROL_MASK),

)

TOGGLE_AUTO_HIDE_PORT_LABELS = ToggleAction(

label='Auto-Hide _Port Labels',

tooltip='Automatically hide port labels',

tooltip='View flow graph errors',

stock_id=gtk.STOCK_DIALOG_ERROR,

)

keypresses=(gtk.keysyms.r, gtk.gdk.CONTROL_MASK),

)

TOGGLE_BLOCKS_WINDOW = ToggleAction(

label='Show _Block Tree Panel',

preference_name='blocks_window_visible'

)

TOGGLE_SCROLL_LOCK = ToggleAction(

preference_name='scroll_lock'

)

ABOUT_WINDOW_DISPLAY = Action(

keypresses=(gtk.keysyms.f, gtk.gdk.CONTROL_MASK,

gtk.keysyms.slash, NO_MODS_MASK),

)

stock_id=gtk.STOCK_CLEAR,

)

stock_id=gtk.STOCK_SAVE,

)

OPEN_HIER = Action(

Actions.FLOW_GRAPH_SAVE,

Actions.FLOW_GRAPH_CLOSE,

None,

Actions.FLOW_GRAPH_SCREEN_CAPTURE,

None,

Actions.BLOCK_CUT,

None,

Actions.BLOCK_ROTATE_CCW,

Actions.BLOCK_ROTATE_CW,

None,

Actions.BLOCK_ENABLE,

Actions.BLOCK_DISABLE,

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

Actions.TOGGLE_BLOCKS_WINDOW,

None,

Actions.TOGGLE_SCROLL_LOCK,

None,

Actions.TOGGLE_HIDE_DISABLED_BLOCKS,

Actions.TOGGLE_AUTO_HIDE_PORT_LABELS,

import gtk

import pango

from . Element import Element

from ..core.Param import num_to_str

from ..core.utils import odict

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

if y <= 0:

y = 0

return (x, y)

except:

self.set_coordinate((0, 0))

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

return int(rotation)

except:

def set_rotation(self, rot):

"""

#create the main layout

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

layouts.append(layout)

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

#display the params

if self.is_dummy_block:

markups = [

]

else:

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_markup('\n'.join(markups))

layouts.append(layout)

w, h = layout.get_pixel_size()

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

width = self.label_width

height = self.label_height

#setup the pixmap

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

else: w_off = 0

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

#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

def get_min_height_for_ports():

visible_ports = filter(lambda p: not p.get_hide(), ports)

if visible_ports:

min_height -= ports[0].H

return min_height

H = max(

[ # labels

] +

[ # ports

get_min_height_for_ports() for ports in (self.get_sources_gui(), self.get_sinks_gui())

] +

[ # bus ports only

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

]

)

block=self,

comment=comment,

complexity=complexity,

# Setup the pixel map. Make sure that layout not empty

width, height = layout.get_pixel_size()

if width and height:

pixmap = self.get_parent().new_pixmap(width + 2 * padding,

height + 2 * padding)

gc = pixmap.new_gc()

)

#draw label image

if self.is_horizontal():

elif self.is_vertical():

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

"""

if not self._comment_pixmap:

return

x, y = self.get_coordinate()

#block color constants

BLOCK_ENABLED_COLOR = get_color('#F1ECFF')

BLOCK_DISABLED_COLOR = get_color('#CCCCCC')

#connection color constants

CONNECTION_ENABLED_COLOR = get_color('black')

CONNECTION_DISABLED_COLOR = get_color('#BBBBBB')

MIN_DIALOG_HEIGHT = 500

# default sizes

DEFAULT_BLOCKS_WINDOW_WIDTH = 100

DEFAULT_CANVAS_SIZE_DEFAULT = 1280, 1024

buffer.delete(buffer.get_start_iter(), buffer.get_end_iter())

def save(self, file_path):

buffer = self.get_buffer()

# Callback functions to handle the scrolling lock and clear context menus options

# Action functions are set by the ActionHandler's init function

def clear_cb(self, menu_item, web_view):

def scroll_back_cb(self, menu_item, web_view):

Actions.TOGGLE_SCROLL_LOCK()

def save_cb(self, menu_item, web_view):

def populate_popup(self, view, menu):

"""Create a popup menu for the scroll lock and clear functions"""

class ExecFlowGraphThread(threading.Thread):

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

"""

ExecFlowGraphThread constructor.

action_handler: an instance of an ActionHandler

"""

threading.Thread.__init__(self)

try:

self.start()

Messages.send_verbose_exec(str(e))

Messages.send_end_exec()

"""

Execute this python flow graph.

"""

generator = self.page.get_generator()

try:

Wait on the executing process by reading from its stdout.

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

"""

r = "\n"

while r:

gobject.idle_add(Messages.send_verbose_exec, r)

gobject.idle_add(self.done)

def done(self):

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

self.page.set_proc(None)

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

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

OPEN_FLOW_GRAPH = 'open flow graph'

SAVE_FLOW_GRAPH = 'save flow graph'

SAVE_IMAGE = 'save image'

OPEN_QSS_THEME = 'open qss theme'

FILE_DNE_MARKUP_TMPL="""\

File <b>$encode($filename)</b> Does not Exist!"""

# File Filters

def get_flow_graph_files_filter():

filter = gtk.FileFilter()

filter.set_name('Flow Graph Files')

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

return filter

def get_text_files_filter():

filter = gtk.FileFilter()

filter.set_name('Text Files')

filter.add_pattern('*'+TEXT_FILE_EXTENSION)

return filter

def get_image_files_filter():

filter = gtk.FileFilter()

filter.set_name('Image Files')

filter.add_pattern('*'+IMAGE_FILE_EXTENSION)

return filter

def get_all_files_filter():

filter = gtk.FileFilter()

filter.set_name('All Files')

filter.add_pattern('*')

return filter

def get_qss_themes_filter():

filter = gtk.FileFilter()

filter.set_name('QSS Themes')

filter.add_pattern('*.qss')

return filter

# File Dialogs

class FileDialogHelper(gtk.FileChooserDialog):

"""

A wrapper class for the gtk file chooser dialog.

self.set_local_only(True)

self.add_filter(get_all_files_filter())

class FileDialog(FileDialogHelper):

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

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

self.add_and_set_filter(get_text_files_filter())

file_path = path.splitext(path.basename(current_file_path))[0]

self.set_current_name(file_path) #show the current filename

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

# Handle Save Dialogs

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

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

self.destroy()

return filename

class SaveScreenShotDialog(SaveImageFileDialog):

selected_block.move(delta_coordinate)

self.element_moved = True

def rotate_selected(self, rotation):

"""

Rotate the selected blocks by multiples of 90 degrees.

Returns:

true if changed, otherwise 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()

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

#draw blocks on top of connections

hide_disabled_blocks = Actions.TOGGLE_HIDE_DISABLED_BLOCKS.get_active()

blocks = sorted(self.blocks, key=methodcaller('get_enabled'))

for element in chain(self.connections, blocks):

if hide_disabled_blocks and not element.get_enabled():

continue # skip hidden disabled blocks and connections

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_port = None

selected = set()

#check the elements

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

selected_element = element.what_is_selected(coor, coor_m)

continue

#update the selected port information

if selected_element.is_port:

Returns:

a block or None

"""

def get_selected_elements(self):

"""

Returns:

a block, port, or connection or None

"""

def update_selected_elements(self):

"""

from . import Bars, Actions, Preferences, Utils

from .BlockTreeWindow import BlockTreeWindow

from .Constants import \

from .Dialogs import TextDisplay, MessageDialogHelper

from .NotebookPage import NotebookPage

#end if

"""

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

# Main window

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

class MainWindow(gtk.Window):

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

def __init__(self, platform, action_handler_callback):

"""

"""

self._platform = platform

(o.get_key(), o.get_name(), o.get_key() == generate_mode_default)

for o in gen_opts.get_options()]

Preferences.load(platform)

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

vbox = gtk.VBox()

self.add(vbox)

self.add_accel_group(Actions.get_accel_group())

self.menu_bar = Bars.MenuBar(generate_modes, action_handler_callback)

vbox.pack_start(self.menu_bar, False)

vbox.pack_start(self.tool_bar, False)

self.notebook = gtk.Notebook()

self.page_to_be_closed = None

self.current_page = None

self.notebook.set_show_border(False)

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

self.text_display = TextDisplay()

self.resize(*Preferences.main_window_size())

self.show_all()

self.btwin.hide()

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

page_num: new page number

"""

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

Actions.PAGE_CHANGE()

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

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

"""

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

Preferences.set_open_files(open_files)

Preferences.file_open(open_file)

Preferences.main_window_size(self.get_size())

Preferences.save()

return True

"""

Set the title of the main window.

Set the titles on the page tabs.

Args:

title: the window title

#show/hide notebook tabs

self.notebook.set_show_tabs(len(self.get_pages()) > 1)

def update_pages(self):

"""

Forces a reload of all the pages in this notebook.

file_path: path to a flow graph file

"""

self._flow_graph = flow_graph

#import the file

self.main_window = main_window

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

self.state_cache = StateCache(initial_state)

#import the data to the flow graph

self.get_flow_graph().import_data(initial_state)

#initialize page gui

Args:

file_path: file path string

"""

def get_saved(self):

"""

self._have_pending_changes = True

self._update_gui()

if self._editing_callback:

def _apply_change(self, *args):

"""

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

#call the callback

if self._changed_callback:

else:

self.param.validate()

#gui update

return self._input.get_text()

def set_color(self, color):

def set_tooltip_text(self, text):

try:

set_recent_files(recent_files[:10]) # Keep up to 10 files

def blocks_window_position(pos=None):

return entry('blocks_window_position', pos, default=-1) or 1

def xterm_missing(cmd=None):

return entry('xterm_missing', cmd, default='INVALID_XTERM_SETTING')

parse_template = TemplateParser()

try:

except TypeError:

x = coor