Drop on tree node

hi
i want to enable drag 'n' drop for a tree. it works mostly as expected, but it it is not possible to drop a node on another node which has no children. to make this possible, i had to set has_children to true for every node, even if the node has no children. this makes the expander showing up, which is quiet ugly.
is there another way to drop on a node without any children (like in sapgui tree)?
thx

hi,
If you described situation is right, i do think that you can modify the Context Node of Tree dynamically.
How to do it?
You know, the tree node has one property named "has children". So, i think you can add one attribute to your context node, and bind it with this property.
Then, you can use your Drag&Drop event, in which you can get so many parameters,such as 'ID','INDEX','Offset' ,etc. And i think you can make use of these parameters to get the the context element if necessary.
Then, you can set the context attribute of your drop-target tree node's element dynamically.
At the same time, i think you need clear the Drag-source tree node's "Has children" attribute if necessary.
I don't know whether it can work fine, i just wrote what i thought out about your post.You can check, hope it can help you a little a little.
Best wishes.

Similar Messages

Drag and drop of multiple nodes between 2 trees

Hi,
I am trying to implement a drag and drop of multiple nodes between two different trees. A simple drag drop written on the lines of the demo code RSDEMO_DRAG_DROP_TREE_MULTI works perfectly fine. But my requirement is, when a child (leaf) node is dragged, if its parent is not present in the target tree, that too has to be dragged and dropped from left to right. When I try to manually add nodes to the target tree, it dumps because the node key table and drag drop object have fewer nodes than what I am trying to add. So it always dumps in the drag_drop_complete method.
I have also tried putting this code in the PBO of my screen, calling a subroutine to refresh my tree with all nodes required. But I realise that the PBO does not get called after a drag drop. Is there a way to achieve this? Any help would be greatly appreciated. Thank you.
Regards,
Nithya

There's a Multi-Select TreeView sample on the WindowsClient.com, you can download it. Then you can drag multi nodes as follows:
Code Snippet
private void Form2_Load(object sender, EventArgs e)
            this.listBox1.AllowDrop = true;
            this.listBox1.DragOver += new DragEventHandler(listBox1_DragOver);
            this.listBox1.DragDrop += new DragEventHandler(listBox1_DragDrop);
            this.multiSelectTreeView1.ItemDrag += new
                 ItemDragEventHandler(multiSelectTreeView1_ItemDrag);
        void multiSelectTreeView1_ItemDrag(object sender, ItemDragEventArgs e)
            this.multiSelectTreeView1.DoDragDrop(this.multiSelectTreeView1.SelectedNodes,
                 DragDropEffects.Move);
        void listBox1_DragDrop(object sender, DragEventArgs e)
            ArrayList selectNodes = e.Data.GetData(
                e.Data.GetFormats()[0]) as ArrayList;
            foreach (TreeNode node in selectNodes)
                this.listBox1.Items.Add(node.Text);
        void listBox1_DragOver(object sender, DragEventArgs e)
             e.Effect = DragDropEffects.Move;

Tree node to respond to the drag and drop...

I have to be able to drag a file into a tree node to drop.
When I drop at the tree node, the file should be shown at the right side of panel. Just like MS Window Explorer.
Drag and drop at the table to table is working but not drag into the tree and automatically moves into the tree... is...
Any idea would be welcomded.

You'll need to setDragEnabled and write a TransferHandler for the JTree. See Introduction to Drag and Drop and Data Transfer.

Drop on a Tree Node - Help!

On a drop on a tree node, I'd like to get the item that is
being dropped on.
Tree object being dropped on: event.currentTarget
Index of node in tree being dropped on:
event.currentTarget..calculateDropIndex(event); where event is the
DragEvent
dropTarget is a great name for a method that would do this,
but it returns a display object.
Some ideas:
1. Use the index to somehow go through the XML data provider.
I don't think this is the right way - the XML structure is not list
based.
2. The Tree creates a list from the XML. How can I leverage
that and get the item for a given node index? dropTarget seems like
the right term, but it returns a display object.
3. tree.selectedItem and tree.Selected Items return null and
an array of null, so I can't use that either.

Hello Brian,
thanks for your reply.
The benefit of focusing a node in the tree is the following:
If a person only uses the keyboard to navigate (e.g. because of him/her being blind) expands a tree node, he expects the focus still being on the expanded tree node afterwards. But if a roundtrip to the server happens (because of a executed onClick-event) the focus after the reload is at the beginning of the page again. Thus the blind person hast to TAB through the whole page again until he reaches the tree node he has expanded.
I use the com.sapportals.htmlb.* package for the htmlb-elements.
Almost all elements are underclasses of com.sapportals.htmlb.Component, but Treenode is not.
I use a model to create tree nodes. TreeNodes are created like this in the Model:
mComponentsNode = new TreeNode(COMP_NODE_ID);
mComponentsNode.setComponent(new TextView(COMP_NODE_TEXT));
mComponentsNode.setOnNodeClick(MODE_ON_CLICK_EVENT);
mComponentsNode.setOnNodeExpand(TREE_NODE_EXPAND_EVENT);
mComponentsNode.setOnNodeClose(TREE_NODE_CLOSE_EVENT);
mComponentsNode.setTooltip(COMP_NODE_TOOLTIP);
mComponentsNode.setOpen(true);
mHomeNode.addChildNode(mComponentsNode);
In the JSP the tree is created like this:
<hbj:tree id="configTree"
 title=""
 rootNode="configTree"
 rootNodeIsVisible="false">
</tree>
Do you have any idea?
Thanks!
Regards,
Bastian

Disable Drag & Drop in Tree for some nodes

It is very easy to enable Drag and Drop on Tree controls. How
do I disable some Nodes from being dragged? I do not need all nodes
to be draggable.

The trick is not to use the tree drag* properties of the
control and instead use the DragManager to do custom drag and drop.
This allows to listen to mouse down events and evaluate
whether to useDragManager.doDrag() to initiate a drag.

Tree and Tree Node Components - Threadinar7

