[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Commit-gnuradio] [gnuradio] 101/101: Merge branch 'gtk3' into python3
|
From: |
git |
|
Subject: |
[Commit-gnuradio] [gnuradio] 101/101: Merge branch 'gtk3' into python3 |
|
Date: |
Thu, 16 Mar 2017 14:58:15 +0000 (UTC) |
This is an automated email from the git hooks/post-receive script.
jcorgan pushed a commit to branch python3
in repository gnuradio.
commit 00e775ff3e78f9e0fd216e683c958ed820363fac
Merge: 50bfc3d 69776b6
Author: Sebastian Koslowski <address@hidden>
Date: Thu Mar 9 21:23:51 2017 +0100
Merge branch 'gtk3' into python3
cmake/Modules/GrPython.cmake | 104 +-
grc/CMakeLists.txt | 94 +-
grc/blocks/dummy.xml | 11 -
grc/compiler.py | 2 +-
grc/core/Block.py | 1183 ++++++++++------------
grc/core/CMakeLists.txt | 35 -
grc/core/Config.py | 29 +-
grc/core/Connection.py | 146 +--
grc/core/Constants.py | 96 +-
grc/core/Element.py | 124 ++-
grc/core/Element.pyi | 35 +-
grc/core/FlowGraph.py | 257 ++---
grc/core/Messages.py | 7 +-
grc/core/Param.py | 425 ++------
grc/core/ParseXML.py | 67 +-
grc/core/Platform.py | 160 +--
grc/core/Port.py | 263 +++--
grc/core/generator/CMakeLists.txt | 30 -
grc/core/generator/FlowGraphProxy.py | 28 +-
grc/core/generator/Generator.py | 96 +-
grc/core/generator/__init__.py | 3 +-
grc/core/generator/flow_graph.tmpl | 32 +-
grc/core/utils/CMakeLists.txt | 25 -
grc/core/utils/__init__.py | 10 +-
grc/core/utils/{complexity.py => _complexity.py} | 15 +-
grc/core/utils/epy_block_io.py | 11 +-
grc/core/utils/expr_utils.py | 20 +-
grc/core/utils/extract_docs.py | 28 +-
grc/core/utils/odict.py | 115 ---
grc/gui/Actions.py | 215 ++--
grc/gui/{ActionHandler.py => Application.py} | 354 ++++---
grc/gui/Bars.py | 70 +-
grc/gui/Block.py | 350 -------
grc/gui/BlockTreeWindow.py | 219 ++--
grc/gui/CMakeLists.txt | 25 -
grc/gui/Colors.py | 50 -
grc/gui/Config.py | 156 ++-
grc/gui/Connection.py | 181 ----
grc/gui/Console.py | 51 +
grc/gui/Constants.py | 37 +-
grc/gui/Dialogs.py | 457 +++++----
grc/gui/DrawingArea.py | 210 ++--
grc/gui/Element.py | 278 -----
grc/gui/Executor.py | 24 +-
grc/gui/FileDialogs.py | 293 +++---
grc/gui/MainWindow.py | 301 +++---
grc/gui/Notebook.py | 158 +++
grc/gui/NotebookPage.py | 219 ----
grc/gui/Param.py | 442 --------
grc/gui/ParamWidgets.py | 325 ++++++
grc/gui/ParserErrorsDialog.py | 36 +-
grc/gui/Platform.py | 40 +-
grc/gui/Port.py | 277 -----
grc/gui/Preferences.py | 173 ----
grc/gui/PropsDialog.py | 239 +++--
grc/gui/StateCache.py | 5 +-
grc/gui/Utils.py | 134 +--
grc/gui/VariableEditor.py | 159 ++-
grc/{core/utils => gui/canvas}/__init__.py | 12 +-
grc/gui/canvas/block.py | 398 ++++++++
grc/gui/canvas/colors.py | 78 ++
grc/gui/canvas/connection.py | 251 +++++
grc/gui/canvas/drawable.py | 183 ++++
grc/gui/{FlowGraph.py => canvas/flowgraph.py} | 736 +++++++-------
grc/gui/canvas/param.py | 162 +++
grc/gui/canvas/port.py | 225 ++++
grc/gui/external_editor.py | 9 +-
grc/main.py | 49 +-
grc/scripts/gnuradio-companion | 29 +-
volk | 2 +-
70 files changed, 5399 insertions(+), 5664 deletions(-)
diff --cc cmake/Modules/GrPython.cmake
index 3f63dc1,b5cbc4c..326b207
--- a/cmake/Modules/GrPython.cmake
+++ b/cmake/Modules/GrPython.cmake
@@@ -60,25 -77,33 +60,31 @@@ set(QA_PYTHON_EXECUTABLE ${QA_PYTHON_EX
# - cmd an additional command to run
# - have the result variable to set
########################################################################
- macro(GR_PYTHON_CHECK_MODULE desc mod cmd have)
+ macro(GR_PYTHON_CHECK_MODULE_RAW desc python_code have)
execute_process(
- COMMAND ${PYTHON_EXECUTABLE} -c "
+ COMMAND ${PYTHON_EXECUTABLE} -c "${python_code}"
+ RESULT_VARIABLE return_code
+ )
+ if(return_code EQUAL 0)
+ message(STATUS "Python checking for ${desc} - found")
+ set(${have} TRUE)
+ else()
+ message(STATUS "Python checking for ${desc} - not found")
+ set(${have} FALSE)
+ endif()
+ endmacro(GR_PYTHON_CHECK_MODULE_RAW)
+
+ macro(GR_PYTHON_CHECK_MODULE desc mod cmd have)
- message(STATUS "")
- message(STATUS "Python checking for ${desc}")
+ GR_PYTHON_CHECK_MODULE_RAW(
+ "${desc}" "
#########################################
try:
import ${mod}
assert ${cmd}
-except ImportError, AssertionError: exit(-1)
+except (ImportError, AssertionError): exit(-1)
except: pass
#########################################"
- RESULT_VARIABLE ${have}
- )
- if(${have} EQUAL 0)
- message(STATUS "Python checking for ${desc} - found")
- set(${have} TRUE)
- else(${have} EQUAL 0)
- message(STATUS "Python checking for ${desc} - not found")
- set(${have} FALSE)
- endif(${have} EQUAL 0)
+ "${have}")
endmacro(GR_PYTHON_CHECK_MODULE)
########################################################################
diff --cc grc/core/Port.py
index 8549656,41388df..14dd9cd
--- a/grc/core/Port.py
+++ b/grc/core/Port.py
@@@ -17,11 -17,12 +17,13 @@@ along with this program; if not, write
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
+ from __future__ import absolute_import
+
+from itertools import chain
+
- from .Constants import DEFAULT_DOMAIN, GR_STREAM_DOMAIN, GR_MESSAGE_DOMAIN
- from .Element import Element
+ from six.moves import filter
+ from .Element import Element, lazy_property
-
from . import Constants
@@@ -41,92 -31,74 +43,92 @@@ def _sources_from_virtual_sink_port(sin
Resolve the source port that is connected to the given virtual sink port.
Use the get source from virtual source to recursively resolve subsequent
ports.
"""
- try:
- return _get_source_from_virtual_source_port(
- vsp.get_enabled_connections()[0].source_port)
- except:
- raise Exception('Could not resolve source for virtual sink port
{}'.format(vsp))
+ source_ports_per_virtual_connection = (
+ # there can be multiple ports per virtual connection
- _sources_from_virtual_source_port(c.get_source(), _traversed) #
type: list
++ _sources_from_virtual_source_port(c.source_port, _traversed) # type:
list
+ for c in sink_port.get_enabled_connections()
+ )
+ return list(chain(*source_ports_per_virtual_connection)) # concatenate
generated lists of ports
-def _get_source_from_virtual_source_port(vsp, traversed=[]):
+def _sources_from_virtual_source_port(source_port, _traversed=None):
"""
Recursively resolve source ports over the virtual connections.
Keep track of traversed sources to avoid recursive loops.
"""
- if not vsp.parent.is_virtual_source():
- return vsp
- if vsp in traversed:
- raise Exception('Loop found when resolving virtual source
{}'.format(vsp))
- try:
- return _get_source_from_virtual_source_port(
- _get_source_from_virtual_sink_port(
- list(filter( # Get all virtual sinks with a matching stream
id
- lambda vs: vs.get_param('stream_id').get_value() ==
vsp.parent.get_param('stream_id').get_value(),
- list(filter( # Get all enabled blocks that are also
virtual sinks
- lambda b: b.is_virtual_sink(),
- vsp.parent.parent.get_enabled_blocks(),
- )),
- ))[0].sinks[0]
- ), traversed + [vsp],
- )
- except:
- raise Exception('Could not resolve source for virtual source port
{}'.format(vsp))
-
-
-def _get_sink_from_virtual_source_port(vsp):
+ _traversed = set(_traversed or []) # a new set!
+ if source_port in _traversed:
+ raise LoopError('Loop found when resolving port type')
+ _traversed.add(source_port)
+
- block = source_port.get_parent()
- flow_graph = block.get_parent()
++ block = source_port.parent_block
++ flow_graph = source_port.parent_flow_graph
+
+ if not block.is_virtual_source():
+ return [source_port] # nothing to resolve, we're done
+
- stream_id = block.get_param('stream_id').get_value()
++ stream_id = block.get_parqam('stream_id').get_value()
+
+ # currently the validation does not allow multiple virtual sinks and one
virtual source
+ # but in the future it may...
+ connected_virtual_sink_blocks = (
- b for b in flow_graph.get_enabled_blocks()
++ b for b in flow_graph.iter_enabled_blocks()
+ if b.is_virtual_sink() and b.get_param('stream_id').get_value() ==
stream_id
+ )
+ source_ports_per_virtual_connection = (
- _sources_from_virtual_sink_port(b.get_sinks()[0], _traversed) #
type: list
++ _sources_from_virtual_sink_port(b.sinks[0], _traversed) # type: list
+ for b in connected_virtual_sink_blocks
+ )
+ return list(chain(*source_ports_per_virtual_connection)) # concatenate
generated lists of ports
+
+
+def _downstream_ports(port):
+ if port.is_source:
+ return _sinks_from_virtual_source_port(port)
+ else:
+ return _sinks_from_virtual_sink_port(port)
+
+
+def _sinks_from_virtual_source_port(source_port, _traversed=None):
"""
Resolve the sink port that is connected to the given virtual source port.
Use the get sink from virtual sink to recursively resolve subsequent
ports.
"""
- try:
- # Could have many connections, but use first
- return _get_sink_from_virtual_sink_port(
- vsp.get_enabled_connections()[0].sink_port)
- except:
- raise Exception('Could not resolve source for virtual source port
{}'.format(vsp))
+ sink_ports_per_virtual_connection = (
+ # there can be multiple ports per virtual connection
- _sinks_from_virtual_sink_port(c.get_sink(), _traversed) # type: list
++ _sinks_from_virtual_sink_port(c.sink_port, _traversed) # type: list
+ for c in source_port.get_enabled_connections()
+ )
+ return list(chain(*sink_ports_per_virtual_connection)) # concatenate
generated lists of ports
-def _get_sink_from_virtual_sink_port(vsp, traversed=[]):
+def _sinks_from_virtual_sink_port(sink_port, _traversed=None):
"""
Recursively resolve sink ports over the virtual connections.
Keep track of traversed sinks to avoid recursive loops.
"""
- if not vsp.parent.is_virtual_sink():
- return vsp
- if vsp in traversed:
- raise Exception('Loop found when resolving virtual sink
{}'.format(vsp))
- try:
- return _get_sink_from_virtual_sink_port(
- _get_sink_from_virtual_source_port(
- filter( # Get all virtual source with a matching stream id
- lambda vs: vs.get_param('stream_id').get_value() ==
vsp.parent.get_param('stream_id').get_value(),
- list(filter( # Get all enabled blocks that are also
virtual sinks
- lambda b: b.is_virtual_source(),
- vsp.parent.parent.get_enabled_blocks(),
- )),
- )[0].sources[0]
- ), traversed + [vsp],
- )
- except:
- raise Exception('Could not resolve source for virtual sink port
{}'.format(vsp))
+ _traversed = set(_traversed or []) # a new set!
+ if sink_port in _traversed:
+ raise LoopError('Loop found when resolving port type')
+ _traversed.add(sink_port)
+
- block = sink_port.get_parent()
- flow_graph = block.get_parent()
++ block = sink_port.parent_block
++ flow_graph = sink_port.parent_flow_graph
+
+ if not block.is_virtual_sink():
+ return [sink_port]
+
+ stream_id = block.get_param('stream_id').get_value()
+
+ connected_virtual_source_blocks = (
- b for b in flow_graph.get_enabled_blocks()
++ b for b in flow_graph.iter_enabled_blocks()
+ if b.is_virtual_source() and b.get_param('stream_id').get_value() ==
stream_id
+ )
+ sink_ports_per_virtual_connection = (
- _sinks_from_virtual_source_port(b.get_sources()[0], _traversed) #
type: list
++ _sinks_from_virtual_source_port(b.sources[0], _traversed) # type:
list
+ for b in connected_virtual_source_blocks
+ )
+ return list(chain(*sink_ports_per_virtual_connection)) # concatenate
generated lists of ports
class Port(Element):
@@@ -144,50 -117,44 +147,44 @@@
"""
self._n = n
if n['type'] == 'message':
- n['domain'] = GR_MESSAGE_DOMAIN
+ n['domain'] = Constants.GR_MESSAGE_DOMAIN
+
if 'domain' not in n:
- n['domain'] = DEFAULT_DOMAIN
- elif n['domain'] == GR_MESSAGE_DOMAIN:
+ n['domain'] = Constants.DEFAULT_DOMAIN
+ elif n['domain'] == Constants.GR_MESSAGE_DOMAIN:
n['key'] = n['name']
n['type'] = 'message' # For port color
- if not n.find('key'):
- n['key'] = str(next(block.port_counters[dir == 'source']))
# Build the port
- Element.__init__(self, block)
+ Element.__init__(self, parent)
# Grab the data
- self._name = n['name']
- self._key = n['key']
- self._type = n['type'] or ''
- self._domain = n['domain']
- self._hide = n.find('hide') or ''
- self._dir = dir
+ self.name = n['name']
+ self.key = n['key']
+ self.domain = n.get('domain')
+ self._type = n.get('type', '')
+ self.inherit_type = not self._type
+ self._hide = n.get('hide', '')
+ self._dir = direction
self._hide_evaluated = False # Updated on rewrite()
- self._nports = n.find('nports') or ''
- self._vlen = n.find('vlen') or ''
- self._optional = n.find('optional') or ''
+ self._nports = n.get('nports', '')
+ self._vlen = n.get('vlen', '')
+ self._optional = bool(n.get('optional'))
+ self._optional_evaluated = False # Updated on rewrite()
- self._clones = [] # References to cloned ports (for nports > 1)
+ self.clones = [] # References to cloned ports (for nports > 1)
def __str__(self):
if self.is_source:
- return 'Source - {}({})'.format(self.get_name(), self.get_key())
+ return 'Source - {}({})'.format(self.name, self.key)
if self.is_sink:
- return 'Sink - {}({})'.format(self.get_name(), self.get_key())
-
- def get_types(self):
- return Constants.TYPE_TO_SIZEOF.keys()
-
- def is_type_empty(self):
- return not self._n['type'] or not
self.get_parent().resolve_dependencies(self._n['type'])
+ return 'Sink - {}({})'.format(self.name, self.key)
def validate(self):
- if self.get_type() not in self.get_types():
+ Element.validate(self)
+ if self.get_type() not in Constants.TYPE_TO_SIZEOF.keys():
self.add_error_message('Type "{}" is not a possible
type.'.format(self.get_type()))
- platform = self.get_parent().get_parent().get_parent()
- if self.get_domain() not in platform.domains:
- self.add_error_message('Domain key "{}" is not
registered.'.format(self.get_domain()))
- platform = self.parent_platform
- if self.domain not in platform.domains:
++ if self.domain not in self.parent_platform.domains:
+ self.add_error_message('Domain key "{}" is not
registered.'.format(self.domain))
if not self.get_enabled_connections() and not self.get_optional():
self.add_error_message('Port is not connected.')
@@@ -195,44 -162,57 +192,44 @@@
"""
Handle the port cloning for virtual blocks.
"""
+ del self._error_messages[:]
- if self.is_type_empty():
+ if self.inherit_type:
- try:
- # Clone type and vlen
- source = self.resolve_empty_type()
- self._type = str(source.get_type())
- self._vlen = str(source.get_vlen())
- except:
- # Reset type and vlen
- self._type = ''
- self._vlen = ''
-
- Element.rewrite(self)
- hide = self.parent.resolve_dependencies(self._hide).strip().lower()
+ self.resolve_empty_type()
+
- hide =
self.get_parent().resolve_dependencies(self._hide).strip().lower()
++ hide =
self.parent_block.resolve_dependencies(self._hide).strip().lower()
self._hide_evaluated = False if hide in ('false', 'off', '0') else
bool(hide)
- optional =
self.get_parent().resolve_dependencies(self._optional).strip().lower()
++ optional =
self.parent_block.resolve_dependencies(self._optional).strip().lower()
+ self._optional_evaluated = False if optional in ('false', 'off', '0')
else bool(optional)
# Update domain if was deduced from (dynamic) port type
type_ = self.get_type()
- if self._domain == GR_STREAM_DOMAIN and type_ == "message":
- self._domain = GR_MESSAGE_DOMAIN
- self._key = self._name
- if self._domain == GR_MESSAGE_DOMAIN and type_ != "message":
- self._domain = GR_STREAM_DOMAIN
- self._key = '0' # Is rectified in rewrite()
+ if self.domain == Constants.GR_STREAM_DOMAIN and type_ == "message":
+ self.domain = Constants.GR_MESSAGE_DOMAIN
+ self.key = self.name
+ if self.domain == Constants.GR_MESSAGE_DOMAIN and type_ != "message":
+ self.domain = Constants.GR_STREAM_DOMAIN
+ self.key = '0' # Is rectified in rewrite()
def resolve_virtual_source(self):
- if self.parent.is_virtual_sink():
- return _get_source_from_virtual_sink_port(self)
- if self.parent.is_virtual_source():
- return _get_source_from_virtual_source_port(self)
+ """Only used by Generator after validation is passed"""
+ return _upstream_ports(self)
def resolve_empty_type(self):
- if self.is_sink:
+ def find_port(finder):
try:
- return next((p for p in finder(self) if not
p.is_type_empty()), None)
- src = _get_source_from_virtual_sink_port(self)
- if not src.inherit_type:
- return src
- except:
++ return next((p for p in finder(self) if not p.inherit_type),
None)
+ except LoopError as error:
+ self.add_error_message(str(error))
+ except (StopIteration, Exception) as error:
pass
- sink = _get_sink_from_virtual_sink_port(self)
- if not sink.inherit_type:
- return sink
- if self.is_source:
- try:
- src = _get_source_from_virtual_source_port(self)
- if not src.inherit_type:
- return src
- except:
- pass
- sink = _get_sink_from_virtual_source_port(self)
- if not sink.inherit_type:
- return sink
+
+ try:
+ port = find_port(_upstream_ports) or find_port(_downstream_ports)
+ self._type = str(port.get_type())
+ self._vlen = str(port.get_vlen())
+ except Exception:
+ # Reset type and vlen
+ self._type = self._vlen = ''
def get_vlen(self):
"""
@@@ -242,9 -222,9 +239,9 @@@
Returns:
the vector length or 1
"""
- vlen = self.get_parent().resolve_dependencies(self._vlen)
- vlen = self.parent.resolve_dependencies(self._vlen)
++ vlen = self.parent_block.resolve_dependencies(self._vlen)
try:
- return int(self.get_parent().get_parent().evaluate(vlen))
+ return max(1, int(self.parent_flowgraph.evaluate(vlen)))
except:
return 1
@@@ -258,52 -238,17 +255,17 @@@
the number of ports or 1
"""
if self._nports == '':
- return ''
+ return 1
- nports = self.get_parent().resolve_dependencies(self._nports)
- nports = self.parent.resolve_dependencies(self._nports)
++ nports = self.parent_block.resolve_dependencies(self._nports)
try:
- return max(1,
int(self.get_parent().get_parent().evaluate(nports)))
+ return max(1, int(self.parent_flowgraph.evaluate(nports)))
except:
return 1
def get_optional(self):
- return bool(self._optional)
+ return self._optional_evaluated
- def get_color(self):
- """
- Get the color that represents this port's type.
- Codes differ for ports where the vec length is 1 or greater than 1.
-
- Returns:
- a hex color code.
- """
- try:
- color = Constants.TYPE_TO_COLOR[self.get_type()]
- vlen = self.get_vlen()
- if vlen == 1:
- return color
- color_val = int(color[1:], 16)
- r = (color_val >> 16) & 0xff
- g = (color_val >> 8) & 0xff
- b = (color_val >> 0) & 0xff
- dark = (0, 0, 30, 50, 70)[min(4, vlen)]
- r = max(r-dark, 0)
- g = max(g-dark, 0)
- b = max(b-dark, 0)
- # TODO: Change this to .format()
- return '#%.2x%.2x%.2x' % (r, g, b)
- except:
- return '#FFFFFF'
-
- def get_clones(self):
- """
- Get the clones of this master port (nports > 1)
-
- Returns:
- a list of ports
- """
- return self._clones
-
def add_clone(self):
"""
Create a clone of this (master) port and store a reference in
self._clones.
@@@ -398,17 -329,47 +346,46 @@@
def get_associated_ports(self):
if not self.get_type() == 'bus':
return [self]
+
+ block = self.parent_block
+ if self.is_source:
+ block_ports = block.sources
+ bus_structure = block.current_bus_structure['source']
else:
- if self.is_source:
- get_ports = self.get_parent().get_sources
- bus_structure =
self.get_parent().current_bus_structure['source']
- else:
- get_ports = self.get_parent().get_sinks
- bus_structure =
self.get_parent().current_bus_structure['sink']
-
- ports = [i for i in get_ports() if not i.get_type() == 'bus']
- if bus_structure:
- busses = [i for i in get_ports() if i.get_type() == 'bus']
- bus_index = busses.index(self)
- ports = filter(lambda a: ports.index(a) in
bus_structure[bus_index], ports)
- return ports
+ block_ports = block.sinks
+ bus_structure = block.current_bus_structure['sink']
+
+ ports = [i for i in block_ports if not i.get_type() == 'bus']
+ if bus_structure:
+ bus_index = [i for i in block_ports if i.get_type() ==
'bus'].index(self)
+ ports = [p for i, p in enumerate(ports) if i in
bus_structure[bus_index]]
+ return ports
+
+
+ class PortClone(Port):
+
+ is_clone = True
+
+ def __init__(self, parent, direction, master, name, key):
+ """
+ Make a new port from nested data.
+
+ Args:
+ block: the parent element
+ n: the nested odict
+ dir: the direction
+ """
+ Element.__init__(self, parent)
+ self.master = master
+ self.name = name
+ self._key = key
+ self._nports = '1'
+
+ def __getattr__(self, item):
+ return getattr(self.master, item)
+
+ def add_clone(self):
+ raise NotImplementedError()
+
+ def remove_clone(self, port):
+ raise NotImplementedError()
-
diff --cc grc/core/generator/Generator.py
index bff70df,7f0caea..2d296cb
--- a/grc/core/generator/Generator.py
+++ b/grc/core/generator/Generator.py
@@@ -159,18 -162,18 +162,18 @@@ class TopBlockGenerator(object)
src = block.get_param('source_code').get_value()
output.append((file_path, src))
- # Filter out virtual sink connections
- def cf(c):
- return not (c.is_bus() or
c.get_sink().get_parent().is_virtual_sink())
- connections = filter(cf, fg.get_enabled_connections())
+ # Filter out bus and virtual sink connections
+ connections = [con for con in fg.get_enabled_connections()
+ if not (con.is_bus() or
con.sink_block.is_virtual_sink())]
# Get the virtual blocks and resolve their connections
- virtual = filter(lambda c:
c.get_source().get_parent().is_virtual_source(), connections)
+ connection_factory = fg.parent_platform.Connection
+ virtual = [c for c in connections if
c.source_block.is_virtual_source()]
for connection in virtual:
- sink = connection.get_sink()
- for source in connection.get_source().resolve_virtual_source():
- resolved = fg.get_parent().Connection(flow_graph=fg,
porta=source, portb=sink)
- source = connection.source_port.resolve_virtual_source()
+ sink = connection.sink_port
- resolved = connection_factory(fg.orignal_flowgraph, source, sink)
- connections.append(resolved)
++ for source in connection.source_port.resolve_virtual_source():
++ resolved = connection_factory(fg.orignal_flowgraph, source,
sink)
+ connections.append(resolved)
# Remove the virtual connection
connections.remove(connection)
diff --cc grc/gui/external_editor.py
index 010bd71,11d6fd7..155b091
--- a/grc/gui/external_editor.py
+++ b/grc/gui/external_editor.py
@@@ -67,19 -73,17 +69,16 @@@ class ExternalEditor(threading.Thread)
time.sleep(1)
except Exception as e:
- print >> sys.stderr, "file monitor crashed:", str(e)
+ print("file monitor crashed:", str(e), file=sys.stderr)
- else:
- # print "file monitor: done with", filename
- pass
+ finally:
+ try:
+ os.remove(self.filename)
+ except OSError:
+ pass
if __name__ == '__main__':
-- def p(data):
- print data
- print(data)
--
-- e = ExternalEditor('/usr/bin/gedit', "test", "content", p)
++ e = ExternalEditor('/usr/bin/gedit', "test", "content", print)
e.open_editor()
e.start()
time.sleep(15)
- [Commit-gnuradio] [gnuradio] 72/101: Merge remote-tracking branch 'upstream/next' into gtk3, (continued)
- [Commit-gnuradio] [gnuradio] 72/101: Merge remote-tracking branch 'upstream/next' into gtk3, git, 2017/03/16
- [Commit-gnuradio] [gnuradio] 71/101: grc: gtk3: fixup dialogs, git, 2017/03/16
- [Commit-gnuradio] [gnuradio] 78/101: Merge remote-tracking branch 'upstream/next' into gtk3, git, 2017/03/16
- [Commit-gnuradio] [gnuradio] 79/101: grc: refactor: move drawables in subpackage, git, 2017/03/16
- [Commit-gnuradio] [gnuradio] 95/101: grc: gtk3: curved connections, git, 2017/03/16
- [Commit-gnuradio] [gnuradio] 82/101: grc: gtk3: Converted to Gtk.Application (ActionHandler) and Gtk.ApplicationWindow (MainWindow), git, 2017/03/16
- [Commit-gnuradio] [gnuradio] 96/101: grc: gtk3: invalid connection all red, git, 2017/03/16
- [Commit-gnuradio] [gnuradio] 90/101: Merge remote-tracking branch 'upstream/next' into gtk3, git, 2017/03/16
- [Commit-gnuradio] [gnuradio] 97/101: grc: gtk3: drag to connect, git, 2017/03/16
- [Commit-gnuradio] [gnuradio] 84/101: grc: refactor: Moved preferences to Config.py, git, 2017/03/16
- [Commit-gnuradio] [gnuradio] 101/101: Merge branch 'gtk3' into python3,
git <=
- [Commit-gnuradio] [gnuradio] 47/101: grc: refactor: Port, Param, Options init clean-up, git, 2017/03/16
- [Commit-gnuradio] [gnuradio] 89/101: Merge remote-tracking branch 'upstream/next' into gtk3, git, 2017/03/16