def refresh(self):
"""
Refresh TreeModel when the directory is updated
:return: None
"""
self._tree.setModel(DefaultTreeModel(self._add_nodes(None, self._dir)))
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 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 __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 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)
def __init__(self, view):
model = DefaultTreeModel(PathBrowserTreeItem())
self.tree = JTree(model, mousePressed=self.__mousePressed)
self.tree.cellRenderer = BrowserCellRenderer()
self.panel = JScrollPane(self.tree)
