def __init__(self, channels, item_model): print "ChannelTree __init__" self.item_model = item_model root = DefaultMutableTreeNode("Root") tree_model = DefaultTreeModel(root) idx = 0 print "channels", channels for channel in channels: node = ChannelTreeNode(channel) tree_model.insertNodeInto(node, root, idx) idx = idx + 1 JTree.__init__(self, tree_model)
def makeTree(self): #----------------------------------------------------------------------- # First, build the hierarchy of Tree nodes #----------------------------------------------------------------------- root = DefaultMutableTreeNode('Root Node') for name in 'Parent 1,Parent 2'.split(','): here = DefaultMutableTreeNode(name) for child in 'Child 1,Child 2'.split(','): here.add(DefaultMutableTreeNode(child)) root.add(here) #----------------------------------------------------------------------- # Next, use the hierarchy to create a Tree Model, with a listener #----------------------------------------------------------------------- model = DefaultTreeModel(root, treeModelListener=myTreeModelListener()) #----------------------------------------------------------------------- # Then, build our editable JTree() using this model #----------------------------------------------------------------------- tree = JTree(model, editable=1, showsRootHandles=1, valueChanged=self.select) #----------------------------------------------------------------------- # Only allow one node to be selectable at a time #----------------------------------------------------------------------- tree.getSelectionModel().setSelectionMode( TreeSelectionModel.SINGLE_TREE_SELECTION) return tree
def refresh(self): """ Refresh TreeModel when the directory is updated :return: None """ self._tree.setModel(DefaultTreeModel(self._add_nodes(None, self._dir)))
def createUpdatedModel(self): """When the user does any changes in the tree, the underlaying kconfig structure will change. Nodes may change visibility and value. The tree control cannot hide nodes, so a new datamodel must be generated that does not include invisible nodes.""" shadowTreeRoot = self.shadowModel.getRoot() rootNode = DefaultMutableTreeNode("Root") self.addVisibleNodes(rootNode, shadowTreeRoot) return DefaultTreeModel(rootNode)
def createNewModel(): root = DefaultMutableTreeNode("Root") vegetableNode = DefaultMutableTreeNode("Vegetables") vegetableNode.add(DefaultMutableTreeNode("Capsicum")) vegetableNode.add(DefaultMutableTreeNode("Carrot")) vegetableNode.add(DefaultMutableTreeNode("Tomato")) fruitNode = DefaultMutableTreeNode("Fruits") fruitNode.add(DefaultMutableTreeNode("Grapes")) fruitNode.add(DefaultMutableTreeNode("Orange")) color = DefaultMutableTreeNode("Colors") color.add(DefaultMutableTreeNode("Orange")) color.add(DefaultMutableTreeNode("Red")) fruitNode.add(color) root.add(vegetableNode) root.add(fruitNode) #printNode(root) model = DefaultTreeModel(root) return model
def createTreeModel(mapContext, reducedTree=True): i18n = ToolsLocator.getI18nManager() root = DefaultMutableTreeNode(i18n.getTranslation("_Root")) localLayers = DefaultMutableTreeNode(DataFolder(i18n.getTranslation("_Local_layers"),None)) remoteLayers = DefaultMutableTreeNode(DataFolder(i18n.getTranslation("_Remote_layers"),None)) root.insert(localLayers, root.getChildCount()) root.insert(remoteLayers, root.getChildCount()) layers = list() remotes = list() for layer in iter(mapContext.deepiterator()): getDataStore = getattr(layer,"getDataStore",None) if getDataStore == None: continue if getDataStore() == None: # asumimos que es raster uri = layer.getURI() if uri != None: layers.append((uri.getPath(),layer)) else: remotes.append((layer.getName(), layer)) continue params = getDataStore().getParameters() getFile = getattr(params, "getFile", None) if getFile != None and getFile() !=None: getTable = getattr(params, "getTable", None) if getTable != None and getTable() !=None: layers.append((os.path.join(getFile().getAbsolutePath(),getTable()),layer)) else: layers.append((getFile().getAbsolutePath(),layer)) else: remotes.append((layer.getName(), layer)) layers.sort(cmp = lambda x,y: cmp(x[0],y[0])) if reducedTree: buildReducedTreeFromLayers(localLayers,layers) buildReducedTreeFromLayers(remoteLayers,remotes) else: for path,layer in layers: buildTreeFromPath(localLayers,path,layer) model = DefaultTreeModel(root) return model
def createTreeModel(mapContext, reducedTree=True): i18n = ToolsLocator.getI18nManager() root = DefaultMutableTreeNode(i18n.getTranslation("_Visibility")) rootWithVisibility = DefaultMutableTreeNode( DataGroup(i18n.getTranslation("_Visible"))) rootWithoutVisibility = DefaultMutableTreeNode( DataGroup(i18n.getTranslation("_Out_of_Scale_Range"))) rootNotVisibility = DefaultMutableTreeNode( DataGroup(i18n.getTranslation("_Not_Visible"))) root.insert(rootWithVisibility, root.getChildCount()) root.insert(rootWithoutVisibility, root.getChildCount()) root.insert(rootNotVisibility, root.getChildCount()) for layer in iter(mapContext.deepiterator()): if not isinstance(layer, SingleLayer): continue try: envelope = layer.getFullEnvelope() insideViewportEnvelope = mapContext.getViewPort().getEnvelope( ).intersects(envelope) except: insideViewportEnvelope = True if layer.isWithinScale(mapContext.getScaleView()) and layer.isVisible( ) and insideViewportEnvelope: newNode = DefaultMutableTreeNode(DataLayer(layer.getName(), layer)) rootWithVisibility.insert(newNode, 0) elif not layer.isWithinScale( mapContext.getScaleView()) and layer.isVisible(): newNode = DefaultMutableTreeNode(DataLayer(layer.getName(), layer)) rootWithoutVisibility.insert(newNode, 0) else: # layer.isVisible()==False: newNode = DefaultMutableTreeNode(DataLayer(layer.getName(), layer)) rootNotVisibility.insert(newNode, 0) model = DefaultTreeModel(root) return model
def createTreeModel(mapContext, reducedTree=True): i18n = ToolsLocator.getI18nManager() root = DefaultMutableTreeNode(i18n.getTranslation("_Selection")) rootSelected = DefaultMutableTreeNode( DataGroup(i18n.getTranslation("_Selected"))) rootSelectable = DefaultMutableTreeNode( DataGroup(i18n.getTranslation("_Selectable"))) rootNotSelectable = DefaultMutableTreeNode( DataGroup(i18n.getTranslation("_Not_selectable"))) root.insert(rootSelected, root.getChildCount()) root.insert(rootSelectable, root.getChildCount()) root.insert(rootNotSelectable, root.getChildCount()) for layer in iter(mapContext.deepiterator()): if not isinstance(layer, SingleLayer): continue store = layer.getDataStore() if isinstance( store, DefaultFeatureStore) and store.getSelection().getSize() != 0: newNode = DefaultMutableTreeNode(DataLayer(layer.getName(), layer)) fset = layer.getDataStore().getSelection() for f in fset: newFeature = DefaultMutableTreeNode( FeatureDataLayerNode(layer.getName(), layer, f)) newNode.insert(newFeature, newNode.getChildCount()) rootSelected.insert(newNode, 0) elif isinstance(store, DefaultFeatureStore): newNode = DefaultMutableTreeNode(DataLayer(layer.getName(), layer)) rootSelectable.insert(newNode, 0) else: newNode = DefaultMutableTreeNode(DataLayer(layer.getName(), layer)) rootNotSelectable.insert(newNode, 0) model = DefaultTreeModel(root) return model
def createKconfShadowModel(self, kconf): """Create the one and only shadow data model""" rootNode = DefaultMutableTreeNode(kconf.mainmenu_text) self.addNodes(rootNode, kconf.top_node.list) self.shadowModel = DefaultTreeModel(rootNode)
class KConfigTree(JTree, CellEditorListener): """Custom Swing JTree based tree that visualizes a KConfig configuration. The full KConfig menu structure is put into a shadow tree model. From the shadow model, a real model is built (updateModel), where hidden nodes are not included. This update model is what the tree uses to visualize the configuration menu. Both the shadow and the updated model has the same TreeNodeData with KConfig data. The expanded state and search result state is kept in the TreeNodeData. """ shadowModel = None isUpdating = False showAll = False isSearching = False def __init__(self, kconf): self.setCellRenderer(CustomCellRenderer()) self.setCellEditor(CustomCellEditor(self)) self.createKconfShadowModel(kconf) self.setModel(self.createUpdatedModel()) self.expandRow(0) self.setEditable(True) self.setRootVisible(False) self.setShowsRootHandles(True) self.setRowHeight(0) self.addTreeExpansionListener(KConfigTreeExpansionListener()) self.getCellEditor().addCellEditorListener(self) def editingCanceled(self, event): """From CellEditorListener """ # log.info("editingCanceled", self.cellEditor.getCellEditorValue()) pass def editingStopped(self, event): """From CellEditorListener.""" # log.info("editingStopped", self.cellEditor.getCellEditorValue()) self.stopEditing() def createKconfShadowModel(self, kconf): """Create the one and only shadow data model""" rootNode = DefaultMutableTreeNode(kconf.mainmenu_text) self.addNodes(rootNode, kconf.top_node.list) self.shadowModel = DefaultTreeModel(rootNode) def addNodes(self, parent, node): """Recursively traverse the KConfig structure and add to the shadow model""" while node: newUiNode = DefaultMutableTreeNode(TreeNodeData(node, self)) parent.add(newUiNode) if node.list: self.addNodes(newUiNode, node.list) node = node.next def createUpdatedModel(self): """When the user does any changes in the tree, the underlaying kconfig structure will change. Nodes may change visibility and value. The tree control cannot hide nodes, so a new datamodel must be generated that does not include invisible nodes.""" shadowTreeRoot = self.shadowModel.getRoot() rootNode = DefaultMutableTreeNode("Root") self.addVisibleNodes(rootNode, shadowTreeRoot) return DefaultTreeModel(rootNode) def addVisibleNodes(self, visibleParent, shadowParent): """Adds visible nodes from the shadow tree model to the update tree model. If there is an active search operation, only search matches will be added. If showAll is set, all nodes are added regardless of visibility.""" childrenEnum = shadowParent.children() while childrenEnum.hasMoreElements(): shadowChild = childrenEnum.nextElement() if shadowChild.getUserObject().getVisible() > 0 or self.showAll: if not self.isSearching or shadowChild.getUserObject( ).isSearchMatch(): visibleChild = DefaultMutableTreeNode( shadowChild.getUserObject()) visibleParent.add(visibleChild) if shadowChild.getChildCount() > 0: self.addVisibleNodes(visibleChild, shadowChild) def isPathEditable(self, path): comp = path.getLastPathComponent() if isinstance(comp, DefaultMutableTreeNode): nodeData = comp.getUserObject() if isinstance(nodeData, TreeNodeData): return True return False def updateTree(self): """Call to create a new updated tree model""" if not self.isUpdating: # log.info("updateTree()") self.isUpdating = True self.setModel(self.createUpdatedModel()) self.updateExpandedState(self.getModel().getRoot()) self.isUpdating = False def updateExpandedState(self, parent): """Scan through the whole tree and expand the tree node if the node data has the expanded field set to True.""" childrenEnum = parent.children() while childrenEnum.hasMoreElements(): child = childrenEnum.nextElement() if child.getUserObject().isExpanded(): self.expandPath(TreePath(child.getPath())) if child.getChildCount() > 0: self.updateExpandedState(child) def setShowAll(self, show): self.showAll = show self.updateTree() def doSearch(self, searchText): """Perform a search in the data model with the supplied text.""" if len(searchText) > 0: self.isSearching = True self.doSearchBranch(self.shadowModel.getRoot(), searchText) else: self.isSearching = False self.updateTree() def doSearchBranch(self, shadowParent, searchText): """Traverse the tree model searching for the search text""" match = False childrenEnum = shadowParent.children() while childrenEnum.hasMoreElements(): shadowChild = childrenEnum.nextElement() if shadowChild.getUserObject().search(searchText, self.showAll): match = True if shadowChild.getChildCount() > 0: if self.doSearchBranch(shadowChild, searchText): shadowChild.getUserObject().setSearchMatch(True) match = True return match
def __init__(self): DefaultTreeModel.__init__(self, DefaultMutableTreeNode())
def __init__(self, view): model = DefaultTreeModel(PathBrowserTreeItem()) self.tree = JTree(model, mousePressed=self.__mousePressed) self.tree.cellRenderer = BrowserCellRenderer() self.panel = JScrollPane(self.tree)