Hi All,
This is the seventh in the "Threadinar" series , please see Threadinar6 at
http://forum.sun.com/jive/thread.jspa?threadID=100601 for details
In this Threadinar we will focus on the
"Tree" and "Tree Node" Components
Let us begin our discussion with the Tree Component.
Tree Component
You can drag the Tree component from the Palette's Basic category to the Visual Designer to create a hierarchical tree structure with nodes that can be expanded and collapsed, like the nodes in the Outline window. When the user clicks a node, the row will be highlighted. A tree is often used as a navigation mechanism.
A tree contains Tree Node components, which act like hyperlinks. You can use a Tree Node to navigate to another page by setting its url property. You can also use a Tree Node to submit the current page. If the the Tree Node's action property is bound to an action event handler, selecting the node automatically submits the page. If the Tree Node's actionListener property is bound to an action listener, opening or closing the node automatically submits the page. You set Tree Node properties in the Tree Node Component Properties window.
* If you use this component to navigate between pages of a portlet, do not use the url property to link to a page. Instead, use the Navigation editor to set up your links to pages.
* Events related to tree node selection do not work correctly in portlets because the component uses cookies to pass the selected node id back and forth, and cookies are not correctly handled by the portlet container. You cannot handle tree node selection events in portlet projects.
Initially when you drop a tree on a page, it has one root node labeled Tree and one subnode labeled Tree Node 1. You can add more nodes by dragging them to the tree and dropping them either on the root node to create top level nodes or on existing nodes to create subnodes of those nodes. You can also right-click the Tree or any Tree Node and choose Add Tree Node to add a subnode to the node.
Additionally, you can work with the component in the Outline window, where the component and its child components are available as nodes. You can move a node from level to level easily in the Outline window, so you might want to work there if you are rearranging nodes. You can also add and delete tree nodes in the Outline window, just as in the Visual Designer.
The Tree component has properties that, among other things, enable you change the root node's displayed text, change the appearance of the text, specify if expanding or collapsing a node requires a trip to the server, and specify whether node selection should automatically open or close the tree. To set the Tree's properties, select the Tree component in your page and use the Tree Component Properties window.
The following Tutorial ("Using Tree Component") is very useful to learn using Tree components
http://developers.sun.com/prodtech/javatools/jscreator/learning/tutorials/2/sitemaptree.html
See Also the Technical Article - "Working with the Tree Component and Tree Node Actions"
http://developers.sun.com/prodtech/javatools/jscreator/reference/techart/2/tree_component.html
Tree Node Component
You can drag the Tree Node component from the Palette's Basic category to a Tree component or another tree node in the Visual Designer to create a node in a hierarchical tree structure, similar to the tree you see in the Outline window.
The tree node is created as a subnode of the node on which you drop it. If you drop the node on the tree component itself, a new node is created as a child of the root node. You can see the hierarchical structure clearly in the Outline window, where you can also easily move nodes around and reparent them.
You can also add a tree node either to a Tree component or to a Tree Node component by right-clicking the component and choosing Add Tree Node.
A Tree Node component by default is a container for an image and can be used to navigate to another page, submit the current page, or simply open or close the node if the node has child nodes.
* If you select the Tree Node component's node Tree Node icon in the Outline window, you can edit its properties in the Tree Node Properties window. You can set things like whether or not the Tree Node is expanded by default, the tooltip for the Tree Node, the label for the tree node, and the Tree Node's identifier in your web application.
* You can use a Tree Node to navigate to another page by setting its url property. You can also use a Tree Node to submit the current page. If the the Tree Node's action property is bound to an action event handler, selecting the node automatically submits the page. If the Tree Node's actionListener property is bound to an action listener, opening or closing the node automatically submits the page.
- Note: If you use this component to navigate between pages of a portlet, do not use the url property to link to a page. Instead, use the Navigation editor to set up your links to pages. In addition, events related to tree node selection do not work correctly in portlets because the component uses cookies to pass the selected node id back and forth, and cookies are not correctly handled by the portlet container. You cannot handle tree node selection events in portlet projects.
* If you select the image in the Tree Node, you can see that its icon property is set to TREE_DOCUMENT. If you right-click the image on the page and choose Set Image, you can either change the icon to another one or choose your own image in the Image Customizer dialog box. For more information on working with an image in a tree node, see Image component.
- Note: The image used in a tree node works best if it is 16x16 or smaller. Larger images can work, but might appear overlapped in the Visual Designer. You can right-click the component and choose Preview in Browser feature to check the appearance of the images.
Please share your comments, experiences, additional information, questions, feedback, etc. on these components.
------------------------------------------------------------------------------- --------------------

