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 __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)
def __init__(self):
DefaultTreeModel.__init__(self, DefaultMutableTreeNode())
