Example #1
0
    def _update_tabs(self):
        # Build a { category id -> [ PreferencePane ] } map.
        categories = self.categories[:]
        category_map = dict((category.id, []) for category in categories)
        for pane in self.panes:

            # force pane to call trait_context
            # for some reason when using this PreferencesDialog
            # pane._model is None (only set when trait_context called)
            pane.trait_context()

            if pane.category in category_map:
                category_map[pane.category].append(pane)
            else:
                categories.append(PreferencesCategory(id=pane.category))
                category_map[pane.category] = [pane]

        # Construct the appropriately sorted list of preference tabs.
        tabs = []
        for category in before_after_sort(categories):
            panes = before_after_sort(category_map[category.id])
            tabs.append(PreferencesTab(name=category.name, panes=panes))
        self._tabs = tabs

        # auto select first category
        self._selected = tabs[0]
Example #2
0
    def _update_tabs(self):
        # Build a { category id -> [ PreferencePane ] } map.
        categories = self.categories[:]
        category_map = dict((category.id, []) for category in categories)
        for pane in self.panes:

            # force pane to call trait_context
            # for some reason when using this PreferencesDialog
            # pane._model is None (only set when trait_context called)
            pane.trait_context()

            if pane.category in category_map:
                category_map[pane.category].append(pane)
            else:
                categories.append(PreferencesCategory(id=pane.category))
                category_map[pane.category] = [pane]

        # Construct the appropriately sorted list of preference tabs.
        tabs = []
        for category in before_after_sort(categories):
            panes = before_after_sort(category_map[category.id])
            tabs.append(PreferencesTab(name=category.name, panes=panes))
        self._tabs = tabs

        # auto select first category
        self._selected = tabs[0]
    def _create_manager_recurse(self, schema, additions, path=''):
        """ Recursively builds the manager for with the specified additions map.
        """
        # Compute the new action path.
        if path: path += '/'
        path += schema.id

        # Determine the order of the items at this path.
        items = schema.items
        if additions[path]:
            items = before_after_sort(items + additions[path])

        # Create the actual children by calling factory items.
        children = []
        for item in items:
            # Unpack additions first, since they may themselves be schemas.
            if isinstance(item, SchemaAddition):
                item = item.factory()

            if isinstance(item, Schema):
                item = self._create_manager_recurse(item, additions, path)

            if isinstance(item, ActionManager):
                # Give even non-root action managers a reference to the
                # controller so that custom Groups, MenuManagers, etc. can get
                # access to their Tasks.
                item.controller = self.controller
            
            children.append(item)
            
        # Finally, create the pyface.action instance for this schema.
        return schema.create(children)
    def _get_ordered_schemas(self, schemas):
        begin = []
        middle = []
        end = []

        for schema in schemas:
            absolute_position = getattr(schema, "absolute_position", None)
            if absolute_position is None:
                middle.append(schema)
            elif absolute_position == "last":
                end.append(schema)
            else:
                begin.append(schema)

        schemas = before_after_sort(begin) + before_after_sort(middle) + before_after_sort(end)
        return schemas
    def _update_tabs(self):
        # Build a { category id -> [ PreferencePane ] } map.
        categories = self.categories[:]
        category_map = dict((category.id, []) for category in categories)
        for pane in self.panes:
            if pane.category in category_map:
                category_map[pane.category].append(pane)
            else:
                categories.append(PreferencesCategory(id=pane.category))
                category_map[pane.category] = [ pane ]

        # Construct the appropriately sorted list of preference tabs.
        tabs = []
        for category in before_after_sort(categories):
            panes = before_after_sort(category_map[category.id])
            tabs.append(PreferencesTab(name = category.name, panes=panes))
        self._tabs = tabs
Example #6
0
    def _update_tabs(self):
        # Build a { category id -> [ PreferencePane ] } map.
        categories = self.categories[:]
        category_map = dict((category.id, []) for category in categories)
        for pane in self.panes:
            if pane.category in category_map:
                category_map[pane.category].append(pane)
            else:
                categories.append(PreferencesCategory(id=pane.category))
                category_map[pane.category] = [ pane ]

        # Construct the appropriately sorted list of preference tabs.
        tabs = []
        for category in before_after_sort(categories):
            panes = before_after_sort(category_map[category.id])
            tabs.append(PreferencesTab(name = category.name, panes=panes))
        self._tabs = tabs
Example #7
0
    def _get_ordered_schemas(self, schemas):
        begin = []
        middle = []
        end = []

        for schema in schemas:
            absolute_position = getattr(schema, 'absolute_position', None)
            if absolute_position is None:
                middle.append(schema)
            elif absolute_position == 'last':
                end.append(schema)
            else:
                begin.append(schema)

        schemas = (before_after_sort(begin) + before_after_sort(middle) +
                   before_after_sort(end))
        return schemas
 def test_before_after_sort_2(self):
     """ Does the before-after sort work when both 'before' and 'after'
         are set?
     """
     items = [ TestItem(1), TestItem(2), TestItem(3),
               TestItem(4, after=2, before=3) ]
     actual = before_after_sort(items)
     desired = [ TestItem(1), TestItem(2), TestItem(4), TestItem(3) ]
     self.assertEquals(actual, desired)
 def test_before_after_sort_1(self):
     """ Does the before-after sort work?
     """
     items = [ TestItem(1), TestItem(2), TestItem(3, before=2),
               TestItem(4, after=1), TestItem(5) ]
     actual = before_after_sort(items)
     desired = [ TestItem(1), TestItem(3), TestItem(4),
                 TestItem(2), TestItem(5) ]
     self.assertEquals(actual, desired)
 def test_before_after_sort_2(self):
     """ Does the before-after sort work when both 'before' and 'after'
         are set?
     """
     items = [
         TestItem(1), TestItem(2), TestItem(3), TestItem(
             4, after=2, before=3)
     ]
     actual = before_after_sort(items)
     desired = [TestItem(1), TestItem(2), TestItem(4), TestItem(3)]
     self.assertEqual(actual, desired)
 def test_before_after_sort_1(self):
     """ Does the before-after sort work?
     """
     items = [
         TestItem(1), TestItem(2), TestItem(
             3, before=2), TestItem(
                 4, after=1), TestItem(5)
     ]
     actual = before_after_sort(items)
     desired = [
         TestItem(1), TestItem(3), TestItem(4), TestItem(2), TestItem(5)
     ]
     self.assertEqual(actual, desired)
 def _get_ordered_schemas(self, schemas):
     begin = []
     middle = []
     end = []
     for schema in schemas:
         absolute_position = getattr(schema, 'absolute_position', None)
         if absolute_position is None:
             middle.append(schema)
         elif absolute_position == 'last':
             end.append(schema)
         else:
             begin.append(schema)
     return before_after_sort(begin + middle + end)
Example #13
0
 def test_simple(self):
     items = before_after_sort(self.items)
     print(", ".join([i.id for i in items]))
     check_sorted(items)
Example #14
0
 def test_before_after_sort_3(self):
     """ Does the degenerate case for the before-after sort work?
     """
     actual = before_after_sort([TestItem(1)])
     desired = [TestItem(1)]
     self.assertEqual(actual, desired)
 def test_before_after_sort_3(self):
     """ Does the degenerate case for the before-after sort work?
     """
     actual = before_after_sort([ TestItem(1) ])
     desired = [ TestItem(1) ]
     self.assertEquals(actual, desired)
Example #16
0
 def test_simple(self):
     items = before_after_sort(self.items)
     print(", ".join([i.id for i in items]))
     check_sorted(items)