KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > jimm > datavision > gui > FieldPickerWin


1 package jimm.datavision.gui;
2 import jimm.datavision.*;
3 import jimm.datavision.field.Field;
4 import jimm.datavision.field.ColumnField;
5 import jimm.datavision.field.SpecialField;
6 import jimm.datavision.gui.cmd.FPDeleteCommand;
7 import jimm.datavision.source.DataSource;
8 import jimm.datavision.source.Column;
9 import jimm.datavision.source.Table;
10 import jimm.datavision.gui.Designer;
11 import jimm.datavision.gui.cmd.NameableRenameCommand;
12 import jimm.datavision.gui.cmd.FPCutCommand;
13 import jimm.util.I18N;
14 import java.awt.Dimension JavaDoc;
15 import java.awt.BorderLayout JavaDoc;
16 import java.awt.event.*;
17 import java.util.*;
18 import javax.swing.*;
19 import javax.swing.event.*;
20 import javax.swing.tree.*;
21
22 /**
23  * A window that lets the user drag any field available onto the report and
24  * create, edit, delete, and rename formulas, parameters, and user columns.
25  * <p>
26  * Uses a {@link FieldPickerTree}. The classes used to store information about
27  * leaf nodes are subclasses of {@link FPLeafInfo} and are found in
28  * FPLeafInfo.java.
29  *
30  * @see FPTableInfo
31  * @author Jim Menard, <a HREF="mailto:jimm@io.com">jimm@io.com</a>
32  */

