- BLOCK_FLAG_NEED_QT_GUI, BLOCK_FLAG_NEED_WX_GUI,

- raise ValueError('Key "{0}" not found in {1}.'.format(key, _get_keys(lst)))

- raise Exception('Key "{0}" already exists in params'.format(key))

- raise Exception('Key "{0}" already exists in sources'.format(key))

- raise Exception('Key "{0}" already exists in sinks'.format(key))

- self.add_error_message('Check "{0}" failed.'.format(check))

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

- self.add_error_message('Value "{0}" cannot be evaluated:\n{1}'.format(value, err))

- self.add_error_message("Can't generate this block in mode: {0} ".format(

- check_generate_mode('WX GUI', BLOCK_FLAG_NEED_WX_GUI, ('wx_gui',))

- return 'self.{0}.{1}'.format(self.get_id(), callback)

- return 'Block - {0} - {1}({2})'.format(self.get_id(), self.get_name(), self.get_key())

- return "Template error: {0}\n {1}".format(tmpl, err)

- COMPONENT "grc"

- COMPONENT "grc"

- def __init__(self, prefs_file, version, version_parts=None):

- return 'Connection (\n\t{0}\n\t\t{1}\n\t{2}\n\t\t{3}\n)'.format(

- def is_msg(self):

- return self.get_source().get_type() == self.get_sink().get_type() == 'msg'

-

- self.add_error_message('No connection known for domains "{0}", "{1}"'.format(

- 'Domain "{0}" can have only one downstream block'.format(source_domain))

- 'Domain "{0}" can have only one upstream block'.format(sink_domain))

- self.add_error_message('Source IO size "{0}" does not match sink IO size "{1}".'.format(source_size, sink_size))

-BLOCK_FLAG_NEED_WX_GUI = 'need_wx_gui'

- ('Message Queue', 'msg', 0, GRC_COLOR_DARK_GREY),

-MSG_COLOR_SPEC = '#777777'

- error_messages.append("{0}:\n\t{1}".format(child, msg.replace("\n", "\n\t")))

-import time

-

-from .utils import odict, expr_utils

- return 'FlowGraph - {0}({1})'.format(self.get_option('title'), self.get_option('id'))

- self.platform.load_and_generate_flow_graph(file_path)

- 'Connection between {0}({1}) and {2}({3}) could not be made.\n\t{4}'.format(

-ID_BLACKLIST = ['self', 'options', 'gr', 'blks2', 'wxgui', 'wx', 'math', 'forms', 'firdes'] + dir(__builtin__)

- raise ValueError('Key "{0}" not found in {1}.'.format(key, _get_keys(lst)))

- template = '{0:' + fmt + '}{1}'

- raise Exception('Error separating "{0}" into key:value'.format(opt))

- raise Exception('Key "{0}" already exists in option'.format(key))

- return 'Option {0}({1})'.format(self.get_name(), self.get_key())

- raise Exception('Key "{0}" already exists in options'.format(key))

- raise Exception('Options keys "{0}" are not unique.'.format(self.get_option_keys()))

- raise Exception('Opt keys "{0}" are not identical across all options.'.format(opt_keys))

- raise Exception('The value "{0}" is not in the possible values of "{1}".'.format(self.get_value(), self.get_option_keys()))

- 'grid_pos', 'notebook', 'gui_hint',

- return 'Param - {0}({1})'.format(self.get_name(), self.get_key())

- 'grid_pos': Constants.INT_VECTOR_COLOR_SPEC,

- 'notebook': Constants.INT_VECTOR_COLOR_SPEC,

- # Hide empty grid positions

- if self.get_key() in ('grid_pos', 'notebook') and not self.get_value():

- return 'part'

- self.add_error_message('Type "{0}" is not a possible type.'.format(self.get_type()))

- raise Exception('Value "{0}" cannot be evaluated:\n{1}'.format(v, e))

- raise Exception('Expression "{0}" is invalid for type complex.'.format(str(e)))

- raise Exception('Expression "{0}" is invalid for type float.'.format(str(e)))

- raise Exception('Expression "{0}" is invalid for type integer.'.format(str(e)))

- raise Exception('Expression "{0}" is invalid for type bool.'.format(str(e)))

- raise TypeError('Type "{0}" not handled'.format(t))

- raise Exception('Value "{0}" cannot be evaluated:\n{1}'.format(v, e))

- raise Exception('Expression "{0}" is invalid for type complex vector.'.format(str(e)))

- raise Exception('Expression "{0}" is invalid for type float vector.'.format(str(e)))

- raise Exception('Expression "{0}" is invalid for type integer vector.'.format(str(e)))

- raise Exception('ID "{0}" must begin with a letter and may contain letters, numbers, and underscores.'.format(v))

- raise Exception('ID "{0}" is blacklisted.'.format(v))

- raise Exception('ID "{0}" is not unique.'.format(v))

- raise Exception('ID "{0}" does not exist.'.format(v))

- raise Exception('Stream ID "{0}" is not unique.'.format(v))

- raise Exception('Stream ID "{0}" is not found.'.format(v))

- # Grid Position Type

- #########################

- elif t == 'grid_pos':

- if not v:

- # Allow for empty grid pos

- return ''

- e = self.get_parent().get_parent().evaluate(v)

- if not isinstance(e, (list, tuple)) or len(e) != 4 or not all([isinstance(ei, int) for ei in e]):

- raise Exception('A grid position must be a list of 4 integers.')

- row, col, row_span, col_span = e

- # Check row, col

- if row < 0 or col < 0:

- raise Exception('Row and column must be non-negative.')

- # Check row span, col span

- if row_span <= 0 or col_span <= 0:

- raise Exception('Row and column span must be greater than zero.')

- # Get hostage cell parent

- try:

- my_parent = self.get_parent().get_param('notebook').evaluate()

- except:

- my_parent = ''

- # Calculate hostage cells

- for r in range(row_span):

- for c in range(col_span):

- self._hostage_cells.append((my_parent, (row+r, col+c)))

- # Avoid collisions

- params = filter(lambda p: p is not self, self.get_all_params('grid_pos'))

- for param in params:

- for parent, cell in param._hostage_cells:

- if (parent, cell) in self._hostage_cells:

- raise Exception('Another graphical element is using parent "{0}", cell "{1}".'.format(str(parent), str(cell)))

- return e

- #########################

- # Notebook Page Type

- #########################

- elif t == 'notebook':

- if not v:

- # Allow for empty notebook

- return ''

-

- # Get a list of all notebooks

- notebook_blocks = filter(lambda b: b.get_key() == 'notebook', self.get_parent().get_parent().get_enabled_blocks())

- # Check for notebook param syntax

- try:

- notebook_id, page_index = map(str.strip, v.split(','))

- except:

- raise Exception('Bad notebook page format.')

- # Check that the notebook id is valid

- try:

- notebook_block = filter(lambda b: b.get_id() == notebook_id, notebook_blocks)[0]

- except:

- raise Exception('Notebook id "{0}" is not an existing notebook id.'.format(notebook_id))

-

- # Check that page index exists

- if int(page_index) not in range(len(notebook_block.get_param('labels').evaluate())):

- raise Exception('Page index "{0}" is not a valid index number.'.format(page_index))

- return notebook_id, page_index

-

- #########################

- raise Exception('Import "{0}" failed.'.format(v))

- raise Exception('Bad import syntax: "{0}".'.format(v))

- raise TypeError('Type "{0}" not handled'.format(t))

- return 'Platform - {0}({1})'.format(self.config.key, self.config.name)

- def load_and_generate_flow_graph(self, file_path):

- Messages.send('>>> Loading: %r\n' % file_path)

- return False

- # Other, nested higiter_blocks might be auto-loaded here

- if not flow_graph.get_option('generate_options').startswith('hb'):

- Messages.send('>>> Load Error: {0}: {1}\n'.format(file_path, str(e)))

- return False

- Messages.send('>>> Generating: {0}\n'.format(file_path))

- generator = self.Generator(flow_graph, file_path)

- Messages.send('>>> Generate Error: {0}: {1}\n'.format(file_path, str(e)))

- return False

- self.load_block_xml(generator.get_file_path_xml())

- return True

- print >> sys.stderr, 'Warning: Block with key "{0}" already exists.\n\tIgnoring: {1}'.format(key, xml_file)

- print >> sys.stderr, 'Warning: Domain with emtpy key.\n\tIgnoring: {0}'.format(xml_file)

- print >> sys.stderr, 'Warning: Domain with key "{0}" already exists.\n\tIgnoring: {1}'.format(key, xml_file)

- print >> sys.stderr, 'Warning: Can\'t parse color code "{0}" for domain "{1}" '.format(color, key)

- print >> sys.stderr, 'Warning: Empty domain key(s) in connection template.\n\t{0}'.format(xml_file)

- print >> sys.stderr, 'Warning: Connection template "{0}" already exists.\n\t{1}'.format(key, xml_file)

- if n['type'] == 'msg':

- n['key'] = 'msg'

- return 'Source - {0}({1})'.format(self.get_name(), self.get_key())

- return 'Sink - {0}({1})'.format(self.get_name(), self.get_key())

- self.add_error_message('Type "{0}" is not a possible type.'.format(self.get_type()))

- self.add_error_message('Domain key "{0}" is not registered.'.format(self.get_domain()))

- # Message port logic

- if self.get_type() == 'msg':

- if self.get_nports():

- self.add_error_message('A port of type "msg" cannot have "nports" set.')

- if self.get_vlen() != 1:

- self.add_error_message('A port of type "msg" must have a "vlen" of 1.')

- COMPONENT "grc"

- COMPONENT "grc"

- code += block.get_param('notebook').get_value() # Older gui markup w/ wxgui

- except:

- pass

- try:

- return not (c.is_bus() or c.is_msg() or c.get_sink().get_parent().is_virtual_sink())

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

- 'msgs': msgs,

-##@param msgs the msg type connections

-#if $generate_options in ('wx_gui', 'qt_gui')

-## Determine the absolute icon path (wx gui only).

-#if $generate_options == 'wx_gui'

- #import gtk

- #set $icon = gtk.IconTheme().lookup_icon('gnuradio-grc', 32, 0)

-

-

-class $(class_name)(grc_wxgui.top_block_gui):

-

- def __init__($param_str):

- grc_wxgui.top_block_gui.__init__(self, title="$title")

- #if $icon

- _icon_path = "$icon.get_filename()"

- self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY))

- #end if

-#elif $generate_options == 'qt_gui'

-

- self.restoreGeometry(self.settings.value("geometry").toByteArray())

-##Create Message Queues

-########################################################

-#if $msgs

-

- $DIVIDER

- # Message Queues

- $DIVIDER

-#end if

-#for $msg in $msgs

- $(msg.get_source().get_parent().get_id())_msgq_out = $(msg.get_sink().get_parent().get_id())_msgq_in = gr.msg_queue(2)

-#end for

-########################################################

- #set $desc_args = 'usage="%prog: [options]", option_class=eng_option'

- #set $desc_args += ', description=description'

- parser = OptionParser($desc_args)

- parser.add_option(

- "$make_short_id($param)", "--$param.get_id().replace('_', '-')", dest="$param.get_id()", type="$type", default=$make_default($type, $param),

- help="Set $($param.get_param('label').get_evaluated() or $param.get_id()) [default=%default]")

- options, _ = argument_parser().parse_args()

- #if $generate_options == 'wx_gui'

- tb = top_block_cls($(', '.join($params_eq_list)))

- #if $flow_graph.get_option('max_nouts')

- tb.Run($flow_graph.get_option('run'), $flow_graph.get_option('max_nouts'))

- #else

- tb.Start($flow_graph.get_option('run'))

- #for $m in $monitors

- (tb.$m.get_id()).start()

- #end for

- tb.Wait()

- #end if

- #elif $generate_options == 'qt_gui'

- from distutils.version import StrictVersion

- if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"):

- qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting)

- COMPONENT "grc"

- raise KeyError('Cannot insert, key "{0}" already exists'.format(str(key)))

- raise KeyError('Cannot insert, key "{0}" already exists'.format(str(key)))