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
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)
def test_simple(self): items = before_after_sort(self.items) print(", ".join([i.id for i in items])) check_sorted(items)
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)