001: package org.jacorb.ir.gui;
002:
003: /*
004: * JacORB - a free Java ORB
005: *
006: * Copyright (C) 1997-2004 Gerald Brose.
007: *
008: * This library is free software; you can redistribute it and/or
009: * modify it under the terms of the GNU Library General Public
010: * License as published by the Free Software Foundation; either
011: * version 2 of the License, or (at your option) any later version.
012: *
013: * This library is distributed in the hope that it will be useful,
014: * but WITHOUT ANY WARRANTY; without even the implied warranty of
015: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
016: * Library General Public License for more details.
017: *
018: * You should have received a copy of the GNU Library General Public
019: * License along with this library; if not, write to the Free
020: * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
021: */
022:
023: import javax.swing.*;
024: import javax.swing.table.*;
025: import javax.swing.tree.*;
026: import javax.swing.event.*;
027:
028: import java.awt.*;
029: import java.awt.event.*;
030:
031: import org.jacorb.ir.gui.typesystem.*;
032: import org.jacorb.ir.gui.typesystem.remote.RemoteTypeSystem;
033:
034: /**
035: * @author (c) Joerg von Frantzius, Gerald Brose, FU Berlin
036: * @version $Id: IRBrowser.java,v 1.10 2006/06/14 11:55:28 alphonse.bendt Exp $
037: */
038:
039: class IRBrowser extends JFrame implements
040: java.awt.event.WindowListener, java.awt.event.MouseListener,
041: ListSelectionListener, TreeSelectionListener, ActionListener {
042:
043: JTable contentTable;
044: JSplitPane splitPane;
045: JTree treeView;
046: JTextArea textArea;
047: TypeSystem typeSystem;
048: TreeModel treeModel;
049: JMenuItem followTypeMenu;
050: private static final String title = "IRBrowser";
051:
052: /**
053: * Constructor
054: */
055:
056: public IRBrowser() {
057: super ();
058: try {
059: typeSystem = new RemoteTypeSystem();
060: } catch (Exception e) {
061: System.err.println("Caught exception starting browser");
062: e.printStackTrace();
063: System.exit(-1);
064: }
065: initialize();
066: }
067:
068: /**
069: * @param repositoryIOR java.lang.String
070: */
071:
072: public IRBrowser(String repositoryIOR) {
073: super ();
074: try {
075: typeSystem = new RemoteTypeSystem(repositoryIOR);
076: } catch (Exception e) {
077: System.err.println("Caught exception starting browser");
078: e.printStackTrace();
079: System.exit(-1);
080: }
081: initialize();
082: }
083:
084: /**
085: * @param event java.awt.ActionEvent
086: */
087:
088: public void actionPerformed(java.awt.event.ActionEvent event) {
089: NodeMapper nodeMapper = (NodeMapper) contentTable.getModel()
090: .getValueAt(contentTable.getSelectedRow(), 0);
091: TypeSystemNode typeSystemNode = nodeMapper.getNode();
092: followTypeOf(typeSystemNode);
093: System.out.println("following type of " + typeSystemNode);
094: }
095:
096: /**
097: * conn0: (IRBrowser.window.windowClosing(java.awt.event.WindowEvent) --> IRBrowser.dispose())
098: * @param arg1 java.awt.event.WindowEvent
099: */
100:
101: private void conn0(java.awt.event.WindowEvent arg1) {
102: try {
103: // user code begin {1}
104: // user code end
105: this .dispose();
106: // user code begin {2}
107: // user code end
108: } catch (java.lang.Throwable ivjExc) {
109: // user code begin {3}
110: // user code end
111: handleException(ivjExc);
112: }
113: }
114:
115: /**
116: * @param typeSystemNode typesystem.TypeSystemNode
117: */
118:
119: public void followTypeOf(TypeSystemNode typeSystemNode) {
120: DefaultMutableTreeNode treeNode = null;
121:
122: if (typeSystemNode instanceof TypeAssociator) {
123: TypeSystemNode assTypeNode = ((TypeAssociator) typeSystemNode)
124: .getAssociatedTypeSystemNode();
125: if (assTypeNode.getModelRepresentant(treeModel) != null) {
126: treeNode = (DefaultMutableTreeNode) assTypeNode
127: .getModelRepresentant(treeModel);
128: }
129: }
130: if (treeNode != null) {
131: // wenn Node ein AbstractContainer ist oder eine assoziierte
132: // TypeSystemNode besitzt, jeweils im treeView dorthin springen
133: DefaultTreeModel treeModel = (DefaultTreeModel) treeView
134: .getModel();
135: TreePath fullTreePath = new TreePath(treeModel
136: .getPathToRoot(treeNode));
137:
138: treeView.scrollPathToVisible(fullTreePath);
139: // Selection auf node setzen
140: treeView.setSelectionPath(fullTreePath);
141: treeView.validate();
142: }
143: }
144:
145: /**
146: * Called whenever the part throws an exception.
147: * @param exception java.lang.Throwable
148: */
149:
150: private void handleException(Throwable exception) {
151: exception.printStackTrace();
152: }
153:
154: /**
155: * Initializes connections
156: */
157:
158: private void initConnections() {
159: this .addWindowListener(this );
160: }
161:
162: /**
163: * Initialize class
164: */
165:
166: public void initialize() {
167: // setBackground(java.awt.Color.lightGray);
168: setTitle(title);
169:
170: splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
171:
172: // Create the table
173: DefaultTableModel tableModel = typeSystem.getTableModel(null);
174: contentTable = new JTable(tableModel);
175: contentTable.setAutoCreateColumnsFromModel(true);
176: // contentTable.setModel(tableModel);
177: contentTable.setColumnSelectionAllowed(false);
178: contentTable.setRowSelectionAllowed(true);
179: contentTable.setCellSelectionEnabled(false);
180: contentTable.removeEditor();
181: contentTable.setShowGrid(false);
182: contentTable.setTableHeader(new javax.swing.table.JTableHeader(
183: contentTable.getColumnModel()));
184: contentTable.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
185: // contentTable.setBackground(java.awt.Color.white);
186: // contentTable.setMinimumSize(new java.awt.Dimension(100,contentTable.getMinimumSize().height));
187: contentTable.setMinimumSize(new Dimension(100, 100));
188: contentTable.getSelectionModel().addListSelectionListener(this );
189:
190: this .treeModel = typeSystem.getTreeModel();
191: // this.treeModel = typeSystem.createTreeModelRoot();
192: treeView = new JTree(treeModel);
193: // treeView.addTreeExpansionListener(typeSystem.getTreeExpansionListener(this.treeModel));
194: treeView.setRootVisible(true);
195: treeView.setShowsRootHandles(true);
196: // treeView.setBackground(java.awt.Color.lightGray);
197: // treeView.setMinimumSize(new java.awt.Dimension(200,100));
198: treeView.setMinimumSize(new Dimension(100, 100));
199: treeView.addTreeSelectionListener(this );
200:
201: JScrollPane tableScrollPane = JTable
202: .createScrollPaneForTable(contentTable);
203: JScrollPane treeScrollPane = new JScrollPane(treeView);
204: // tableScrollPane.setBackground(java.awt.Color.white);
205: tableScrollPane
206: .setMinimumSize(new java.awt.Dimension(100, 100));
207: treeScrollPane.setMinimumSize(new java.awt.Dimension(100, 100));
208: tableScrollPane.setPreferredSize(new java.awt.Dimension(100,
209: 100));
210: treeScrollPane
211: .setPreferredSize(new java.awt.Dimension(100, 100));
212:
213: textArea = new JTextArea("Hallo, hallo!");
214: textArea.setEditable(false);
215: textArea.setFont(new java.awt.Font("sansserif",
216: java.awt.Font.PLAIN, 10));
217: textArea.setRows(4);
218: textArea.setTabSize(15);
219: textArea.setBorder(BorderFactory.createLoweredBevelBorder());
220: textArea.setMinimumSize(new java.awt.Dimension(100, 100));
221: textArea.setPreferredSize(new Dimension(600, 90));
222: // textArea.setBackground(java.awt.Color.lightGray);
223:
224: splitPane.setLeftComponent(new JScrollPane(treeView));
225: splitPane.setRightComponent(tableScrollPane);
226: // splitPane.setRightComponent(new JScrollPane(contentTable));
227: splitPane.setDividerLocation(300);
228:
229: // Hinzufügen der Komponenten
230: Container contentPane = getContentPane();
231: // contentPane.setBackground(java.awt.Color.lightGray);
232: /* getContentPane().setLayout(new java.awt.BorderLayout());
233: getContentPane().add(splitPane, java.awt.BorderLayout.NORTH);
234: getContentPane().add(textArea, java.awt.BorderLayout.SOUTH);
235: */
236: // contentPane.setLayout(new BorderLayout());
237: /* Container north = new JPanel();
238: north.setLayout(new SpringLayout());
239: Container south = new JPanel();
240: south.setLayout(new SpringLayout());
241: north.add(splitPane, SpringLayout.HEIGHT_WIDTH_SPRING);
242: south.add(textArea);
243: contentPane.add(north,BorderLayout.NORTH);
244: contentPane.add(south,BorderLayout.SOUTH);
245: */
246: // contentPane.add(splitPane,"North");
247: // contentPane.add(textArea,"South");
248: splitPane.setBounds(0, 0, 600, 400 - textArea
249: .getPreferredSize().height);
250: textArea.setBounds(0, splitPane.bounds().height, 600, textArea
251: .getPreferredSize().height);
252: // contentPane.setLayout(layout);
253: contentPane.setLayout(new BorderLayout());
254: contentPane.add("Center", splitPane);
255:
256: // contentPane.add(textArea);
257: contentPane.add("South", textArea);
258: contentPane.setBackground(Color.white);
259:
260: resize(600, 400);
261: // contentPane.setBounds();
262:
263: // JPopupMenu popup = new JPopupMenu(treeView);
264: // popup.add(new JMenuItem("Hallo?"));
265: // popup.addPopupMenuListener(new TreePopupMenuListener());
266: // treeView.add(popup);
267:
268: JMenuBar menuBar = new JMenuBar();
269: JMenu menu = new JMenu("Navigate");
270: menuBar.add(menu);
271: followTypeMenu = new JMenuItem("Follow Type");
272: followTypeMenu.setEnabled(false);
273: followTypeMenu.addActionListener(this );
274: menu.add(followTypeMenu);
275: setJMenuBar(menuBar);
276:
277: validate();
278: treeView.expandPath(new TreePath(
279: ((DefaultMutableTreeNode) treeModel.getRoot())
280: .getPath()));
281:
282: treeView.addMouseListener((MouseListener) this );
283: contentTable.addMouseListener((MouseListener) this );
284: // pack();
285: // validate();
286: // validate();
287: // user code end
288: setName("IRBrowser");
289: setName("IRBrowser");
290: initConnections();
291: // user code begin {2}
292: // user code end
293: }
294:
295: private static void usage() {
296: System.out
297: .println("Usage: IRBrowser [ -i ior_str | -f filename ]");
298: System.out
299: .println(" Note - if no arguments, will default to using resolve_initial_reference");
300: }
301:
302: /**
303: * @param args java.lang.String[]
304: */
305:
306: public static void main(String args[]) {
307: IRBrowser test = null;
308: String ior = null;
309:
310: if (args.length == 1 || args.length > 2) {
311: usage();
312: } else if (args.length == 2 && args[0].equals("-f")) {
313: try {
314: java.io.BufferedReader in = new java.io.BufferedReader(
315: new java.io.FileReader(args[1]));
316: ior = in.readLine();
317: while (ior.indexOf("IOR:") != 0)
318: ior = in.readLine();
319: in.close();
320: } catch (java.io.IOException io) {
321: io.printStackTrace();
322: usage();
323: }
324: test = new IRBrowser(ior);
325: } else if (args.length == 2 && args[0].equals("-i")) {
326: test = new IRBrowser(args[1]);
327: } else {
328: test = new IRBrowser();
329: }
330: test.show();
331: }
332:
333: public void mouseClicked(MouseEvent event) {
334: javax.swing.tree.DefaultMutableTreeNode treeNode = null;
335: // bei Doppelklick auf contentTable den treeView auf entsprechende TypeSystemNode setzen
336: if (event.getComponent() == contentTable
337: && event.getClickCount() > 1
338: && contentTable.getSelectedRow() != -1) {
339: System.out.println("contentTable doubleClick");
340: // im TableModel steckt in jeder Zelle ein NodeMapper, von dem die dazugehörige treeNode zu erfahren ist
341:
342: NodeMapper nodeMapper = (NodeMapper) contentTable
343: .getModel().getValueAt(
344: contentTable.getSelectedRow(), 0);
345: TypeSystemNode typeSystemNode = nodeMapper.getNode();
346:
347: if (typeSystemNode instanceof AbstractContainer) {
348: treeNode = (DefaultMutableTreeNode) typeSystemNode
349: .getModelRepresentant(treeModel);
350: }
351:
352: if (typeSystemNode instanceof TypeAssociator) {
353: TypeSystemNode assTypeNode = ((TypeAssociator) typeSystemNode)
354: .getAssociatedTypeSystemNode();
355: if (assTypeNode.getModelRepresentant(treeModel) != null) {
356: treeNode = (DefaultMutableTreeNode) assTypeNode
357: .getModelRepresentant(treeModel);
358: }
359: }
360: if (treeNode != null) {
361: // wenn Node ein AbstractContainer ist oder eine assoziierte TypeSystemNode besitzt, jeweils im treeView dorthin springen
362:
363: System.out.println("expanding Tree: " + treeNode);
364: DefaultTreeModel treeModel = (DefaultTreeModel) treeView
365: .getModel();
366: TreePath fullTreePath = new TreePath(treeModel
367: .getPathToRoot(treeNode));
368:
369: treeView.scrollPathToVisible(fullTreePath);
370: // Selection auf node setzen
371: treeView.setSelectionPath(fullTreePath);
372: treeView.validate();
373: }
374: }
375: }
376:
377: public void mouseEntered(MouseEvent event) {
378: }
379:
380: public void mouseExited(MouseEvent event) {
381: }
382:
383: public void mousePressed(MouseEvent event) {
384: }
385:
386: public void mouseReleased(MouseEvent event) {
387: }
388:
389: /**
390: * Setze Titel des Frames und enable/disable Menüs je nach
391: * selektierter Node (Node kann in TableView oder in TreeView
392: * selektiert worden sein)
393: * @param node typesystem.TypeSystemNode
394: */
395:
396: public void setSelectedNode(TypeSystemNode node) {
397: // Node kann TableView oder TreeView selektiert worden sein
398: setTitle(title + " - " + node.getAbsoluteName());
399: textArea.setText(node.description());
400: if (node instanceof TypeAssociator) {
401: followTypeMenu.setEnabled(true);
402: } else {
403: followTypeMenu.setEnabled(false);
404: }
405: }
406:
407: /**
408: */
409:
410: public void valueChanged(ListSelectionEvent e) {
411: // contentTable nur bei einfacher Selection ändern
412: // System.out.println("valueChanged (Table...)");
413: TypeSystemNode node;
414: if (contentTable.getSelectedRow() != -1) {
415: NodeMapper nodeMapper = (NodeMapper) contentTable
416: .getModel().getValueAt(
417: contentTable.getSelectedRow(), 0);
418:
419: if ((node = ((TypeSystemNode) nodeMapper.getNode())) != null) {
420: setSelectedNode(node);
421: }
422: }
423: }
424:
425: /**
426: */
427:
428: public void valueChanged(TreeSelectionEvent e) {
429: // contentTable nur bei einfacher Selection ändern
430: DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) e
431: .getPath().getLastPathComponent();
432:
433: TypeSystemNode node = (TypeSystemNode) treeNode.getUserObject();
434:
435: contentTable.setModel(typeSystem.getTableModel(treeNode));
436: contentTable.clearSelection();
437: TableColumnModel tabColMod = contentTable.getColumnModel();
438:
439: for (int i = 0; i < contentTable.getColumnCount(); i++) {
440: TableColumn tabCol = tabColMod.getColumn(i);
441: tabCol.setCellEditor(null);
442: // otherwise columns would be editable
443: }
444: setSelectedNode(node);
445: contentTable.validate();
446: treeView.validate();
447: }
448:
449: /**
450: * Method to handle events for the WindowListener interface.
451: * @param e java.awt.event.WindowEvent
452: */
453:
454: public void windowActivated(java.awt.event.WindowEvent e) {
455: // user code begin {1}
456: // user code end
457: // user code begin {2}
458: // user code end
459: }
460:
461: /**
462: * Method to handle events for the WindowListener interface.
463: * @param e java.awt.event.WindowEvent
464: */
465:
466: /* WARNING: THIS METHOD WILL BE REGENERATED. */
467:
468: public void windowClosed(java.awt.event.WindowEvent e) {
469: // user code begin {1}
470: System.exit(0);
471: // user code end
472: // user code begin {2}
473: // user code end
474:
475: }
476:
477: /**
478: * Method to handle events for the WindowListener interface.
479: * @param e java.awt.event.WindowEvent
480: */
481: /* WARNING: THIS METHOD WILL BE REGENERATED. */
482:
483: public void windowClosing(java.awt.event.WindowEvent e) {
484: // user code begin {1}
485: // user code end
486: if ((e.getSource() == this )) {
487: conn0(e);
488: }
489: // user code begin {2}
490: // user code end
491: }
492:
493: /**
494: * Method to handle events for the WindowListener interface.
495: * @param e java.awt.event.WindowEvent
496: */
497: /* WARNING: THIS METHOD WILL BE REGENERATED. */
498:
499: public void windowDeactivated(java.awt.event.WindowEvent e) {
500: // user code begin {1}
501: // user code end
502: // user code begin {2}
503: // user code end
504: }
505:
506: /**
507: * Method to handle events for the WindowListener interface.
508: * @param e java.awt.event.WindowEvent
509: */
510: /* WARNING: THIS METHOD WILL BE REGENERATED. */
511:
512: public void windowDeiconified(java.awt.event.WindowEvent e) {
513: // user code begin {1}
514: // user code end
515: // user code begin {2}
516: // user code end
517: }
518:
519: /**
520: * Method to handle events for the WindowListener interface.
521: * @param e java.awt.event.WindowEvent
522: */
523: /* WARNING: THIS METHOD WILL BE REGENERATED. */
524:
525: public void windowIconified(java.awt.event.WindowEvent e) {
526: // user code begin {1}
527: // user code end
528: // user code begin {2}
529: // user code end
530: }
531:
532: /**
533: * Method to handle events for the WindowListener interface.
534: * @param e java.awt.event.WindowEvent
535: */
536: /* WARNING: THIS METHOD WILL BE REGENERATED. */
537:
538: public void windowOpened(java.awt.event.WindowEvent e) {
539: // user code begin {1}
540: // user code end
541: // user code begin {2}
542: // user code end
543: }
544: }
|