|
1
21
22 package swingwtx.swing.tree;
23
24 import swingwtx.swing.event.EventListenerList;
25 import swingwtx.swing.event.TreeModelEvent;
26 import swingwtx.swing.event.TreeModelListener;
27
28 public class DefaultTreeModel implements TreeModel {
29
30 protected TreeNode root;
31 protected EventListenerList listenerList = new EventListenerList();
32 protected boolean asksAllowsChildren;
33
34 public DefaultTreeModel(TreeNode root) {
35 this(root, false);
36 }
37
38 public DefaultTreeModel(TreeNode root, boolean asksAllowsChildren) {
39 super();
40 this.root = root;
41 this.asksAllowsChildren = asksAllowsChildren;
42 }
43
44 public void setRoot(TreeNode root) {
45 Object  lastRoot = this.root;
46 this.root = root;
47 if (root == null && lastRoot != null) {
48 fireTreeStructureChanged(this, null, null, null);
49 }
50 else {
51 nodeStructureChanged(root);
52 }
53 }
54
55 public Object getRoot() {
56 return root;
57 }
58
59 public int getIndexOfChild(Object parent, Object child) {
60 if(parent == null || child == null)
61 return -1;
62 return ((TreeNode) parent).getIndex((TreeNode) child);
63 }
64
65 public void setAsksAllowsChildren(boolean newValue) {
66 asksAllowsChildren = newValue;
67 }
68
69 public boolean asksAllowsChildren() {
70 return asksAllowsChildren;
71 }
72
73 public Object getChild(Object parent, int index) {
74 return ((TreeNode) parent).getChildAt(index);
75 }
76
77 public int getChildCount(Object parent) {
78 return ((TreeNode) parent).getChildCount();
79 }
80
81 public boolean isLeaf(Object node) {
82 if(asksAllowsChildren)
83 return !((TreeNode) node).getAllowsChildren();
84 return ((TreeNode)node).isLeaf();
85 }
86
87 public void reload() {
88 reload(root);
89 }
90
91 public void reload(TreeNode node) {
92 fireTreeStructureChanged(this, getPathToRoot(node), null, null);
93 }
94
95 public void valueForPathChanged(TreePath path, Object newValue) {
96 MutableTreeNode node = (MutableTreeNode) path.getLastPathComponent();
97 node.setUserObject(newValue);
98 nodeChanged(node);
99 }
100
101 public void insertNodeInto(MutableTreeNode newChild,
102 MutableTreeNode parent, int index){
103 parent.insert(newChild, index);
104 int[] newIndexs = new int[1];
105 newIndexs[0] = index;
106 nodesWereInserted(parent, newIndexs);
107 }
108
109 public void removeNodeFromParent(MutableTreeNode node) {
110 MutableTreeNode parent = (MutableTreeNode)node.getParent();
111 int[] childIndex = new int[1];
112 Object [] removedArray = new Object [1];
113 childIndex[0] = parent.getIndex(node);
114 parent.remove(childIndex[0]);
115 removedArray[0] = node;
116 nodesWereRemoved(parent, childIndex, removedArray);
117 }
118
119 public void nodeChanged(TreeNode node) {
120 if( listenerList.getListenerCount() > 0 && node != null) {
121 TreeNode parent = node.getParent();
122 if(parent != null) {
123 int anIndex = parent.getIndex(node);
124 if(anIndex != -1) {
125 int[] cIndexs = new int[1];
126 cIndexs[0] = anIndex;
127 nodesChanged(parent, cIndexs);
128 }
129 }
130 else if (node == getRoot()) {
131 nodesChanged(node, null);
132 }
133 }
134 }
135
136 public void nodesWereInserted(TreeNode node, int[] childIndices) {
137 if(listenerList.getListenerCount() > 0 && node != null && childIndices != null
138 && childIndices.length > 0) {
139 int cCount = childIndices.length;
140 Object [] newChildren = new Object [cCount];
141 for(int counter = 0; counter < cCount; counter++)
142 newChildren[counter] = node.getChildAt(childIndices[counter]);
143 fireTreeNodesInserted(this, getPathToRoot(node), childIndices,
144 newChildren);
145 }
146 }
147
148 public void nodesWereRemoved(TreeNode node, int[] childIndices,
149 Object [] removedChildren) {
150 if(node != null && childIndices != null) {
151 fireTreeNodesRemoved(this, getPathToRoot(node), childIndices, removedChildren);
152 }
153 }
154
155 public void nodesChanged(TreeNode node, int[] childIndices) {
156 if(node != null) {
157 if (childIndices != null) {
158 int cCount = childIndices.length;
159 if(cCount > 0) {
160 Object [] cChildren = new Object [cCount];
161 for(int counter = 0; counter < cCount; counter++)
162 cChildren[counter] = node.getChildAt
163 (childIndices[counter]);
164 fireTreeNodesChanged(this, getPathToRoot(node), childIndices, cChildren);
165 }
166 }
167 else if (node == getRoot()) {
168 fireTreeNodesChanged(this, getPathToRoot(node), null, null);
169 }
170 }
171 }
172
173 public void nodeStructureChanged(TreeNode node) {
174 if(node != null) {
175 fireTreeStructureChanged(this, getPathToRoot(node), null, null);
176 }
177 }
178
179 public TreeNode[] getPathToRoot(TreeNode aNode) {
180 return getPathToRoot(aNode, 0);
181 }
182
183 protected TreeNode[] getPathToRoot(TreeNode aNode, int depth) {
184 TreeNode[] nodes;
185 if(aNode == null) {
186 if(depth == 0)
187 return null;
188 else
189 nodes = new TreeNode[depth];
190 }
191 else {
192 depth++;
193 if(aNode == root)
194 nodes = new TreeNode[depth];
195 else
196 nodes = getPathToRoot(aNode.getParent(), depth);
197 nodes[nodes.length - depth] = aNode;
198 }
199 return nodes;
200 }
201
202
203 public Object [] getListeners(Class listenerType) {
204 return listenerList.getListeners(listenerType);
205 }
206
207 public void addTreeModelListener(TreeModelListener l) {
208 listenerList.add(TreeModelListener.class, l);
209 }
210
211 public void removeTreeModelListener(TreeModelListener l) {
212 listenerList.remove(TreeModelListener.class, l);
213 }
214
215 public TreeModelListener[] getTreeModelListeners() {
216 return (TreeModelListener[]) listenerList.getListeners(TreeModelListener.class);
217 }
218
219 protected void fireTreeNodesInserted(Object source, Object [] path,
220 int[] childIndices,
221 Object [] children) {
222 Object [] listenerz = getTreeModelListeners();
223 TreeModelEvent e = new TreeModelEvent(source, path, childIndices, children);
224 for (int i = 0; i< listenerz.length; i++) {
225 ((TreeModelListener) listenerz[i]).treeNodesInserted(e);
226 }
227 }
228
229 protected void fireTreeNodesChanged(Object source, Object [] path,
230 int[] childIndices,
231 Object [] children) {
232 Object [] listenerz = getTreeModelListeners();
233 TreeModelEvent e = new TreeModelEvent(source, path, childIndices, children);
234 for (int i = 0; i< listenerz.length; i++) {
235 ((TreeModelListener) listenerz[i]).treeNodesChanged(e);
236 }
237 }
238
239 protected void fireTreeNodesRemoved(Object source, Object [] path,
240 int[] childIndices,
241 Object [] children) {
242 Object [] listenerz = getTreeModelListeners();
243 TreeModelEvent e = new TreeModelEvent(source, path, childIndices, children);
244 for (int i = 0; i< listenerz.length; i++) {
245 ((TreeModelListener) listenerz[i]).treeNodesRemoved(e);
246 }
247
248 }
249
250 protected void fireTreeStructureChanged(Object source, Object [] path,
251 int[] childIndices,
252 Object [] children) {
253 Object [] listenerz = getTreeModelListeners();
254 TreeModelEvent e = new TreeModelEvent(source, path, childIndices, children);
255 for (int i = 0; i< listenerz.length; i++) {
256 ((TreeModelListener) listenerz[i]).treeStructureChanged(e);
257 }
258 }
259
260
261 }
262 |
Popular Tags |
Java API By Example, From Geeks To Geeks.