KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jacorb > ir > gui > typesystem > ModelBuilder


1 /*
2  * JacORB - a free Java ORB
3  *
4  * Copyright (C) 1999-2004 Gerald Brose
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public
17  * License along with this library; if not, write to the Free
18  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  *
20  */

21 package org.jacorb.ir.gui.typesystem;
22
23 import javax.swing.tree.*;
24 import javax.swing.table.*;
25 import javax.swing.event.*;
26 import java.util.*;
27
28 /**
29  * @author Joerg von Frantzius
30  */

31
32 public class ModelBuilder
33     implements Runnable JavaDoc, TreeExpansionListener, TreeModelListener
34 {
35     private Hashtable threadArguments = new Hashtable();
36     // (mit der Hashtable und dem Threadnamen als Key sind
37
// mehrere buildTreeModelAsync()-Threads möglich)
38

39     protected Hashtable expandedModParts = new Hashtable();
40     // key: DefaultMutableTreeNode
41
// hier stehen die TreeNodes drin, auf deren ModelParticipant
42
// bereits expand() aufgerufen und komplett abgearbeitet wurde
43

44     protected Hashtable treeViewsToUpdate = new Hashtable();
45     // key: DefaultMutableTreeNode; value: JTree
46

47     protected Hashtable treeNodesAndTableModels = new Hashtable();
48     // key: TreeNode; value: Vector[TableModel]
49
// welche TableModels gehören zu einer TreeNode
50

51     private Hashtable treeModelsListenedTo = new Hashtable();
52     // key: TreeModel
53
// zu welchen TreeModels sind wir als Listener eingetragen
54
// (mehrfaches addTreeModelListener() auf dem selben
55
// TreeModel würde mehrfache Events geben!)
56

57     private static ModelBuilder singleton = new ModelBuilder();
58
59     // wir brauchen eine ModelBuilder-Instanz, um einen Thread starten zu können
60
// (es wäre eine eigene Klasse nötig, wenn die Methoden static wären;
61
// inner classes gibts bei VisualAge leider noch nicht)
62

63     /**
64      * @return javax.swing.tree.TreeModel
65      * @param obj java.lang.Object
66      */

67     public DefaultTreeModel buildTreeModel(ModelParticipant rootModPart)
68     {
69     DefaultMutableTreeNode root = new DefaultMutableTreeNode(rootModPart);
70     DefaultTreeModel treeModel = new DefaultTreeModel(root);
71     treeModel.setAsksAllowsChildren(true);
72     rootModPart.buildTree(treeModel,null);
73     return treeModel;
74     }
75     /**
76      * @return javax.swing.tree.TreeModel
77      * @param obj java.lang.Object
78      */

79     public DefaultTreeModel buildTreeModelAsync(ModelParticipant rootModPart)
80     {
81     DefaultMutableTreeNode root = new DefaultMutableTreeNode(rootModPart);
82     DefaultTreeModel treeModel = new DefaultTreeModel(root);
83     treeModel.setAsksAllowsChildren(true);
84     Thread JavaDoc thread = new Thread JavaDoc(this);
85     threadArguments.put(thread.getName(),treeModel);
86         // run() entnimmt das Model der Hashtable
87
thread.start(); // asynchronen Aufbau des TreeModels starten
88
return treeModel;
89     }
90     /**
91      * Erzeugt TreeModel, das nur root enthält. Um Nodes zu
92      * expandieren, muß der von getTreeExpansionListener(treeModel)
93      * zurückgegebene TreeExpansionListener bei JTree angemeldet werden.
94      * @return javax.swing.tree.DefaultTreeModel
95      * @param root org.jacorb.ir.gui.typesystem.ModelParticipant
96      */

97     public DefaultTreeModel createTreeModelRoot(ModelParticipant rootModPart) {
98     DefaultMutableTreeNode root = new DefaultMutableTreeNode(rootModPart);
99     DefaultTreeModel treeModel = new DefaultTreeModel(root);
100     rootModPart.addToParent(treeModel,null);
101     treeModel.setAsksAllowsChildren(true);
102     return treeModel;
103     }
104     /**
105      * Dummy nur aus Synchronisierungsgründen
106      * @param modPart org.jacorb.ir.gui.typesystem.ModelParticipant
107      */

108     private synchronized void expandModPart(ModelParticipant modPart,
109                                             DefaultTreeModel treeModel)
110     {
111     modPart.expand(treeModel);
112     return;
113     }
114
115     public static ModelBuilder getSingleton()
116     {
117     return singleton;
118     }
119
120     /**
121      * @return TableModel
122      * @param node org.jacorb.ir.gui.typesystem.TypeSystemNode
123      */

124     public synchronized DefaultTableModel getTableModel(DefaultTreeModel treeModel,
125                                                         DefaultMutableTreeNode treeNode)
126     {
127     DefaultTableModel tableModel = new DefaultTableModel();
128     java.lang.Object JavaDoc[] colIdentifiers = {"Item","Type","Name"};
129     tableModel.setColumnIdentifiers(colIdentifiers);
130         // tableModel.setSortColumn("Name"); // gibt's nicht mehr in Swing 0.7
131

132     if (treeNode!=null &&
133             (treeNode.getUserObject() instanceof AbstractContainer))
134         {
135             if (!treeModelsListenedTo.containsKey(treeModel)) {
136                 treeModel.addTreeModelListener(this);
137                 treeModelsListenedTo.put(treeModel,treeModel);
138             }
139             if (treeNodesAndTableModels.containsKey(treeNode)) {
140                 Vector tableModels = (Vector)treeNodesAndTableModels.get(treeNode);
141                 tableModels.addElement(tableModel);
142             }
143             else {
144                 Vector tableModels = new Vector();
145                 tableModels.addElement(tableModel);
146                 treeNodesAndTableModels.put(treeNode,tableModels);
147             }
148             if (!expandedModParts.containsKey(treeNode)) {
149                 // Unterbaum muß erst geladen werden
150
startExpandNode(treeModel,treeNode);
151                 // wir sind synchronized, desgleichen expandModPart(),
152
// das vom Thread aufgerufen wird
153
// => wir kriegen alle Events mit, die generiert werden,
154
// wenn treeModel sich ändert
155
}
156             else
157             {
158                 // alles klar, Unterbaum ist schon da
159
for (int i=0; i<treeModel.getChildCount(treeNode); i++) {
160                     insertTableRow(tableModel,(DefaultMutableTreeNode)treeNode.getChildAt(i),i);
161                 }
162             } // if (!expandedModParts.containsKey(treeNode))
163
} // if (treeNode!=null...)
164
return tableModel;
165     }
166
167     /**
168      * @return javax.swing.event.TreeExpansionListener
169      * @param treeModel javax.swing.tree.DefaultTreeModel
170      */

171
172     public TreeExpansionListener getTreeExpansionListener(TreeModel treeModel)
173     {
174     return this; // treeModel kann ignoriert werden
175
}
176
177     /**
178      * @param tableModel javax.swing.table.DefaultTableModel
179      * @param treeNode javax.swing.tree.DefaultMutableTreeNode
180      */

181     private void insertTableRow(DefaultTableModel tableModel,
182                                 DefaultMutableTreeNode treeNode,
183                                 int index)
184     {
185         TypeSystemNode typeSystemNode = (TypeSystemNode)treeNode.getUserObject();
186         String JavaDoc type = "";
187         if (typeSystemNode instanceof TypeAssociator) {
188             type = ((TypeAssociator)typeSystemNode).getAssociatedType();
189         }
190         java.lang.Object JavaDoc[] row =
191         {new NodeMapper(typeSystemNode,typeSystemNode.getInstanceNodeTypeName()),
192          new NodeMapper(typeSystemNode,type),
193          new NodeMapper(typeSystemNode,typeSystemNode.getName())};
194         tableModel.insertRow(index,row);
195     }
196
197     /**
198      */

199     public void run ( )
200     {
201     Object JavaDoc argument = threadArguments.get(Thread.currentThread().getName());
202     if (argument instanceof DefaultTreeModel)
203         {
204             DefaultTreeModel treeModel = (DefaultTreeModel)argument;
205             ModelParticipant root =
206                 (ModelParticipant)((DefaultMutableTreeNode)treeModel.getRoot()).getUserObject();
207             root.buildTree(treeModel,null);
208     }
209     if (argument instanceof Object JavaDoc[]) {
210             Object JavaDoc[] args = (Object JavaDoc[])argument;
211             DefaultTreeModel treeModel = (DefaultTreeModel)args[0];
212             ModelParticipant modPart = (ModelParticipant)args[1];
213             expandModPart(modPart,treeModel);
214     }
215     }
216
217     /**
218      * Startet Thread, der expand() auf ModelParticipant der TreeNode aufruft
219      * @param treeModel javax.swing.tree.DefaultTreeModel
220      * @param treeNode javax.swing.tree.DefaultMutableTreeNode
221      */

222     private void startExpandNode(DefaultTreeModel treeModel,
223                                  DefaultMutableTreeNode treeNode)
224     {
225     ModelParticipant modPart = (ModelParticipant)treeNode.getUserObject();
226
227     if (!expandedModParts.containsKey(treeNode)) {
228             System.out.println("expanding node: "+treeNode);
229             Thread JavaDoc thread = new Thread JavaDoc(this);
230             Object JavaDoc[] args = new Object JavaDoc[2];
231             args[0] = treeModel;
232             args[1] = modPart;
233             threadArguments.put(thread.getName(),args);
234             // run() entnimmt das Model der Hashtable
235
thread.start(); // asynchrones expand starten
236
// modPart.expand(treeModel);
237
}
238     }
239
240     /**
241      * @param e javax.swing.event.TreeExpansionEvent
242      */

243     public void treeCollapsed(TreeExpansionEvent e)
244     {
245     return;
246     }
247
248     /**
249      * @param e javax.swing.event.TreeExpansionEvent
250      */

251
252     public synchronized void treeExpanded(TreeExpansionEvent e)
253     {
254     javax.swing.JTree JavaDoc jTree = (javax.swing.JTree JavaDoc)e.getSource();
255     DefaultTreeModel treeModel = (DefaultTreeModel)jTree.getModel();
256     TreePath path = e.getPath();
257     DefaultMutableTreeNode treeNode =
258             (DefaultMutableTreeNode)path.getPathComponent(path.getPathCount()-1);
259     treeViewsToUpdate.put(treeNode,jTree); // TreeView hinterlegen, der sofort hinzugefügte Nodes anzeigen soll
260
startExpandNode(treeModel,treeNode);
261     }
262
263     public void treeNodesChanged(TreeModelEvent te) {}
264
265     public void treeNodesInserted(TreeModelEvent te)
266     {
267         // System.out.println("treeNodesInserted()");
268
DefaultTreeModel treeModel = (DefaultTreeModel)te.getSource();
269     DefaultMutableTreeNode treeNode =
270             (DefaultMutableTreeNode)te.getTreePath().getLastPathComponent();
271     Vector tableModels = (Vector)treeNodesAndTableModels.get(treeNode);
272     DefaultTableModel tableModel;
273     Object JavaDoc[] children = te.getChildren();
274     int[] indices = te.getChildIndices();
275
276     if (tableModels!=null)
277         {
278             // else: zu der TreeNode gibt es keine TableModels
279
for (int i=0; i<indices.length; i++) {
280                 for (Enumeration e = tableModels.elements(); e.hasMoreElements(); ) {
281                     tableModel = (DefaultTableModel)e.nextElement();
282                     insertTableRow(tableModel,(DefaultMutableTreeNode)treeNode.getChildAt(indices[i]),indices[i]);
283                 }
284             }
285     }
286     }
287
288     public void treeNodesRemoved(TreeModelEvent te) {}
289
290     public void treeStructureChanged(TreeModelEvent te) {}
291 }
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
Popular Tags