One challenge I had experience was to make the tree
always expanded on all pages (I placed my tree menu
in a page fragment so I can just import it in my
pages).Did you solve this problem. It would be interesting to know what you did.
To expand a node you call setExpanded on the node. Here is some code from a tutorial that a coworker of mine is working on.
In the prerender method:
 Integer expandedPersonId = getRequestBean1().getPersonId();
 // If expandedPersonId is null, then we are not coming back
 // from the Trip page. In that case we do not want any trip
 // nodes to be pre-selected (highlighted) due to browser cookies.
 if (expandedPersonId==null) {
 try {
 HttpServletRequest req =(HttpServletRequest)
 getExternalContext().getRequest();
 Cookie[] cookies = req.getCookies();
 //Check if cookies are set
 if (cookies != null) {
 for (int loop =0; loop < cookies.length; loop++) {
 if (cookies[loop].getName().equals
 ("form1:displayTree-hi")) {
 cookies[loop].setMaxAge(0);
 HttpServletResponse response =(HttpServletResponse)
 getExternalContext().getResponse();
 response.addCookie(cookies[loop]);
 } catch (Exception e) {
 error("Failure trying to clear highlighting of selected node:" +
 e.getMessage());
 } ... (in a loop for tree nodes)...
 personNode.setExpanded(newPersonId.equals
 (expandedPersonId));In the action method for the nodes:
 // Get the client id of the currently selected tree node
 String clientId = displayTree.getCookieSelectedTreeNode();
 // Extract component id from the client id
 String nodeId = clientId.substring(clientId.lastIndexOf(":")+1);
 // Find the tree node component with the given id
 TreeNode selectedNode =
 (TreeNode) this.getForm1().findComponentById(nodeId);
 try {
 // Node's id property is composed of "trip" plus the trip id
 // Extract the trip id and save it for the next page
 Integer tripId = Integer.valueOf(selectedNode.getId().substring(4));
 getRequestBean1().setTripId(tripId);
 } catch (Exception e) {
 error("Can't convert node id to Integer: " +
 selectedNode.getId().substring(4));
 return null;
It would also be great if I can set the tree
readonly where the user cannot toggle the expand
property of the tree (hope this can be added to the
tree functionality).

Manual Drag and Drop from Tree to Tree with XML dataProvider

Been struggling with Drag-n-Drop between Tree controls. As far as I can tell, it doesn't work very well.
I have boiled it down to a minimal project below and would be ever so grateful if someone can tell me what I am doing wrong.
The complete MXML application file is below. Flex 3.5.
Two trees side-by-side. One has XML that I want to drag over to the drop tree.
On the DragOver() event, I select the node which is given to me by the calculateDropIndex() function.
After startup; first open the L1 branch on the left and drag L11 over and drop it on the right Tree.
Looks good, root node is selected/highlighted and dropFeedback is correct and dropping the node drops it as a child of "Start Here".
Open the Start Here root node to see it.
Now proceded to #1 below.
Here are the problems:
1) Drag "L12" from the left tree over to the middle of the right tree (below "L11" just dropped). "L11" will not be selected. The Selected node (with dropIndex=4) will be the entire new nested XML "<L><L11/></L>"; and therefore only "Start Here" node will be highlighted. Drop "L12" anyway. So, it is acting like selectedIndex = <anynumber> will only select the root node. How do I get the new L11 to show as a drop target?
2) Now drag "L21" from the left tree onto the right tree; again starting below all nodes on the right tree. Selected node will not change until you drag it above #2 out of 3. Then, you can drag it anywhere, and correctly highlight/select any node as the target, and get that node in code. This is a problem. Go ahead and drop it anywhere. Now if you drag, for example, L22 from the left it will correctly highlight/select any node without having to first drag above #2 in the list.
3) Now, grab and drag L11 a second time and drop it at the bottom on the right. Drag L23 over. No matter which L11 you hover over, it highlights the one at the bottom. How can this be right?
Those are the bugs I would like to figure out. If I am doing it wrong, I sure would like to know what I am doing wrong. The code below is distilled down to one simple mxml application module.
Thanks,
Jeff
<?xml version="1.0" encoding="utf-8"?>
<mx:Application
xmlns:mx="http://www.adobe.com/2006/mxml" layout="horizontal" minWidth="955" minHeight="600">
<mx:Script>
<![CDATA[
import mx.collections.XMLListCollection;
import mx.core.IUIComponent;
import mx.events.DragEvent;
import mx.managers.DragManager;
Bindable]
private var dragXML:XML =
<Tree label="root"><L1 label="L1">
<L11 label="L11"/>
<L12 label="L12"/>
</L1>
<L2 label="L2">
<L21 label="L21"/>
<L22 label="L22"/>
<L23 label="L23"/>
</L2>
</Tree> ;
Bindable]
private var dragXMLListCollection:XMLListCollection = new XMLListCollection(dragXML.*);
Bindable]
private var dropXML:XML =
<Tree label="root"><L label="Start Here"/>
</Tree> ;
Bindable]
private var dropXMLListCollection:XMLListCollection = new XMLListCollection(dropXML.*);
// ************* Drag Drop Events ********************
private function dragEnter(evt:DragEvent):void
if (evt.dragSource.hasFormat("treeItems")) DragManager.acceptDragDrop(IUIComponent(evt.target));}
private function dragOver(evt:DragEvent):void
// Calculate dropindex and set selected item
var dropIndex:int = dropTree.calculateDropIndex(evt);dropTree.selectedIndex = dropIndex;
// setting the selected item based on calculateDropIndex()
var selNode:XML = dropTree.selectedItem as XML; // Getting XML for selected node in Tree
var selNodeName:String = (selNode != null ? selNode.localName() : "");
// Get dragged XML
var dragNode:XML = XML(evt.dragSource.dataForFormat("treeItems")[0]);
var dragNodeName:String = dragNode.localName();
trace(evt, "\n", dropIndex, "\n", (selNode ? selNode.toXMLString() : "null"), "\n", dragNode.toXMLString());
// you cannot drop a shorter name on a longer name
if ((dragNodeName.length >= selNodeName.length) && (selNode != null)) DragManager.showFeedback(DragManager.COPY);
else DragManager.showFeedback(DragManager.NONE);}
private function dragDrop(evt:DragEvent):void
// get selected node in drop tree
var selNode:XML = dropTree.selectedItem as XML; //selected in dragOver() event
// Get dragged XML
var dragNode:XML = XML(evt.dragSource.dataForFormat("treeItems")[0]);
// Drop logic
// Compare dragNode.localName().length to dropNode.localName().length
// if drag longer; drop as child
// if drag is equal; drop as sibling
// Drag can never be shorter in this example.
var isChild:Boolean = String(dragNode.localName()).length > String(selNode.localName()).length;
if (isChild){
selNode.insertChildAfter(
null, dragNode);}
else
selNode.parent().insertChildAfter(selNode, dragNode);
]]>
</mx:Script>
<mx:Tree id="dragTree" width="30%" showRoot="true" height="100%" labelField="@label"dataProvider="
{dragXMLListCollection}"dragEnabled="
true" dragMoveEnabled="false" dropEnabled="false" />
<mx:Tree id="dropTree" width="30%" showRoot="true" height="100%" labelField="@label"dataProvider="
{dropXMLListCollection}"dragEnter="dragEnter(event);" dragDrop="dragDrop(event);" dragOver="dragOver(event);"
/>
</mx:Application>