33 class FieldPickerWin
34     extends JDialog
35     implements ActionListener, TreeSelectionListener, TreeWillExpandListener,
36            Observer
37 {
38
39 public static final int REPORT_DATABASE_FIELDS = 0;
40 public static final int FORMULAS = 1;
41 public static final int PARAMETERS = 2;
42 public static final int USERCOLS = 3;
43 public static final int SPECIAL_FIELDS = 4;
44 public static final int ALL_DATABASE_FIELDS = 5;
45 // public static final int GROUP_NAME_FIELDS = XXXX;
46

47 protected Report report;
48 protected Designer designer;
49 protected JMenuItem cutItem, editFormulaItem, renameFormulaItem,
50     editParameterItem, renameParameterItem,
51     editUserColumnItem, renameUserColumnItem,
52     deleteItem;
53 protected FieldPickerTree tree;
54 protected DefaultTreeModel treeModel;
55 protected DefaultMutableTreeNode formulaCategoryNode;
56 protected DefaultMutableTreeNode parameterCategoryNode;
57 protected DefaultMutableTreeNode userColumnCategoryNode;
58 protected DefaultMutableTreeNode selectedNode;
59 protected FPLeafInfo selectedInfo;
60 protected Comparator nameComparator;
61
62 /**
63  * Constructor.
64  *
65  * @param designer the design window to which this dialog belongs
66  * @param report the report
67  * @param startingType the index of the starting type to display
68  */

69 FieldPickerWin(Designer designer, Report report, int startingType) {
70     super(designer.getFrame(), I18N.get("FieldPickerWin.title"));
71     this.report = report;
72     this.designer = designer;
73
74     // Note: this comparator imposes orderings that are inconsistent with
75
// equals.
76
nameComparator = new Comparator() {
77     public int compare(Object JavaDoc o1, Object JavaDoc o2) {
78         String JavaDoc name1 = ((Nameable)o1).getName();
79         String JavaDoc name2 = ((Nameable)o2).getName();
80         return name1.compareTo(name2);
81     }};
82
83     buildWindow(startingType);
84
85     pack();
86     show();
87 }
88
89 public void update(Observable o, Object JavaDoc arg) {
90     // Primitive and overkill, but it works.
91
tree.repaint();
92 }
93
94 /**
95  * Builds the contents of the window.
96  *
97  * @param startingType the index of the starting type to display
98  */

99 protected void buildWindow(int startingType) {
100     buildMenuBar();
101
102     DefaultMutableTreeNode top = new DefaultMutableTreeNode();
103     createNodes(top);
104     treeModel = new DefaultTreeModel(top);
105
106     tree = new FieldPickerTree(treeModel);
107     tree.setRootVisible(false);
108     tree.getSelectionModel().setSelectionMode
109     (TreeSelectionModel.SINGLE_TREE_SELECTION);
110
111     // Make specified starting type visible and expanded
112
tree.expandRow(startingType);
113
114     // Listen for selection changes and node expansions
115
tree.addTreeSelectionListener(this);
116     tree.addTreeWillExpandListener(this);
117
118     // Create the scroll pane and add the tree to it.
119
JScrollPane treeView = new JScrollPane(tree);
120     treeView.setMinimumSize(new Dimension JavaDoc(100, 100));
121     treeView.setPreferredSize(new Dimension JavaDoc(200, 300));
122
123     getContentPane().add(treeView, BorderLayout.CENTER);
124 }
125
126 /**
127  * Builds the window menu bar.
128  */

129 protected void buildMenuBar() {
130     JMenuBar bar = new JMenuBar();
131     bar.add(buildFileMenu());
132     bar.add(buildEditMenu());
133     bar.add(buildFieldMenu());
134     setJMenuBar(bar);
135 }
136
137 /**
138  * Builds and returns the "File" menu.
139  *
140  * @return a menu
141  */

142 protected JMenu buildFileMenu() {
143     JMenu menu = MenuUtils.readMenu("FieldPickerWin.menu_file");
144     MenuUtils.addToMenu(this, menu, "FieldPickerWin.menu_file_close");
145     return menu;
146 }
147
148 /**
149  * Builds and returns the "Edit" menu.
150  *
151  * @return a menu
152  */

153 protected JMenu buildEditMenu() {
154     JMenu menu = MenuUtils.readMenu("FieldPickerWin.menu_edit");
155
156     MenuUtils.addToMenu(this, menu, "FieldPickerWin.menu_edit_undo");
157     MenuUtils.addToMenu(this, menu, "FieldPickerWin.menu_edit_redo");
158     menu.addSeparator();
159     cutItem = MenuUtils.addToMenu(this, menu, "FieldPickerWin.menu_edit_cut");
160     MenuUtils.addToMenu(this, menu, "FieldPickerWin.menu_edit_copy");
161     MenuUtils.addToMenu(this, menu, "FieldPickerWin.menu_edit_paste");
162     deleteItem =
163     MenuUtils.addToMenu(this, menu, "FieldPickerWin.menu_edit_delete");
164
165     return menu;
166 }
167
168 /**
169  * Builds and returns the "Field" menu.
170  *
171  * @return a menu
172  */

173 protected JMenu buildFieldMenu() {
174     JMenu menu = MenuUtils.readMenu("FieldPickerWin.menu_field");
175
176     MenuUtils.addToMenu(this, menu, "FieldPickerWin.menu_field_new_formula");
177     editFormulaItem =
178     MenuUtils.addToMenu(this, menu,
179                 "FieldPickerWin.menu_field_edit_formula");
180     renameFormulaItem =
181     MenuUtils.addToMenu(this, menu,
182                 "FieldPickerWin.menu_field_rename_formula");
183
184     menu.addSeparator();
185
186     MenuUtils.addToMenu(this, menu, "FieldPickerWin.menu_field_new_param");
187     editParameterItem =
188     MenuUtils.addToMenu(this, menu,
189                 "FieldPickerWin.menu_field_edit_param");
190     renameParameterItem =
191     MenuUtils.addToMenu(this, menu,
192                 "FieldPickerWin.menu_field_rename_param");
193
194     menu.addSeparator();
195
196     MenuUtils.addToMenu(this, menu,
197             "FieldPickerWin.menu_field_new_usercol");
198     editUserColumnItem =
199     MenuUtils.addToMenu(this, menu,
200                 "FieldPickerWin.menu_field_edit_usercol");
201     renameUserColumnItem =
202     MenuUtils.addToMenu(this, menu,
203                 "FieldPickerWin.menu_field_rename_usercol");
204
205     return menu;
206 }
207
208 /**
209  * Creates tree nodes.
210  *
211  * @param top top-level tree node
212  */

213 protected void createNodes(DefaultMutableTreeNode top) {
214     createUsedDatabaseTables(top);
215     createFormulas(top);
216     createParameters(top);
217     createUserColumns(top);
218     createSpecialFields(top);
219     createAllDatabaseTables(top);
220 }
221
222 /**
223  * Creates nodes representing tables and columns for columns used by report.
224  *
225  * @param top top-level tree node
226  */

227 protected void createUsedDatabaseTables(DefaultMutableTreeNode top) {
228     DefaultMutableTreeNode categoryNode =
229     new DefaultMutableTreeNode(I18N.get("FieldPickerWin.db_fields"));
230     top.add(categoryNode);
231
232     // Store list of tables actually used by the report in a sorted set.
233
final TreeSet tables = new TreeSet(nameComparator);
234     final TreeSet noTableCols = new TreeSet(nameComparator);
235
236     // Walk the list of all columns used by the report, adding the table
237
// to the sorted set of tables.
238
report.withFieldsDo(new FieldWalker() {
239     public void step(Field f) {
240         if (f instanceof ColumnField) {
241         Column col = ((ColumnField)f).getColumn();
242         Table t = col.getTable();
243         if (t == null)
244             noTableCols.add(col);
245         else
246             tables.add(t);
247         }
248     }
249     });
250
251     // Add tables and columns under tables
252
for (Iterator iter = tables.iterator(); iter.hasNext(); )
253     addTableNode(categoryNode, (Table)iter.next());
254
255     // Add colums that have no table
256
for (Iterator iter = noTableCols.iterator(); iter.hasNext(); ) {
257     Column column = (Column)iter.next();
258     ColumnInfo info = new ColumnInfo(column, designer);
259     categoryNode.add(new DefaultMutableTreeNode(info, false));
260     }
261 }
262
263 /**
264  * Creates nodes representing formula fields.
265  *
266  * @param top top-level tree node
267  */

268 protected void createFormulas(DefaultMutableTreeNode top) {
269     formulaCategoryNode =
270     new DefaultMutableTreeNode(I18N.get("FieldPickerWin.formulas"));
271     top.add(formulaCategoryNode);
272
273     TreeSet formulas = new TreeSet(nameComparator);
274
275     for (Iterator iter = report.formulas(); iter.hasNext(); )
276     formulas.add(iter.next());
277
278     for (Iterator iter = formulas.iterator(); iter.hasNext(); ) {
279     Formula f = (Formula)iter.next();
280     FormulaInfo info = new FormulaInfo(report, f, designer);
281     formulaCategoryNode.add(new DefaultMutableTreeNode(info));
282     f.addObserver(this);
283     }
284 }
285
286 /**
287  * Creates nodes representing parameter fields.
288  *
289  * @param top top-level tree node
290  */

291 protected void createParameters(DefaultMutableTreeNode top) {
292     parameterCategoryNode =
293     new DefaultMutableTreeNode(I18N.get("FieldPickerWin.parameters"));
294     top.add(parameterCategoryNode);
295
296     TreeSet parameters = new TreeSet(nameComparator);
297
298     for (Iterator iter = report.parameters(); iter.hasNext(); )
299     parameters.add(iter.next());
300
301     for (Iterator iter = parameters.iterator(); iter.hasNext(); ) {
302     Parameter p = (Parameter)iter.next();
303     ParameterInfo info = new ParameterInfo(report, p, designer);
304     parameterCategoryNode.add(new DefaultMutableTreeNode(info));
305     p.addObserver(this);
306     }
307 }
308
309 /**
310  * Creates nodes representing user column fields.
311  *
312  * @param top top-level tree node
313  */

314 protected void createUserColumns(DefaultMutableTreeNode top) {
315     userColumnCategoryNode =
316     new DefaultMutableTreeNode(I18N.get("FieldPickerWin.usercols"));
317     top.add(userColumnCategoryNode);
318
319     TreeSet usercols = new TreeSet(nameComparator);
320
321     for (Iterator iter = report.userColumns(); iter.hasNext(); )
322     usercols.add(iter.next());
323
324     for (Iterator iter = usercols.iterator(); iter.hasNext(); ) {
325     UserColumn uc = (UserColumn)iter.next();
326     UserColumnInfo info = new UserColumnInfo(report, uc, designer);
327     userColumnCategoryNode.add(new DefaultMutableTreeNode(info));
328     uc.addObserver(this);
329     }
330 }
331
332 /**
333  * Creates nodes representing each possible special field.
334  *
335  * @param top top-level tree node
336  */

337 protected void createSpecialFields(DefaultMutableTreeNode top) {
338     DefaultMutableTreeNode categoryNode =
339     new DefaultMutableTreeNode(I18N.get("FieldPickerWin.specials"));
340     top.add(categoryNode);
341
342     HashMap strs = SpecialField.specialFieldNames();
343     TreeSet sortedKeys = new TreeSet(strs.keySet());
344
345     for (Iterator iter = sortedKeys.iterator(); iter.hasNext(); ) {
346     String JavaDoc key = (String JavaDoc)iter.next();
347     String JavaDoc val = (String JavaDoc)strs.get(key);
348     key = SpecialField.TYPE_STRING + ':' + key;
349     SpecialInfo info = new SpecialInfo(val, key, designer);
350                        
351     DefaultMutableTreeNode node = new DefaultMutableTreeNode(info);
352     categoryNode.add(node);
353     }
354 }
355
356 /**
357  * Creates notes representing tables and columns for all tables in the
358  * database.
359  *
360  * @param top top-level tree node
361  */

362 protected void createAllDatabaseTables(DefaultMutableTreeNode top) {
363     DefaultMutableTreeNode categoryNode =
364     new DefaultMutableTreeNode(I18N.get("FieldPickerWin.all"));
365     top.add(categoryNode);
366
367     // Store list of tables actually used by the report in a sorted set.
368
final TreeSet tables = new TreeSet(nameComparator);
369     final TreeSet noTableCols = new TreeSet(nameComparator);
370
371     // Walk data source's list of tables. If there are no tables for the
372
// data source, then instead add all columns to the noTableCols set.
373
DataSource source = report.getDataSource();
374     Iterator iter = source.tables();
375     if (iter != null) {
376     while (iter.hasNext())
377         tables.add(iter.next());
378     }
379
380     if (tables.isEmpty()) {
381     for (iter = source.columns(); iter.hasNext(); )
382         noTableCols.add(iter.next());
383     }
384
385     // Add nodes for tables and columns under tables
386
for (iter = tables.iterator(); iter.hasNext(); )
387     addTableNode(categoryNode, (Table)iter.next());
388
389     // Add nodes for columns that have no table
390
for (iter = noTableCols.iterator(); iter.hasNext(); ) {
391     Column column = (Column)iter.next();
392     ColumnInfo info = new ColumnInfo(column, designer);
393     categoryNode.add(new DefaultMutableTreeNode(info, false));
394     }
395 }
396
397 /**
398  * Creates and adds a node representing a data source table. The node is
399  * given one dummy node that will be removed when the table node loads its
400  * column nodes.
401  *
402  * @param categoryNode the parent node
403  * @param table the database table
404  */

405 protected void addTableNode(DefaultMutableTreeNode categoryNode, Table table) {
406     FPTableInfo info = new FPTableInfo(table, designer);
407     DefaultMutableTreeNode tableNode = new DefaultMutableTreeNode(info);
408     info.setTableNode(tableNode);
409     categoryNode.add(tableNode);
410
411     // Add a dummy node that will be removed when the table node
412
// loads its column nodes.
413
tableNode.add(new DefaultMutableTreeNode(""));
414 }
415
416 /**
417  * Opens a name editor to (re)name a nameable object. Returns <code>true</code>
418  * if the user clicked OK, <code>false</code> if the user clicked Cancel.
419  *
420  * @param nameable a nameable object
421  * @param editTitleKey I18N lookup key for "edit" title
422  * @param newTitleKey I18N lookup key for "new" title
423  * @param promptKey I18N lookup key for prompt
424  * @param unnamedKey I18N lookup key for "unnamed" name
425  * @return <code>true</code> if the user clicked OK, <code>false</code>
426  * if the user clicked Cancel
427  */

428 protected boolean rename(Nameable nameable, String JavaDoc newTitleKey,
429              String JavaDoc editTitleKey, String JavaDoc promptKey,
430              String JavaDoc unnamedKey)
431 {
432     String JavaDoc oldName = nameable.getName();
433     String JavaDoc title = (oldName == null || oldName.length() == 0)
434     ? I18N.get(newTitleKey) : I18N.get(editTitleKey);
435     String JavaDoc name = new AskStringDialog((JFrame)this.getOwner(), title,
436                       I18N.get(promptKey), oldName)
437     .getString();
438
439     if (name == null) // User cancelled
440
return false;
441
442     if (name.length() == 0)
443     name = I18N.get(unnamedKey);
444     designer.performCommand(new NameableRenameCommand(nameable, oldName,
445                                name));
446     return true;
447 }
448
449 /**
450  * Adds a newly created editable object to the tree, makes it visible,
451  * and opens its editor.
452  *
453  * @param info describes what is being added to add to the tree
454  * @param categoryNode where in the tree to put the new item
455  */

456 protected void addEditableToTree(FPLeafInfo info,
457                  DefaultMutableTreeNode categoryNode)
458 {
459     // Add to tree
460
DefaultMutableTreeNode node = new DefaultMutableTreeNode(info);
461     treeModel.insertNodeInto(node, categoryNode, categoryNode.getChildCount());
462
463     // Make leaf visible and make it the current selection
464
TreePath path = new TreePath(node.getPath());
465     tree.scrollPathToVisible(path);
466     tree.setSelectionPath(path);
467
468     editSelection(); // Open editor
469
}
470
471
472 /**
473  * Creates a new formula, adds it to the report and the tree, and opens
474  * the formula editor.
475  */

476 protected void newFormula() {
477     // Create formula and let user enter name
478
Formula f = new Formula(null, report, "", "");
479     if (renameFormula(f) == false)
480     return; // User cancelled
481

482     // Add to report and to tree and open editor
483
report.addFormula(f);
484     addEditableToTree(new FormulaInfo(report, f, designer),
485               formulaCategoryNode);
486 }
487
488 /**
489  * Opens a name editor to rename the currently select formula. Returns
490  * <code>true</code> if the user clicked OK, <code>false</code> if the
491  * user clicked Cancel.
492  *
493  * @return <code>true</code> if the user clicked OK, <code>false</code>
494  * if the user clicked Cancel
495  */

496 protected boolean renameFormula() {
497     return renameFormula((Formula)selectedInfo.getLeaf());
498 }
499
500 /**
501  * Opens a name editor to (re)name a formula. Returns <code>true</code>
502  * if the user clicked OK, <code>false</code> if the user clicked Cancel.
503  *
504  * @param f a formula
505  * @return <code>true</code> if the user clicked OK, <code>false</code>
506  * if the user clicked Cancel
507  */

508 protected boolean renameFormula(Formula f) {
509     return rename(f, "FieldPickerWin.new_formula_name_title",
510           "FieldPickerWin.edit_formula_name_title",
511           "FieldPickerWin.formula_name_prompt",
512           "FieldPickerWin.unnamed_formula");
513 }
514
515 /**
516  * Opens an editor on the currently selected item.
517  */

518 protected void editSelection() {
519     selectedInfo.openEditor();
520 }
521
522 /**
523  * Creates a new parameter, adds it to the report and the tree, and opens
524  * the parameter editor.
525  */

526 protected void newParameter() {
527     // Create parameter and let user edit it.
528
Parameter p = new Parameter(null, report);
529     if (renameParameter(p) == false)
530     return; // User cancelled
531

532     // Add to report and to tree and open editor
533
report.addParameter(p);
534     addEditableToTree(new ParameterInfo(report, p, designer),
535               parameterCategoryNode);
536 }
537
538 /**
539  * Opens a name editor to rename the currently select parameter. Returns
540  * <code>true</code> if the user clicked OK, <code>false</code> if the
541  * user clicked Cancel.
542  *
543  * @return <code>true</code> if the user clicked OK, <code>false</code>
544  * if the user clicked Cancel
545  */

546 protected boolean renameParameter() {
547     return renameParameter((Parameter)selectedInfo.getLeaf());
548 }
549
550 /**
551  * Opens a name editor to (re)name a parameter. Returns <code>true</code>
552  * if the user clicked OK, <code>false</code> if the user clicked Cancel.
553  *
554  * @param p a parameter
555  * @return <code>true</code> if the user clicked OK, <code>false</code>
556  * if the user clicked Cancel
557  */

558 protected boolean renameParameter(Parameter p) {
559     return rename(p, "FieldPickerWin.new_param_name_title",
560           "FieldPickerWin.edit_param_name_title",
561           "FieldPickerWin.param_name_prompt",
562           "FieldPickerWin.unnamed_parameter");
563 }
564
565 /**
566  * Creates a new user column, adds it to the report and the tree, and opens
567  * the user column editor.
568  */

569 protected void newUserColumn() {
570     // Create user column and let user enter name
571
UserColumn uc = new UserColumn(null, report, "");
572     if (renameUserColumn(uc) == false)
573     return; // User cancelled
574

575     // Add to report and to tree and open editor
576
report.addUserColumn(uc);
577     addEditableToTree(new UserColumnInfo(report, uc, designer),
578               userColumnCategoryNode);
579 }
580
581 /**
582  * Opens a name editor to rename the currently select user column. Returns
583  * <code>true</code> if the user clicked OK, <code>false</code> if the
584  * user clicked Cancel.
585  *
586  * @return <code>true</code> if the user clicked OK, <code>false</code>
587  * if the user clicked Cancel
588  */

589 protected boolean renameUserColumn() {
590     return renameUserColumn((UserColumn)selectedInfo.getLeaf());
591 }
592
593 /**
594  * Opens a name editor to (re)name a user column. Returns <code>true</code>
595  * if the user clicked OK, <code>false</code> if the user clicked Cancel.
596  *
597  * @param f a user column
598  * @return <code>true</code> if the user clicked OK, <code>false</code>
599  * if the user clicked Cancel
600  */

601 protected boolean renameUserColumn(UserColumn f) {
602     return rename(f, "FieldPickerWin.new_usercol_name_title",
603           "FieldPickerWin.edit_usercol_name_title",
604           "FieldPickerWin.usercol_name_prompt",
605           "FieldPickerWin.unnamed_usercol");
606 }
607
608 /**
609  * Handles user actions. Actions are only allowed when legal. For example,
610  * the "Cut" menu item will only be enabled when a delete operation is
611  * possible.
612  */

613 public void actionPerformed(ActionEvent e) {
614     String JavaDoc cmd = e.getActionCommand();
615
616     // File menu
617
if ("close".equals(cmd)) dispose();
618
619     // Edit menu
620
else if ("cut".equals(cmd))
621     designer.performCommand(new FPCutCommand(report, designer, tree,
622                           selectedNode));
623
624     // Field menu
625
else if ("new_formula".equals(cmd)) newFormula();
626     else if ("edit_formula".equals(cmd)) editSelection();
627     else if ("rename_formula".equals(cmd)) renameFormula();
628     else if ("new_parameter".equals(cmd)) newParameter();
629     else if ("edit_parameter".equals(cmd)) editSelection();
630     else if ("rename_parameter".equals(cmd)) renameParameter();
631     else if ("new_user_column".equals(cmd)) newUserColumn();
632     else if ("edit_user_column".equals(cmd)) editSelection();
633     else if ("rename_user_column".equals(cmd)) renameUserColumn();
634     else if ("delete".equals(cmd))
635     designer.performCommand(new FPDeleteCommand(report, designer, tree,
636                             selectedNode));
637 }
638
639 /**
640  * Modifies the menu in response to a change in the tree's selection.
641  */

642 public void valueChanged(TreeSelectionEvent e) {
643     if (e.isAddedPath()) {
644     selectedNode
645         = (DefaultMutableTreeNode)e.getPath().getLastPathComponent();
646     Object JavaDoc obj = selectedNode.getUserObject();
647     if (obj instanceof FPLeafInfo)
648         selectedInfo = (FPLeafInfo)obj;
649     else
650         selectedInfo = null;
651
652     if (selectedInfo == null) {
653         cutItem.setEnabled(false);
654         editFormulaItem.setEnabled(false);
655         editParameterItem.setEnabled(false);
656         editUserColumnItem.setEnabled(false);
657         renameFormulaItem.setEnabled(false);
658         renameParameterItem.setEnabled(false);
659         renameUserColumnItem.setEnabled(false);
660             deleteItem.setEnabled(false);
661     }
662     else {
663         boolean isFormula = selectedInfo instanceof FormulaInfo;
664         boolean isParameter = selectedInfo instanceof ParameterInfo;
665         boolean isUserColumn = selectedInfo instanceof UserColumnInfo;
666
667         cutItem.setEnabled(selectedInfo.isDeletable());
668         deleteItem.setEnabled(selectedInfo.isDeletable());
669         editFormulaItem.setEnabled(isFormula);
670         editParameterItem.setEnabled(isParameter);
671         editUserColumnItem.setEnabled(isUserColumn);
672         renameFormulaItem.setEnabled(isFormula);
673         renameParameterItem.setEnabled(isParameter);
674         renameUserColumnItem.setEnabled(isUserColumn);
675     }
676
677     }
678     else {
679     selectedInfo = null;
680     cutItem.setEnabled(false);
681     editFormulaItem.setEnabled(false);
682     editParameterItem.setEnabled(false);
683     editUserColumnItem.setEnabled(false);
684     renameFormulaItem.setEnabled(false);
685     renameParameterItem.setEnabled(false);
686     renameUserColumnItem.setEnabled(false);
687     }
688 }
689
690 public void treeWillExpand(TreeExpansionEvent e) {
691     DefaultMutableTreeNode node
692     = (DefaultMutableTreeNode)e.getPath().getLastPathComponent();
693     Object JavaDoc obj = node.getUserObject();
694     if (obj instanceof FPTableInfo)
695     ((FPTableInfo)obj).loadColumns();
696 }
697
698 public void treeWillCollapse(TreeExpansionEvent e) {
699 }
700
701 }
702
Popular Tags