1 files changed, 45 insertions, 39 deletions
diff --git a/grc/core/Platform.py b/grc/core/Platform.py
index 9b25e67d65..be7b60ca59 100644
--- a/grc/core/Platform.py
+++ b/grc/core/Platform.py
@@ -17,9 +17,14 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 """
 
+from __future__ import absolute_import, print_function
+
 import os
 import sys
 
+import six
+from six.moves import range
+
 from . import ParseXML, Messages, Constants
 
 from .Config import Config
@@ -31,7 +36,7 @@ from .Block import Block
 from .Port import Port
 from .Param import Param
 
-from .utils import odict, extract_docs
+from .utils import extract_docs
 
 
 class Platform(Element):
@@ -48,10 +53,9 @@ class Platform(Element):
 
     def __init__(self, *args, **kwargs):
         """ Make a platform for GNU Radio """
-        Element.__init__(self)
+        Element.__init__(self, parent=None)
 
         self.config = self.Config(*args, **kwargs)
-
         self.block_docstrings = {}
         self.block_docstrings_loaded_callback = lambda: None  # dummy to be replaced by BlockTreeWindow
 
@@ -63,18 +67,19 @@ class Platform(Element):
         self._block_dtd = Constants.BLOCK_DTD
         self._default_flow_graph = Constants.DEFAULT_FLOW_GRAPH
 
-        # Create a dummy flow graph for the blocks
-        self._flow_graph = Element(self)
-        self._flow_graph.connections = []
-
-        self.blocks = odict()
-        self._blocks_n = odict()
+        self.blocks = {}
+        self._blocks_n = {}
         self._block_categories = {}
         self.domains = {}
         self.connection_templates = {}
 
         self._auto_hier_block_generate_chain = set()
 
+        # Create a dummy flow graph for the blocks
+        self._flow_graph = Element.__new__(FlowGraph)
+        Element.__init__(self._flow_graph, self)
+        self._flow_graph.connections = []
+
         self.build_block_library()
 
     def __str__(self):
@@ -130,12 +135,13 @@ class Platform(Element):
             Messages.send('>>> Generate Error: {}: {}\n'.format(file_path, str(e)))
             return False
 
-        self.load_block_xml(generator.get_file_path_xml())
+        self.load_block_xml(generator.file_path_xml)
         return True
 
     def build_block_library(self):
         """load the blocks and block tree from the search paths"""
         self._docstring_extractor.start()
+
         # Reset
         self.blocks.clear()
         self._blocks_n.clear()
@@ -157,10 +163,10 @@ class Platform(Element):
                 # print >> sys.stderr, 'Warning: Block validation failed:\n\t%s\n\tIgnoring: %s' % (e, xml_file)
                 pass
             except Exception as e:
-                print >> sys.stderr, 'Warning: XML parsing failed:\n\t%r\n\tIgnoring: %s' % (e, xml_file)
+                print('Warning: XML parsing failed:\n\t%r\n\tIgnoring: %s' % (e, xml_file), file=sys.stderr)
 
         # Add blocks to block tree
-        for key, block in self.blocks.iteritems():
+        for key, block in six.iteritems(self.blocks):
             category = self._block_categories.get(key, block.category)
             # Blocks with empty categories are hidden
             if not category:
@@ -182,20 +188,20 @@ class Platform(Element):
                 yield block_path
             elif os.path.isdir(block_path):
                 for dirpath, dirnames, filenames in os.walk(block_path):
-                    for filename in sorted(filter(lambda f: f.endswith('.xml'), filenames)):
+                    for filename in sorted(f for f in filenames if f.endswith('.xml')):
                         yield os.path.join(dirpath, filename)
 
     def load_block_xml(self, xml_file):
         """Load block description from xml file"""
         # Validate and import
         ParseXML.validate_dtd(xml_file, self._block_dtd)
-        n = ParseXML.from_file(xml_file).find('block')
+        n = ParseXML.from_file(xml_file).get('block', {})
         n['block_wrapper_path'] = xml_file  # inject block wrapper path
         # Get block instance and add it to the list of blocks
         block = self.Block(self._flow_graph, n)
         key = block.get_key()
         if key in self.blocks:
-            print >> sys.stderr, 'Warning: Block with key "{}" already exists.\n\tIgnoring: {}'.format(key, xml_file)
+            print('Warning: Block with key "{}" already exists.\n\tIgnoring: {}'.format(key, xml_file), file=sys.stderr)
         else:  # Store the block
             self.blocks[key] = block
             self._blocks_n[key] = n
@@ -213,62 +219,62 @@ class Platform(Element):
         path = []
 
         def load_category(cat_n):
-            path.append(cat_n.find('name').strip())
-            for block_key in cat_n.findall('block'):
+            path.append(cat_n.get('name').strip())
+            for block_key in cat_n.get('block', []):
                 if block_key not in self._block_categories:
                     self._block_categories[block_key] = list(path)
-            for sub_cat_n in cat_n.findall('cat'):
+            for sub_cat_n in cat_n.get('cat', []):
                 load_category(sub_cat_n)
             path.pop()
 
-        load_category(xml.find('cat'))
+        load_category(xml.get('cat', {}))
 
     def load_domain_xml(self, xml_file):
         """Load a domain properties and connection templates from XML"""
         ParseXML.validate_dtd(xml_file, Constants.DOMAIN_DTD)
-        n = ParseXML.from_file(xml_file).find('domain')
+        n = ParseXML.from_file(xml_file).get('domain')
 
-        key = n.find('key')
+        key = n.get('key')
         if not key:
-            print >> sys.stderr, 'Warning: Domain with emtpy key.\n\tIgnoring: {}'.format(xml_file)
+            print('Warning: Domain with emtpy key.\n\tIgnoring: {}'.format(xml_file), file=sys.stderr)
             return
         if key in self.domains:  # test against repeated keys
-            print >> sys.stderr, 'Warning: Domain with key "{}" already exists.\n\tIgnoring: {}'.format(key, xml_file)
+            print('Warning: Domain with key "{}" already exists.\n\tIgnoring: {}'.format(key, xml_file), file=sys.stderr)
             return
 
-        #to_bool = lambda s, d: d if s is None else s.lower() not in ('false', 'off', '0', '')
+        # to_bool = lambda s, d: d if s is None else s.lower() not in ('false', 'off', '0', '')
         def to_bool(s, d):
             if s is not None:
                 return s.lower() not in ('false', 'off', '0', '')
             return d
 
-        color = n.find('color') or ''
+        color = n.get('color') or ''
         try:
-            import gtk  # ugly but handy
-            gtk.gdk.color_parse(color)
-        except (ValueError, ImportError):
+            chars_per_color = 2 if len(color) > 4 else 1
+            tuple(int(color[o:o + 2], 16) / 255.0 for o in range(1, 3 * chars_per_color, chars_per_color))
+        except ValueError:
             if color:  # no color is okay, default set in GUI
-                print >> sys.stderr, 'Warning: Can\'t parse color code "{}" for domain "{}" '.format(color, key)
+                print('Warning: Can\'t parse color code "{}" for domain "{}" '.format(color, key), file=sys.stderr)
                 color = None
 
         self.domains[key] = dict(
-            name=n.find('name') or key,
-            multiple_sinks=to_bool(n.find('multiple_sinks'), True),
-            multiple_sources=to_bool(n.find('multiple_sources'), False),
+            name=n.get('name') or key,
+            multiple_sinks=to_bool(n.get('multiple_sinks'), True),
+            multiple_sources=to_bool(n.get('multiple_sources'), False),
             color=color
         )
-        for connection_n in n.findall('connection'):
-            key = (connection_n.find('source_domain'), connection_n.find('sink_domain'))
+        for connection_n in n.get('connection', []):
+            key = (connection_n.get('source_domain'), connection_n.get('sink_domain'))
             if not all(key):
-                print >> sys.stderr, 'Warning: Empty domain key(s) in connection template.\n\t{}'.format(xml_file)
+                print('Warning: Empty domain key(s) in connection template.\n\t{}'.format(xml_file), file=sys.stderr)
             elif key in self.connection_templates:
-                print >> sys.stderr, 'Warning: Connection template "{}" already exists.\n\t{}'.format(key, xml_file)
+                print('Warning: Connection template "{}" already exists.\n\t{}'.format(key, xml_file), file=sys.stderr)
             else:
-                self.connection_templates[key] = connection_n.find('make') or ''
+                self.connection_templates[key] = connection_n.get('make') or ''
 
     def _save_docstring_extraction_result(self, key, docstrings):
         docs = {}
-        for match, docstring in docstrings.iteritems():
+        for match, docstring in six.iteritems(docstrings):
             if not docstring or match.endswith('_sptr'):
                 continue
             docstring = docstring.replace('\n\n', '\n').strip()
@@ -300,7 +306,7 @@ class Platform(Element):
         return self.FlowGraph(platform=self)
 
     def get_blocks(self):
-        return self.blocks.values()
+        return list(self.blocks.values())
 
     def get_new_block(self, flow_graph, key):
         return self.Block(flow_graph, n=self._blocks_n[key])