I just found out that by setting the dataProvider for each tree to the XML variable instead of the XMLListCollection variable, problems #1 and #2 went away!
But the documentation says to use an XMLListCollection if you will be dynamically changing the tree contents.
And, I just found out that #1 returns if I specify showRoot="false". But with it set to "true" that problem goes away. Is there some sort of minimum XML required to make drag-n-drop work on these Tree controls?
Hmmmm. It appears that (for #3) the calculateDropIndex() will always return the last matching XML node - by name - in the tree.

How to implement Drag and Drop in trees

Hi,
I have two hierarchical tree in a form, i need to drag each nodes form one tree node and drop into another tree, how i possible. am using Forms 6i developer.

Drag-n-Drop is only available in Forms by extending Forms with a Java Bean. In order to use a Java Bean in your form, your form MUST be web deployed; if you are using traditional Client/Server with your Forms 6i then there is no way to implement Drag-n-Drop.
Take a look at: Drag 'n Drop - Oracle Forms PJC and Java Beans. This article was based on using Oracle Forms 9i so you might not be able to implement it in your Forms 6i app.
Craig...

Context Menu on the right click of af:tree node

Hi Experts,
I am using drag and drop functionality in af:tree.In that i used one tree for drag source and another one tree for drop target,and it is working as expected.
Now I want to bring one additional option in the context menu of the target tree node that is ,when i right click on any of the target tree node in addition to the default menu options like "Collapse","Expand" i want to add one more option .For this i added "contextMenu" facet after the "nodeStamp" facet inside the tree.
*<f:facet name="contextMenu">*
*<af:popup id="p1">*
*<af:menu text="Delete" id="m1">*
*<af:commandMenuItem text="Delete" id="cmi1"*
*action="#{myWorkflow.deleteWorkflowNode}"/>*
*</af:menu>*
*</af:popup>*
*</f:facet*>
Now the problem is : before using drag and drop the context menu workes without any problem .But after using drag and drop the context menu is not popped up.
can anybody help me to resolve this?
Thanks,
Priya.

Hi Frank,
1. I am using JDeveloper 11.1.1.3 version
2. Drop target tree is having the context menu.
3. Yes . In Drop event am calling a backing bean method with return type DnDAction and i return the value as DnDAction.MOVE to reflect the changes in the database table to the target tree.
Regards,
Priya.

Need coordinate for particular tree node as currently expanded

Hi All,
i am working in flex for the past two months,currently i am
working on the drag and drop on a tree , where i am able to drag
one tree leaf node to another another tree leaf node and i am able
to draw a line between the two leaf node indicating that this has
been dragged from the previous tree of a particular node to the
current node of the tree.
The problem which i am facing is that when i collapse the
expanded tree , the line which i have drawn is not able to
synchronize with the tree expand or collapse (the line remains in
the same position even when the particular leaf node move down coz
of expansion of the above tree node.)
any help will be appreciated.

there is a private function in the tree.as class:
private function getVisibleChildrenCount(item:Object):int
that I can use by multiplying how many children there are by
how tall each item "physically" displays on the screen as, but I
want to get that publicly. I don't want to go about hacking the
tree.as code, that's poor form in the highest. Does anybody else
have any ideas...
please?

How to resize a custom tree node like you would a JFrame window?

Hello,
I am trying to resize a custom tree node like you would a JFrame window.
As with a JFrame, when your mouse crosses the Border, the cursor should change and you are able to drag the edge to resize the node.
However, I am faced with a problem. Border cannot detect this and I dont want to use a mouse motion listener (with a large number of nodes, I fear it will be inefficient, calculating every node's position constantly).
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Insets;
import java.util.EventObject;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellEditor;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeSelectionModel;
public class ResizeNode extends JPanel {
 AnilTreeCellRenderer2 atcr;
 AnilTreeCellEditor2 atce;
 DefaultTreeModel treeModel;
 JTree tree;
 DefaultMutableTreeNode markedNode = null;
 public ResizeNode() {
 super(new BorderLayout());
 treeModel = new DefaultTreeModel(null);
 tree = new JTree(treeModel);
 tree.setEditable(true);
 tree.getSelectionModel().setSelectionMode(
 TreeSelectionModel.SINGLE_TREE_SELECTION);
 tree.setShowsRootHandles(true);
 tree.setCellRenderer(atcr = new AnilTreeCellRenderer2());
 tree.setCellEditor(atce = new AnilTreeCellEditor2(tree, atcr));
 JScrollPane scrollPane = new JScrollPane(tree);
 add(scrollPane,BorderLayout.CENTER);
 public void setRootNode(DefaultMutableTreeNode node) {
 treeModel.setRoot(node);
 treeModel.reload();
 public static void main(String[] args){
 ResizeNode tb = new ResizeNode();
 tb.setPreferredSize(new Dimension(400,200));
 JFrame frame = new JFrame("ResizeNode");
 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 frame.setContentPane(tb);
 frame.setSize(400, 200);
 frame.pack();
 frame.setVisible(true);
 tb.populate();
 private void populate() {
 TextAreaNode2 r = new TextAreaNode2(this);
 setRootNode(r);
 TextAreaNode2 a = new TextAreaNode2(this);
 treeModel.insertNodeInto(a, r, r.getChildCount());
class AnilTreeCellRenderer2 extends DefaultTreeCellRenderer{
TreeBasic panel;
DefaultMutableTreeNode currentNode;
public AnilTreeCellRenderer2() {
 super();
public Component getTreeCellRendererComponent
 (JTree tree, Object value, boolean selected, boolean expanded,
 boolean leaf, int row, boolean hasFocus){
 TextAreaNode2 currentNode = (TextAreaNode2)value;
 NodeGUI2 gNode = (NodeGUI2) currentNode.gNode;
 return gNode.box;
class AnilTreeCellEditor2 extends DefaultTreeCellEditor{
DefaultTreeCellRenderer rend;
public AnilTreeCellEditor2(JTree tree, DefaultTreeCellRenderer r){
 super(tree, r);
 rend = r;
public Component getTreeCellEditorComponent(JTree tree, Object value,
 boolean isSelected, boolean expanded, boolean leaf, int row){
 return rend.getTreeCellRendererComponent(tree, value, isSelected, expanded,
 leaf, row, true);
public boolean isCellEditable(EventObject event){
 return true;
class NodeGUI2 {
 final ResizeNode view;
 Box box = Box.createVerticalBox();
 final JTextArea aa = new JTextArea( 1, 5 );
 final JTextArea aaa = new JTextArea( 1, 8 );
 NodeGUI2( ResizeNode view_ ) {
 this.view = view_;
 box.add( aa );
 aa.setBorder( BorderFactory.createMatteBorder( 0, 0, 1, 0, Color.GREEN ) );
 box.add( aaa );
 box.setBorder( BorderFactory.createMatteBorder( 5, 5, 5, 5, Color.CYAN ) );
 private Dimension getEditorPreferredSize() {
 Insets insets = box.getInsets();
 Dimension boxSize = box.getPreferredSize();
 Dimension aaSize = aa.getPreferredSize();
 Dimension aaaSize = aaa.getPreferredSize();
 int height = aaSize.height + aaaSize.height + insets.top + insets.bottom;
 int width = Math.max( aaSize.width, aaaSize.width );
 if ( width < boxSize.width )
 width += insets.right + insets.left + 3; // 3 for cursor
 return new Dimension( width, height );
class TextAreaNode2 extends DefaultMutableTreeNode {
 NodeGUI2 gNode;
 TextAreaNode2(ResizeNode view_) {
 gNode = new NodeGUI2(view_);
}

the node on the tree is only painted on using the
renderer to do the painting work. A mouse listener
has to be added to the tree, and when moved over an
area, you have to determine if you are over the
border and which direction to update the cursor and
to know which way to resize when dragged. One of the
BasicRootPaneUI has some code that can help determine
that.Thanks for replying. What is your opinion on this alternative idea that I just had?
I am wondering if it might be easier to have a toggle button in the node that you click when you want to resize the node. Then a mouse-down and dragging the mouse will resize the node. Mouse-up will reset the toggle button, and so will mouse down in an invalid area.
Anil

Tree item when-tree-node-selected fires differently from 6i to 10g.

In forms 6i, when you keyboard navigate between tree nodes, the wtns trigger will fire. In 10g it does not. In 10g, it will fire if you press the tab key or mouse click on a node.
Anyone know if this was done on purpose?
I ran into this after finally trying my props.fmb in 10g. It works fine in 6i, but not in 10g
copy of my form is here:
http://www.tailboom.com/oracle.php
Forms [32 Bit] Version 6.0.8.18.3 (Production) cleint server
Forms [32 Bit] Version 10.1.2.0.2 (Production)
I wrote most of the tree handling code for oracle apps APPTREE. This is the code that most if not all tree's in apps uses to build standard tree. So I have a pretty good understanding of the forms tree item. And know the wtns fired for web forms 6i on every node like 6i client server. This is very strange IMO.
Thanks.
--pat

Oleg,
thanks for the reference. Although the bug you identify deals with when-tree-node-activated, it is possible they fixed the when-tree-node-selected issue at the same time. With my test tree, i can currently duplicate both issues. I tried to download the patch, but it is only available for linux and unix. No windows patch. I don't have my linux env up and running to where I can test yet. So I can not confirm.
--pat

Useful Code of the Day: Hideable Tree Nodes

Someone posted about how they could selectively hide tree nodes, and I already had this AbstractTreeModel class (which does some things DefaultTreeModel does and some it doesn't) and a concrete subclass for TreeNode objects, so I was thinking how one could do hideable nodes. So I came up with this solution.
There's 4 classes here:
- AbstractTreeModel is the base for the concrete TreeNodeTreeModel
- TreeNodeTreeModel extends AbstractTreeModel to support TreeNodes (DefautlMutableTreeNode, etc.)
- HideableMutableTreeNode which is a DefautlMutableTreeNode subclass which has a visible field (with is/set methods, of course).
- HideableTreeModel is the hideable model which is a subclass of TreeNodeTreeModel.
A HideableMutableTreeNode can be set invisible directly, but the tree still needs to be notified to update. So it's best to use the methods in HideableTreeModel which set a node's visibility which notify the tree of changes accordingly. Methods are also provided to check a full path's visibility or ensure a node including all parent nodes are visible.
A HideableTreeModel can take any TreeNode class, it doesn't have to be all HideableMutableTreeNodes, but only HideableMutableTreeNodes can be made invisible, of course. Any other TreeNode type would just be considered visible.
Hiding nodes works basically by making the tree think there's less nodes then there are. And to do this, the node counts and child index search just works by looping thru the parent's children. This has potential perfomance drawbacks of course, since one has to loop thru the node's children to get nodes every time. This could be alleviated by not supporting non-hideable nodes changing the internal maintenance of HideableMutableTreeNode contents. But I'll leave that to whoever really needs it. It shouldn't be a problem if there are are a relatively small set of child nodes in any given parent.
Also, note that the root node in the model cannot be made invisible, cuz it'd be redundant since JTree can be set to hide the root node.
// *** HideableTreeModel ***
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;
* <code>HideableTreeModel</code> is an <code>TreeNodeTreeModel</code>
* implementation for <code>HideableMutableTreeNode</code> objects. The
* model can also take any other <code>javax.swing.tree.TreeNode</code>
* objects.
public class HideableTreeModel extends TreeNodeTreeModel {
 * Creates a new <code>HideableTreeModel</code> object.
 * @param root the root node
 public HideableTreeModel(TreeNode root) {
 super(root);
 * Checks if the specified node is visible. A node can only be
 * hidden if the node is an instance of <code>HideableMutableTreeNode</code>. 
 * 
 * Note that this only test the visibility of the specified node, not
 * whether a parent node is visible. Use <code>isPathToNodeVisible(Object)</code>
 * to check if the full path is visible.
 * @param node the node
 * @param true if the node is visible, else false
 public boolean isNodeVisible(Object node) {
 if(node != getRoot()) {
 if(node instanceof HideableMutableTreeNode) {
 return ((HideableMutableTreeNode)node).isVisible();
 return true;
 * Sets the specified node to be hidden. A node can only be made hidden
 * if the node is an instance of <code>HideableMutableTreeNode</code>. 
 * 
 * Note that this method will notify the tree to reflect any changes to
 * node visibility. 
 * 
 * Note that this will not alter the visibility of any nodes in the
 * specified node's path to the root node. Use
 * <code>ensurePathToNodeVisible(Object)</code> instead to make sure the
 * full path down to that node is visible. 
 * 
 * Note that this method will notify the tree to reflect any changes to
 * node visibility.
 * @param node the node
 * @param v true for visible, false for hidden
 * @param true if the node's visibility could actually change, else false
 public boolean setNodeVisible(Object node, boolean v) {
 // can't hide root
 if(node != getRoot()) {
 if(node instanceof HideableMutableTreeNode) {
 HideableMutableTreeNode n = (HideableMutableTreeNode)node;
 // don't fix what ain't broke...
 if(v != n.isVisible()) {
 TreeNode parent = n.getParent();
 if(v) {
 // need to get index after showing...
 n.setVisible(v);
 int index = getIndexOfChild(parent, n);
 super.nodeInserted(parent, n, index);
 } else {
 // need to get index before hiding...
 int index = getIndexOfChild(parent, n);
 n.setVisible(v);
 super.nodeRemoved(parent, n, index);
 return true;
 return false;
 * Checks if the specified node is visible and all nodes above it are
 * visible.
 * @param node the node
 * @param true if the path is visible, else false
 public boolean isPathToNodeVisible(Object node) {
 Object[] path = getPathToRoot(node);
 for(int i = 0; i < path.length; i++) {
 if(!isNodeVisible(path)) {
 return false;
 return true;
 * Sets the specified node and all nodes above it to be visible.
 * Note that this method will notify the tree to reflect any changes to
 * node visibility.
 * @param node the node
 public void ensurePathToNodeVisible(Object node) {
 Object[] path = getPathToRoot(node);
 for(int i = 0; i < path.length; i++) {
 setNodeVisible(path[i], true);
 * Returns the child of parent at index index in the parent's child array.
 * @param parent the parent node
 * @param index the index
 * @return the child or null if no children
 public Object getChild(Object parent, int index) {
 if(parent instanceof TreeNode) {
 TreeNode p = (TreeNode)parent;
 for(int i = 0, j = -1; i < p.getChildCount(); i++) {
 TreeNode pc = (TreeNode)p.getChildAt(i);
 if(isNodeVisible(pc)) {
 j++;
 if(j == index) {
 return pc;
 return null;
 * Returns the number of children of parent.
 * @param parent the parent node
 * @return the child count
 public int getChildCount(Object parent) {
 int count = 0;
 if(parent instanceof TreeNode) {
 TreeNode p = (TreeNode)parent;
 for(int i = 0; i < p.getChildCount(); i++) {
 TreeNode pc = (TreeNode)p.getChildAt(i);
 if(isNodeVisible(pc)) {
 count++;
 return count;
 * Returns the index of child in parent.
 * @param parent the parent node
 * @param child the child node
 * @return the index of the child node in the parent
 public int getIndexOfChild(Object parent, Object child) {
 int index = -1;
 if(parent instanceof TreeNode && child instanceof TreeNode) {
 TreeNode p = (TreeNode)parent;
 TreeNode c = (TreeNode)child;
 if(isNodeVisible(c)) {
 index = 0;
 for(int i = 0; i < p.getChildCount(); i++) {
 TreeNode pc = (TreeNode)p.getChildAt(i);
 if(pc.equals(c)) {
 return index;
 if(isNodeVisible(pc)) {
 index++;
 return index;
 * Main method for testing.
 * @param args the command-line arguments
 public static void main(String[] args) {
 JFrame f = new JFrame();
 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 HideableMutableTreeNode root = new HideableMutableTreeNode("root");
 root.add(new HideableMutableTreeNode("child_1"));
 final HideableMutableTreeNode c2 = new HideableMutableTreeNode("child_2");
 c2.setVisible(false);
 final HideableMutableTreeNode c2a = new HideableMutableTreeNode("child_2_A");
 c2.add(c2a);
 c2.add(new HideableMutableTreeNode("child_2_B"));
 root.add(c2);
 HideableMutableTreeNode c3 = new HideableMutableTreeNode("child_3");
 HideableMutableTreeNode cC = new HideableMutableTreeNode("child_3_C");
 cC.setVisible(false);
 c3.add(cC);
 c3.add(new HideableMutableTreeNode("child_3_D"));
 root.add(c3);
 root.add(new HideableMutableTreeNode("child_4"));
 root.add(new HideableMutableTreeNode("child_5"));
 DefaultMutableTreeNode c6 = new DefaultMutableTreeNode("child_6");
 c6.add(new DefaultMutableTreeNode("child_6_A"));
 c6.add(new DefaultMutableTreeNode("child_6_B"));
 root.add(c6);
 final HideableTreeModel model = new HideableTreeModel(root);
 JTree tree = new JTree(model);
 f.getContentPane().add(new JScrollPane(tree), BorderLayout.CENTER);
 JButton b = new JButton("toggle");
 b.addActionListener(new ActionListener() {
 public void actionPerformed(ActionEvent e) {
 model.setNodeVisible(c2, !model.isNodeVisible(c2));
 //model.ensurePathToNodeVisible(c2a);
 f.getContentPane().add(b, BorderLayout.SOUTH);
 f.pack();
 f.setSize(300, 500);
 f.show();
// *** HideableMutableTreeNode ***
import javax.swing.*;
import javax.swing.tree.*;
* <code>HideableMutableTreeNode</code> is a <code>DefaultMutableTreeNode</code>
* implementation that works with <code>HideableTreeModel</code>.
public class HideableMutableTreeNode extends DefaultMutableTreeNode {
 * The node is visible flag.
 public boolean visible = true;
 * Creates a tree node that has no parent and no children, but which
 * allows children.
 public HideableMutableTreeNode() {
 super();
 * Creates a tree node with no parent, no children, but which allows
 * children, and initializes it with the specified user object.
 * @param userObject - an Object provided by the user that
 * constitutes the node's data
 public HideableMutableTreeNode(Object userObject) {
 super(userObject);
 * Creates a tree node with no parent, no children, initialized with the
 * specified user object, and that allows children only if specified.
 * @param userObject - an Object provided by the user that
 * constitutes the node's data
 * @param allowsChildren - if true, the node is allowed to have child
 * nodes -- otherwise, it is always a leaf node
 public HideableMutableTreeNode(Object userObject, boolean allowsChildren) {
 super(userObject, allowsChildren);
 * Checks if the node is visible.
 * @return true if the node is visible, else false
 public boolean isVisible() {
 return this.visible;
 * Sets if the node is visible.
 * @param v true if the node is visible, else false
 public void setVisible(boolean v) {
 this.visible = v;
// *** TreeNodeTreeModel ***
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;
* <code>TreeNodeTreeModel</code> is an <code>AbstractTreeModel</code>
* implementation for <code>javax.swing.tree.TreeNode</code> objects.
public class TreeNodeTreeModel extends AbstractTreeModel {
 * Creates a new <code>TreeNodeTreeModel</code> object.
 * @param root the root node
 public TreeNodeTreeModel(TreeNode root) {
 super();
 setRoot(root);
 * Returns the parent of the child node.
 * @param node the child node
 * @return the parent or null if root
 public Object getParent(Object node) {
 if(node != getRoot() && (node instanceof TreeNode)) {
 return ((TreeNode)node).getParent();
 return null;
 * Returns the child of parent at index index in the parent's child array.
 * @param parent the parent node
 * @param index the index
 * @return the child or null if no children
 public Object getChild(Object parent, int index) {
 if(parent instanceof TreeNode) {
 return ((TreeNode)parent).getChildAt(index);
 return null;
 * Returns the number of children of parent.
 * @param parent the parent node
 * @return the child count
 public int getChildCount(Object parent) {
 if(parent instanceof TreeNode) {
 return ((TreeNode)parent).getChildCount();
 return 0;
 * Returns the index of child in parent.
 * @param parent the parent node
 * @param child the child node
 * @return the index of the child node in the parent
 public int getIndexOfChild(Object parent, Object child) {
 if(parent instanceof TreeNode && child instanceof TreeNode) {
 return ((TreeNode)parent).getIndex((TreeNode)child);
 return -1;
 * Returns true if node is a leaf.
 * @param node the node
 * @return true if the node is a leaf
 public boolean isLeaf(Object node) {
 if(node instanceof TreeNode) {
 return ((TreeNode)node).isLeaf();
 return true;
 * Main method for testing.
 * @param args the command-line arguments
 public static void main(String[] args) {
 JFrame f = new JFrame();
 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");
 root.add(new DefaultMutableTreeNode("child_1"));
 DefaultMutableTreeNode c2 = new DefaultMutableTreeNode("child_2");
 c2.add(new DefaultMutableTreeNode("child_2_A"));
 c2.add(new DefaultMutableTreeNode("child_2_B"));
 root.add(c2);
 root.add(new DefaultMutableTreeNode("child_3"));
 root.add(new DefaultMutableTreeNode("child_4"));
 JTree tree = new JTree(new TreeNodeTreeModel(root));
 f.getContentPane().add(new JScrollPane(tree));
 f.pack();
 f.setSize(300, 500);
 f.show();
// *** AbstractTreeModel ***
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.text.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;
public abstract class AbstractTreeModel implements TreeModel {
 * The list of tree model listeners.
 private Vector modelListeners = new Vector();
 * The root object of the tree.
 private Object root = null;
 * Basic no-op constructor.
 public AbstractTreeModel() {
 * Gets the root object of the tree.
 * @return the root object
 public Object getRoot() {
 return this.root;
 * Sets the root object of the tree.
 * @param r the root object
 protected void setRoot(Object r) {
 this.root = r;
 * Gets the path to the root node for the specified object.
 * @param node the root node
 * @return the path to the object or <CODE>null</CODE>
 public Object[] getPathToRoot(Object node) {
 return getPathToRoot(node, 0);
 * Gets the path to the root node for the specified object.
 * @param node the root node
 * @param i the current index
 * @return the path to the object or <CODE>null</CODE>
 private Object[] getPathToRoot(Object node, int i) {
 Object anode[];
 if(node == null) {
 if(i == 0) {
 return null;
 anode = new Object[i];
 } else {
 i++;
 if(node == getRoot()) {
 anode = new Object[i];
 } else {
 anode = getPathToRoot(getParent(node), i);
 anode[anode.length - i] = node;
 return anode;
 * Gets the parent object of the specified object. This method is not
 * part of the <code>javax.swing.tree.TreeModel</code> interface, but is
 * required to support the <code>getPathToRoot(Object)</code> method,
 * which is widely used in this class. Therefore, it is important to
 * correctly implement this method.
 * @param obj the object
 * @parma the parent object or null if no parent or invalid object
 protected abstract Object getParent(Object obj);
 * Adds a listener for the <CODE>TreeModelEvent</CODE> posted after the
 * tree changes.
 * @param l the tree model listener
 public void addTreeModelListener(TreeModelListener l) {
 modelListeners.addElement(l);
 * Removes a listener previously added with addTreeModelListener().
 * @param l the tree model listener
 public void removeTreeModelListener(TreeModelListener l) {
 modelListeners.removeElement(l);
 * Forces the tree to reload. This is useful when many changes occur
 * under the root node in the tree structure.
 * NOTE: This will cause the tree to be collapsed. To maintain
 * the expanded nodes, see the <code>getExpandedPaths(JTree)</code>
 * and <code>expandPaths(JTree, ArrayList)</code> methods.
 * @see #getExpandedPaths(JTree)
 * @see #expandPaths(JTree, ArrayList)
 public void reload() {
 reload(getRoot());
 * Forces the tree to repaint. This is useful when many changes occur
 * under a specific node in the tree structure.
 * NOTE: This will cause the tree to be collapsed below the
 * updated node.
 * @param node the node that changed
 public void reload(Object node) {
 if(node != null) {
 TreePath tp = new TreePath(getPathToRoot(node));
 fireTreeStructureChanged(new TreeModelEvent(this, tp));
 * Messaged when the user has altered the value for the item identified
 * by <CODE>path</CODE> to <CODE>newValue</CODE>.
 * @param path the path to the changed object
 * @param newValue the new value
 public void valueForPathChanged(TreePath path, Object newValue) {
 nodeChanged(path.getLastPathComponent());
 * Notifies the tree that nodes were inserted. The index is looked up
 * automatically.
 * @param node the parent node
 * @param child the inserted child node
 public void nodeInserted(Object node, Object child) {
 nodeInserted(node, child, -1);
 * Notifies the tree that nodes were inserted.
 * @param node the parent node
 * @param child the inserted child node
 * @param index the index of the child
 public void nodeInserted(Object node, Object child, int index) {
 if(index < 0) {
 index = getIndexOfChild(node, child);
 if(node != null && child != null && index >= 0) {
 TreePath tp = new TreePath(getPathToRoot(node));
 int[] ai = { index };
 Object[] ac = { child };
 fireTreeNodesInserted(new TreeModelEvent(this, tp, ai, ac));
 * Notifies the tree that nodes were removed. The index is required
 * since by this point, the object will no longer be in the tree.
 * @param node the parent node
 * @param child the removed child node
 * @param index the index of the child
 public void nodeRemoved(Object node, Object child, int index) {
 if(node != null && child != null && index >= 0) {
 TreePath tp = new TreePath(getPathToRoot(node));
 int[] ai = { index };
 Object[] ac = { child };
 fireTreeNodesRemoved(new TreeModelEvent(this, tp, ai, ac));
 * Notifies the tree that a node was changed.
 * @param node the changed node
 public void nodeChanged(Object node) {
 if(node != null) {
 TreePath tp = new TreePath(getPathToRoot(node));
 fireTreeNodesChanged(new TreeModelEvent(this, tp, null, null));
 * Fires "tree nodes changed" events to all listeners.
 * @param event the tree model event
 protected void fireTreeNodesChanged(TreeModelEvent event) {
 for(int i = 0; i < modelListeners.size(); i++) {
 ((TreeModelListener)modelListeners.elementAt(i)).treeNodesChanged(event);
 * Fires "tree nodes inserted" events to all listeners.
 * @param event the tree model event
 protected void fireTreeNodesInserted(TreeModelEvent event) {
 for(int i = 0; i < modelListeners.size(); i++) {
 ((TreeModelListener)modelListeners.elementAt(i)).treeNodesInserted(event);
 * Fires "tree nodes removed" events to all listeners.
 * @param event the tree model event
 protected void fireTreeNodesRemoved(TreeModelEvent event) {
 for(int i = 0; i < modelListeners.size(); i++) {
 ((TreeModelListener)modelListeners.elementAt(i)).treeNodesRemoved(event);
 * Fires "tree structure changed" events to all listeners.
 * @param event the tree model event
 protected void fireTreeStructureChanged(TreeModelEvent event) {
 for(int i = 0; i < modelListeners.size(); i++) {
 ((TreeModelListener)modelListeners.elementAt(i)).treeStructureChanged(event);
 * Records the list of currently expanded paths in the specified tree.
 * This method is meant to be called before calling the
 * <code>reload()</code> methods to allow the tree to store the paths.
 * @param tree the tree
 * @param pathlist the list of expanded paths
 public ArrayList getExpandedPaths(JTree tree) {
 ArrayList expandedPaths = new ArrayList();
 addExpandedPaths(tree, tree.getPathForRow(0), expandedPaths);
 return expandedPaths;
 * Adds the expanded descendants of the specifed path in the specified
 * tree to the internal expanded list.
 * @param tree the tree
 * @param path the path
 * @param pathlist the list of expanded paths
 private void addExpandedPaths(JTree tree, TreePath path, ArrayList pathlist) {
 Enumeration enum = tree.getExpandedDescendants(path);
 while(enum.hasMoreElements()) {
 TreePath tp = (TreePath)enum.nextElement();
 pathlist.add(tp);
 addExpandedPaths(tree, tp, pathlist);
 * Re-expands the expanded paths in the specified tree. This method is
 * meant to be called before calling the <code>reload()</code> methods
 * to allow the tree to store the paths.
 * @param tree the tree
 * @param pathlist the list of expanded paths
 public void expandPaths(JTree tree, ArrayList pathlist) {
 for(int i = 0; i < pathlist.size(); i++) {
 tree.expandPath((TreePath)pathlist.get(i));

Hey
I'm not trying to show anyone up here, but having just built a tree model for displaying an XML document in a tree, I thought this seemed like a neat exercise.
I implemented this very differently from the @OP. I only have one class, HiddenNodeTreeModel. All the hidden node data is stored in the model itself in my class. The advantage of what I've created is it will work with any TreeModel. The disadvantage is that I think it's not going to be very scalable - the additional computing to get the number of child nodes and to adjust indexes is heavy. So if you need a scalable solution definitely don't use this.
Anyway here you go
HiddenNodeTreeModel.java
======================
package tjacobs.ui.tree;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JTree;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import tjacobs.ui.WindowUtilities;
public class HiddenNodeTreeModel implements TreeModel {
 TreeModel mModel;
 ArrayList<Object> mHidden = new ArrayList<Object>();
 public HiddenNodeTreeModel (TreeModel model) {
 mModel = model;
 public void addTreeModelListener(TreeModelListener arg0) {
 mModel.addTreeModelListener(arg0);
 private ArrayList<Integer> getHiddenChildren(Object parent) {
 ArrayList<Integer> spots = new ArrayList<Integer>();
 Iterator _i = mHidden.iterator();
 while (_i.hasNext()) {
 Object hidden = _i.next();
 int idx = mModel.getIndexOfChild(parent, hidden);
 if (idx != -1) {
 spots.add(idx);
 return spots;
 public Object getChild(Object arg0, int index) {
 ArrayList<Integer> spots = getHiddenChildren(arg0);
 Collections.sort(spots);
 Iterator<Integer> _i = spots.iterator();
 while (_i.hasNext()) {
 int num = _i.next();
 if (num <= index) {
 index++;
 return mModel.getChild(arg0, index);
 public int getChildCount(Object arg0) {
 ArrayList list = getHiddenChildren(arg0);
 System.out.println("size = " + list.size());
 return mModel.getChildCount(arg0) - list.size();
 public int getIndexOfChild(Object arg0, Object arg1) {
 int index = mModel.getIndexOfChild(arg0, arg1);
 ArrayList<Integer> spots = getHiddenChildren(arg0);
 Collections.sort(spots);
 Iterator<Integer> _i = spots.iterator();
 int toSub = 0;
 while (_i.hasNext()) {
 int num = _i.next();
 if (num <= index) {
 toSub++;
 return index - toSub;
 public Object getRoot() {
 // TODO Auto-generated method stub
 return mModel.getRoot();
 public boolean isLeaf(Object arg0) {
 // TODO Auto-generated method stub
 return mModel.isLeaf(arg0);
 public void removeTreeModelListener(TreeModelListener arg0) {
 mModel.removeTreeModelListener(arg0);
 public void valueForPathChanged(TreePath arg0, Object arg1) {
 mModel.valueForPathChanged(arg0, arg1);
 public void hideNode(Object node) {
 if (node instanceof TreePath) {
 node = ((TreePath)node).getLastPathComponent();
 mHidden.add(node);
 public void showNode(Object node) {
 mHidden.remove(node);
 public void showAll() {
 mHidden.clear();
 * @param args
 public static void main(String[] args) {
 // TODO Auto-generated method stub
 DefaultMutableTreeNode A = new DefaultMutableTreeNode("A");
 DefaultMutableTreeNode B = new DefaultMutableTreeNode("B");
 DefaultMutableTreeNode C = new DefaultMutableTreeNode("C");
 DefaultMutableTreeNode D = new DefaultMutableTreeNode("D");
 DefaultMutableTreeNode E = new DefaultMutableTreeNode("E");
 DefaultMutableTreeNode F = new DefaultMutableTreeNode("F");
 A.add(B);
 B.add(C);
 B.add(D);
 B.add(E);
 E.add(F);
 DefaultTreeModel model = new DefaultTreeModel(A);
 final HiddenNodeTreeModel hmodel = new HiddenNodeTreeModel(model);
 final JTree tree = new JTree(hmodel);
 JFrame jf = new JFrame("HiddenNodeTreeModel Test");
 jf.add(tree);
 JMenuBar bar = new JMenuBar();
 jf.setJMenuBar(bar);
 JMenu menu = new JMenu("Options");
 bar.add(menu);
 final JMenuItem hide = new JMenuItem("Hide");
 final JMenuItem show = new JMenuItem("ShowAll");
 menu.add(hide);
 menu.add(show);
 ActionListener al = new ActionListener() {
 public void actionPerformed(ActionEvent ae) {
 if (ae.getSource() == hide) {
 hmodel.hideNode(tree.getSelectionPath());
 tree.updateUI();
 else {
 hmodel.showAll();
 tree.updateUI();
 hide.addActionListener(al);
 show.addActionListener(al);
 jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 jf.setBounds(100,100,100,100);
 jf.setVisible(true);
}

How to get a Tree Node Value when a Tree is Expanded

My reqiurement is when i Expand a Tree i need the Expanded tree Node Value. For Example Consider Parent as a Root Node of a Tree, and Consider its two Children Child1 and Child2.
When + Parent Expanded
I will Get the Output as --Parent
- Child1
- Child2
so As when i expand the Tree i must Get the String Value Parent.

duplicate
How to get a Tree Node Value when a Tree is Expanded

Assigning Selected Tree Node Value To An Item

Hi guys,
I want to assign selected tree node's value to a page item. This item can be a textbox or a label (display only). How can i do that? I tried to use "Selected Node Page Item" property which is available on Tree Attributes. But I couldn't assign the value without refreshing whole page.
Do you have any idea?
Thanks.

Hi ,
Thank you that was exactly what I was looking for. I couldn't find how to pass database column to javascript as an input parameter. So thanks for your help. I made a couple of correction :
1) I put additional ' characters to ('''||"NAME"||''') this part because my field is varchar.
select case when connect_by_isleaf = 1 then 0
when level = 1 then 1
else -1
end as status,
level,
NAME as title,
null as icon,
"ID" as value,
null as tooltip,
'javascript:setFObjName('''||"NAME"||''')' As link
from "#OWNER#"."TABLE_NAME"
start with "PID" is null
connect by prior "ID" = "PID"
2) In script I have added ' character before and after page item.
function setFObjName(pobjName){
$s('P1_OBJ_NAME', pobjName);
So it works. Thanks tfor your help.

Drop on tree node

Similar Messages

Maybe you are looking for