0001: /*
0002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
0003: *
0004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
0005: *
0006: * The contents of this file are subject to the terms of either the GNU
0007: * General Public License Version 2 only ("GPL") or the Common
0008: * Development and Distribution License("CDDL") (collectively, the
0009: * "License"). You may not use this file except in compliance with the
0010: * License. You can obtain a copy of the License at
0011: * http://www.netbeans.org/cddl-gplv2.html
0012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
0013: * specific language governing permissions and limitations under the
0014: * License. When distributing the software, include this License Header
0015: * Notice in each file and include the License file at
0016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
0017: * particular file as subject to the "Classpath" exception as provided
0018: * by Sun in the GPL Version 2 section of the License file that
0019: * accompanied this code. If applicable, add the following below the
0020: * License Header, with the fields enclosed by brackets [] replaced by
0021: * your own identifying information:
0022: * "Portions Copyrighted [year] [name of copyright owner]"
0023: *
0024: * Contributor(s): Alexandre Iline.
0025: *
0026: * The Original Software is the Jemmy library.
0027: * The Initial Developer of the Original Software is Alexandre Iline.
0028: * All Rights Reserved.
0029: *
0030: * If you wish your version of this file to be governed by only the CDDL
0031: * or only the GPL Version 2, indicate your decision by adding
0032: * "[Contributor] elects to include this software in this distribution
0033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
0034: * single choice of license, a recipient has the option to distribute
0035: * your version of this file under either the CDDL, the GPL Version 2 or
0036: * to extend the choice of license to its licensees as provided above.
0037: * However, if you add GPL Version 2 code and therefore, elected the GPL
0038: * Version 2 license, then the option applies only if the new code is
0039: * made subject to such option by the copyright holder.
0040: *
0041: *
0042: *
0043: * $Id: GUIBrowser.java,v 1.7 2007/10/05 11:37:06 jskrivanek Exp $ $Revision: 1.7 $ $Date: 2007/10/05 11:37:06 $
0044: *
0045: */
0046:
0047: package org.netbeans.jemmy.explorer;
0048:
0049: import org.netbeans.jemmy.ClassReference;
0050: import org.netbeans.jemmy.TestOut;
0051: import org.netbeans.jemmy.QueueTool;
0052:
0053: import org.netbeans.jemmy.operators.Operator;
0054:
0055: import java.awt.AWTEvent;
0056: import java.awt.AWTException;
0057: import java.awt.BorderLayout;
0058: import java.awt.Color;
0059: import java.awt.Component;
0060: import java.awt.Container;
0061: import java.awt.Dimension;
0062: import java.awt.Frame;
0063: import java.awt.Graphics;
0064: import java.awt.Rectangle;
0065: import java.awt.Robot;
0066: import java.awt.Window;
0067:
0068: import java.awt.event.ActionEvent;
0069: import java.awt.event.ActionListener;
0070: import java.awt.event.ComponentEvent;
0071: import java.awt.event.ComponentListener;
0072: import java.awt.event.WindowListener;
0073: import java.awt.event.WindowEvent;
0074: import java.awt.image.BufferedImage;
0075: import java.io.ByteArrayInputStream;
0076: import java.io.ByteArrayOutputStream;
0077:
0078: import java.io.File;
0079: import java.io.FileInputStream;
0080: import java.io.FileOutputStream;
0081: import java.io.IOException;
0082: import java.io.InputStream;
0083: import java.io.OutputStream;
0084: import java.io.OutputStreamWriter;
0085: import java.io.PrintWriter;
0086:
0087: import java.lang.reflect.Field;
0088: import java.lang.reflect.InvocationTargetException;
0089: import java.lang.reflect.Method;
0090: import java.lang.reflect.Modifier;
0091:
0092: import java.util.Arrays;
0093: import java.util.Collections;
0094: import java.util.Comparator;
0095: import java.util.Hashtable;
0096: import java.util.Properties;
0097: import java.util.Vector;
0098:
0099: import javax.swing.DefaultListModel;
0100: import javax.swing.JButton;
0101: import javax.swing.JCheckBox;
0102: import javax.swing.JComboBox;
0103: import javax.swing.JDialog;
0104: import javax.swing.JFileChooser;
0105: import javax.swing.JFrame;
0106: import javax.swing.JLabel;
0107: import javax.swing.JList;
0108: import javax.swing.JPanel;
0109: import javax.swing.JScrollPane;
0110: import javax.swing.JSplitPane;
0111: import javax.swing.JTabbedPane;
0112: import javax.swing.JTable;
0113: import javax.swing.JTextArea;
0114: import javax.swing.JTextField;
0115: import javax.swing.JTree;
0116: import javax.swing.ListCellRenderer;
0117:
0118: import javax.swing.border.BevelBorder;
0119:
0120: import javax.swing.event.ChangeEvent;
0121: import javax.swing.event.ChangeListener;
0122: import javax.swing.event.ListSelectionEvent;
0123: import javax.swing.event.ListSelectionListener;
0124: import javax.swing.event.TreeModelListener;
0125: import javax.swing.event.TreeSelectionEvent;
0126: import javax.swing.event.TreeSelectionListener;
0127: import javax.swing.filechooser.FileFilter;
0128: import javax.swing.table.DefaultTableModel;
0129: import javax.swing.tree.TreeCellRenderer;
0130: import javax.swing.tree.TreeModel;
0131: import javax.swing.tree.TreePath;
0132: import org.netbeans.jemmy.util.Dumper;
0133:
0134: /**
0135: * An application allowing to explore a Java GUI application.
0136: * Could be executed by command: <br>
0137: * <pre>
0138: * java "application java options" \
0139: * org.netbeans.jemmy.explorer.GUIBrowser \
0140: * "application main class" \
0141: * "application parameters"
0142: * </pre>
0143: * or from java code by <code>GUIBrowser.showBrowser()</code> method using.
0144: *
0145: * @author Alexandre Iline (alexandre.iline@sun.com)
0146: */
0147: public class GUIBrowser extends JFrame {
0148:
0149: private static String WINDOWS_TAB = "Subwindows";
0150: private static String COMPONENTS_TAB = "Hierarchy";
0151: private static String PROPERTIES_TAB = "Properties";
0152: private static String REFLECTION_TAB = "Reflection";
0153: private static String EVENT_TAB = "Events";
0154: private static String IMAGE_TAB = "Image";
0155:
0156: boolean exit;
0157: PropertyDialog propDialog;
0158: RootNode root;
0159: QueueTool qt;
0160: JTextField refreshDelay;
0161: JTree mainTree;
0162: JLabel status;
0163: JButton viewButton;
0164: JButton expandButton;
0165: JSplitPane split;
0166: ByteArrayOutputStream dumpData;
0167: PrintWriter dumpWriter;
0168:
0169: private GUIBrowser(boolean exitNecessary) {
0170: super ("GUI Browser");
0171:
0172: dumpData = new ByteArrayOutputStream();
0173: dumpWriter = new PrintWriter(new OutputStreamWriter(dumpData));
0174:
0175: exit = exitNecessary;
0176: propDialog = new PropertyDialog(this );
0177: qt = new QueueTool();
0178: qt.setOutput(TestOut.getNullOutput());
0179: root = new RootNode();
0180:
0181: mainTree = new JTree(root.getWindowModel());
0182: mainTree.setCellRenderer(new WindowRenderer());
0183: mainTree.setEditable(false);
0184:
0185: refreshDelay = new JTextField(3);
0186: refreshDelay.setText("0");
0187:
0188: viewButton = new JButton("View");
0189: viewButton.setEnabled(false);
0190: viewButton.addActionListener(new ActionListener() {
0191: public void actionPerformed(ActionEvent e) {
0192: new ComponentBrowser(getOwnr(),
0193: (ComponentNode) mainTree.getSelectionPath()
0194: .getLastPathComponent()).show();
0195: }
0196: });
0197:
0198: expandButton = new JButton("Expand All");
0199: expandButton.setEnabled(false);
0200: expandButton.addActionListener(new ActionListener() {
0201: public void actionPerformed(ActionEvent e) {
0202: expandAll(mainTree, mainTree.getSelectionPath());
0203: }
0204: });
0205:
0206: JButton refreshButton = new JButton("Reload in ...");
0207: refreshButton.addActionListener(new ActionListener() {
0208: public void actionPerformed(ActionEvent e) {
0209: reload(new Integer(refreshDelay.getText()).intValue());
0210: }
0211: });
0212:
0213: JButton dumpButton = new JButton("Dump");
0214: dumpButton.addActionListener(new ActionListener() {
0215: public void actionPerformed(ActionEvent e) {
0216: JFileChooser chooser = new JFileChooser(System
0217: .getProperty("user.home"));
0218: chooser.addChoosableFileFilter(new FileFilter() {
0219: public boolean accept(File f) {
0220: return (f.getName().endsWith(".xml"));
0221: }
0222:
0223: public String getDescription() {
0224: return ("xml files");
0225: }
0226: });
0227: chooser.showSaveDialog(GUIBrowser.this );
0228: try {
0229: File file = chooser.getSelectedFile();
0230: OutputStream output = new FileOutputStream(file);
0231: output.write(dumpData.toByteArray());
0232: } catch (IOException ee) {
0233: ee.printStackTrace();
0234: }
0235: }
0236: });
0237:
0238: JPanel refreshPane = new JPanel();
0239: refreshPane.add(viewButton);
0240: refreshPane.add(expandButton);
0241: refreshPane.add(new JLabel(""));
0242: refreshPane.add(new JLabel(""));
0243: refreshPane.add(new JLabel(""));
0244: refreshPane.add(new JLabel(""));
0245: refreshPane.add(new JLabel(""));
0246: refreshPane.add(new JLabel(""));
0247: refreshPane.add(refreshButton);
0248: refreshPane.add(refreshDelay);
0249: refreshPane.add(new JLabel("seconds "));
0250: refreshPane.add(dumpButton);
0251:
0252: split = createUnderPane(mainTree);
0253:
0254: JPanel nonStatusPane = new JPanel();
0255: nonStatusPane.setLayout(new BorderLayout());
0256: nonStatusPane.add(refreshPane, BorderLayout.SOUTH);
0257: nonStatusPane.add(split, BorderLayout.CENTER);
0258:
0259: split.setDividerLocation(0.8);
0260:
0261: status = new JLabel("Reloaded");
0262:
0263: JPanel statusPane = new JPanel();
0264: statusPane.setLayout(new BorderLayout());
0265: statusPane.add(status, BorderLayout.CENTER);
0266: statusPane.setBorder(new BevelBorder(BevelBorder.LOWERED));
0267:
0268: JPanel bottomPane = new JPanel();
0269: bottomPane.setLayout(new BorderLayout());
0270: bottomPane.add(statusPane, BorderLayout.NORTH);
0271: bottomPane.add(statusPane, BorderLayout.CENTER);
0272:
0273: getContentPane().setLayout(new BorderLayout());
0274: getContentPane().add(bottomPane, BorderLayout.SOUTH);
0275: getContentPane().add(nonStatusPane, BorderLayout.CENTER);
0276:
0277: Component[] cpss = { viewButton, expandButton };
0278: mainTree.addTreeSelectionListener(new SelectionManager(cpss));
0279:
0280: addWindowListener(new WindowListener() {
0281: public void windowActivated(WindowEvent e) {
0282: }
0283:
0284: public void windowClosed(WindowEvent e) {
0285: setVisible(false);
0286: if (exit) {
0287: System.exit(0);
0288: }
0289: }
0290:
0291: public void windowClosing(WindowEvent e) {
0292: }
0293:
0294: public void windowDeactivated(WindowEvent e) {
0295: }
0296:
0297: public void windowDeiconified(WindowEvent e) {
0298: }
0299:
0300: public void windowIconified(WindowEvent e) {
0301: }
0302:
0303: public void windowOpened(WindowEvent e) {
0304: }
0305: });
0306: addComponentListener(new ComponentListener() {
0307: public void componentHidden(ComponentEvent e) {
0308: }
0309:
0310: public void componentMoved(ComponentEvent e) {
0311: }
0312:
0313: public void componentResized(ComponentEvent e) {
0314: split.setDividerLocation(0.8);
0315: }
0316:
0317: public void componentShown(ComponentEvent e) {
0318: }
0319: });
0320:
0321: setSize(800, 400);
0322: }
0323:
0324: boolean shown = false;
0325:
0326: public void show() {
0327: super .show();
0328: viewButton.setEnabled(false);
0329: if (!shown) {
0330: split.setDividerLocation(0.8);
0331: shown = true;
0332: }
0333: }
0334:
0335: /**
0336: * Specifies a status text.
0337: * @param st a status text.
0338: */
0339: public void setStatus(String st) {
0340: status.setText(st);
0341: }
0342:
0343: /**
0344: * Method to invoke GUIBrowser from java code.
0345: */
0346: public static void showBrowser() {
0347: showBrowser(new String[0], false);
0348: }
0349:
0350: /**
0351: * Method to invoke GUIBrowser as java application.
0352: * @param argv Argument array. If not empty, first element should be<br>
0353: * main class of an aplication to be browsed.<br>
0354: * Other elements are application parameters.
0355: */
0356: public static void main(String[] argv) {
0357: showBrowser(argv, true);
0358: }
0359:
0360: private static void showBrowser(String[] argv, boolean exitNecessary) {
0361: if (argv.length >= 1) {
0362: String[] newArgv = new String[argv.length - 1];
0363: for (int i = 1; i < argv.length; i++) {
0364: newArgv[i - 1] = argv[i];
0365: }
0366: try {
0367: new ClassReference(argv[0]).startApplication(newArgv);
0368: } catch (ClassNotFoundException e) {
0369: e.printStackTrace();
0370: } catch (InvocationTargetException e) {
0371: e.printStackTrace();
0372: } catch (NoSuchMethodException e) {
0373: e.printStackTrace();
0374: }
0375: }
0376: new GUIBrowser(exitNecessary).show();
0377: }
0378:
0379: private void reload(final int delay) {
0380: viewButton.setEnabled(false);
0381: expandButton.setEnabled(false);
0382: new Thread(new Runnable() {
0383: public void run() {
0384: try {
0385: for (int i = delay - 1; i >= 0; i--) {
0386: setStatus("Reloading after "
0387: + Integer.toString(i) + " second");
0388: Thread.sleep(1000);
0389: }
0390: setStatus("Reloading ...");
0391: Dumper.dumpAll(dumpWriter);
0392: qt.lock();
0393: root = new RootNode();
0394: qt.unlock();
0395: mainTree.setModel(root.getWindowModel());
0396: setStatus("Reloaded");
0397: } catch (InterruptedException e) {
0398: }
0399: }
0400: }).start();
0401: }
0402:
0403: private JFrame getOwnr() {
0404: return (this );
0405: }
0406:
0407: private class ClassNode {
0408: Class clzz;
0409:
0410: protected ClassNode() {
0411: clzz = null;
0412: }
0413:
0414: public ClassNode(Class clzz) {
0415: this .clzz = clzz;
0416: }
0417:
0418: public ClassNode[] getSuperClasses() {
0419: int count = 0;
0420: Class parent = clzz;
0421: while ((parent = parent.getSuperclass()) != null) {
0422: count++;
0423: }
0424: Class[] interfaces = clzz.getInterfaces();
0425: ClassNode[] result = new ClassNode[count
0426: + interfaces.length + 1];
0427: result[0] = new SuperClassNode(clzz);
0428: count = 1;
0429: parent = clzz;
0430: while ((parent = parent.getSuperclass()) != null) {
0431: result[count] = new SuperClassNode(parent);
0432: count++;
0433: }
0434: for (int i = count; i < count + interfaces.length; i++) {
0435: result[i] = new InterfaceNode(interfaces[i - count]);
0436: }
0437: return (result);
0438: }
0439:
0440: public String toString() {
0441: if (clzz.isArray()) {
0442: return (clzz.getComponentType().getName() + "[]");
0443: } else {
0444: return (clzz.getName());
0445: }
0446: }
0447:
0448: public TreeModel getMethodsModel() {
0449: return (new ClassModel(this ));
0450: }
0451:
0452: public ClassNode[] getSubNodes() {
0453: Vector res = new Vector();
0454: Field[] fields = clzz.getFields();
0455: Arrays.sort(fields, new Comparator() {
0456: public int compare(Object o1, Object o2) {
0457: return (((Field) o1).getName()
0458: .compareTo(((Field) o2).getName()));
0459: }
0460: });
0461: Method[] mtds = clzz.getMethods();
0462: Arrays.sort(mtds, new Comparator() {
0463: public int compare(Object o1, Object o2) {
0464: return (((Method) o1).getName()
0465: .compareTo(((Method) o2).getName()));
0466: }
0467: });
0468: for (int i = 0; i < fields.length; i++) {
0469: if (fields[i].getDeclaringClass().getName().equals(
0470: clzz.getName())) {
0471: res.add(new FieldNode(fields[i]));
0472: }
0473: }
0474: for (int i = 0; i < mtds.length; i++) {
0475: if (mtds[i].getDeclaringClass().getName().equals(
0476: clzz.getName())) {
0477: res.add(new MethodNode(mtds[i]));
0478: }
0479: }
0480: ClassNode[] result = new ClassNode[res.size()];
0481: for (int i = 0; i < result.length; i++) {
0482: result[i] = (ClassNode) res.get(i);
0483: }
0484: return (result);
0485: }
0486: }
0487:
0488: private class SuperClassNode extends ClassNode {
0489: protected SuperClassNode() {
0490: super ();
0491: }
0492:
0493: public SuperClassNode(Class clzz) {
0494: super (clzz);
0495: }
0496:
0497: public String toString() {
0498: return ("Class: " + super .toString());
0499: }
0500: }
0501:
0502: private class InterfaceNode extends ClassNode {
0503: protected InterfaceNode() {
0504: super ();
0505: }
0506:
0507: public InterfaceNode(Class clzz) {
0508: super (clzz);
0509: }
0510:
0511: public String toString() {
0512: return ("Interfac: " + super .toString());
0513: }
0514: }
0515:
0516: private class FieldNode extends ClassNode {
0517: Field field;
0518:
0519: public FieldNode(Field fld) {
0520: super (fld.getType());
0521: field = fld;
0522: }
0523:
0524: public String toString() {
0525: return ("Field: " + Modifier.toString(field.getModifiers())
0526: + " " + super .toString() + " " + field.getName());
0527: }
0528: }
0529:
0530: private class MethodNode extends ClassNode {
0531: Method method;
0532:
0533: public MethodNode(Method mtd) {
0534: super (mtd.getReturnType());
0535: method = mtd;
0536: }
0537:
0538: public String toString() {
0539: return ("Method: "
0540: + Modifier.toString(method.getModifiers()) + " "
0541: + super .toString() + " " + method.getName());
0542:
0543: }
0544:
0545: public ClassNode[] getParameters() {
0546: Class[] ptps = method.getParameterTypes();
0547: ClassNode[] result = new ClassNode[ptps.length];
0548: for (int i = 0; i < ptps.length; i++) {
0549: result[i] = new ClassNode(ptps[i]);
0550: }
0551: return (result);
0552: }
0553: }
0554:
0555: private class ComponentNode extends ClassNode {
0556: protected Hashtable props;
0557: protected String clss = "";
0558: protected String compToString = "";
0559: Component comp;
0560: ComponentImageProvider image;
0561: protected int x, y, w, h;
0562:
0563: protected ComponentNode() {
0564: props = new Hashtable();
0565: }
0566:
0567: public ComponentNode(Component comp) {
0568: super (comp.getClass());
0569: props = Operator.createOperator(comp).getDump();
0570: clss = comp.getClass().getName();
0571: compToString = comp.toString();
0572: this .comp = comp;
0573: x = comp.getLocationOnScreen().x;
0574: y = comp.getLocationOnScreen().y;
0575: w = comp.getWidth();
0576: h = comp.getHeight();
0577: }
0578:
0579: public String toString() {
0580: return (clss);
0581: }
0582:
0583: public Hashtable getProperties() {
0584: return (props);
0585: }
0586:
0587: public String getToString() {
0588: return (compToString);
0589: }
0590:
0591: public void setComponentImageProvider(
0592: ComponentImageProvider provider) {
0593: image = provider;
0594: }
0595:
0596: public BufferedImage getImage() {
0597: if (image != null) {
0598: return (image.getImage(x, y, w, h));
0599: } else {
0600: return (null);
0601: }
0602: }
0603: }
0604:
0605: private class ContainerNode extends ComponentNode {
0606: protected ComponentNode[] comps;
0607:
0608: protected ContainerNode() {
0609: super ();
0610: comps = new ComponentNode[0];
0611: }
0612:
0613: public ContainerNode(Container comp) {
0614: super (comp);
0615: Component[] cmps = comp.getComponents();
0616: Vector wwns = new Vector();
0617: for (int i = 0; i < cmps.length; i++) {
0618: if (cmps[i] != null
0619: && (propDialog.showAll || cmps[i].isVisible())) {
0620: if (cmps[i] instanceof Container) {
0621: wwns
0622: .add(new ContainerNode(
0623: (Container) cmps[i]));
0624: } else {
0625: wwns.add(new ComponentNode(cmps[i]));
0626: }
0627: }
0628: }
0629: comps = new ComponentNode[wwns.size()];
0630: for (int i = 0; i < wwns.size(); i++) {
0631: comps[i] = (ComponentNode) wwns.get(i);
0632: }
0633: }
0634:
0635: public ComponentNode[] getComponents() {
0636: return (comps);
0637: }
0638:
0639: public int getComponentIndex(ComponentNode comp) {
0640: for (int i = 0; i < comps.length; i++) {
0641: if (comps[i].equals(comp)) {
0642: return (i);
0643: }
0644: }
0645: return (-1);
0646: }
0647:
0648: public void setComponentImageProvider(
0649: ComponentImageProvider provider) {
0650: super .setComponentImageProvider(provider);
0651: for (int i = 0; i < comps.length; i++) {
0652: comps[i].setComponentImageProvider(provider);
0653: }
0654: }
0655:
0656: public ComponentModel getComponentModel() {
0657: return (new ComponentModel(this ));
0658: }
0659: }
0660:
0661: private class WindowNode extends ContainerNode {
0662: protected WindowNode[] wins;
0663: String title;
0664:
0665: protected WindowNode() {
0666: super ();
0667: wins = new WindowNode[0];
0668: title = "All Frames";
0669: clss = "";
0670: }
0671:
0672: public WindowNode(Window win) {
0673: super (win);
0674: Window[] wns = win.getOwnedWindows();
0675: Vector wwns = new Vector();
0676: for (int i = 0; i < wns.length; i++) {
0677: if (propDialog.showAll || wns[i].isVisible()) {
0678: wwns.add(new WindowNode(wns[i]));
0679: }
0680: }
0681: wins = new WindowNode[wwns.size()];
0682: for (int i = 0; i < wwns.size(); i++) {
0683: wins[i] = (WindowNode) wwns.get(i);
0684: }
0685: title = win.toString();
0686: clss = win.getClass().getName();
0687: BufferedImage image = null;
0688: try {
0689: image = new Robot().createScreenCapture(new Rectangle(
0690: win.getLocationOnScreen(), win.getSize()));
0691: } catch (AWTException e) {
0692: e.printStackTrace();
0693: }
0694: setComponentImageProvider(new ComponentImageProvider(image,
0695: x, y));
0696: }
0697:
0698: public WindowNode[] getWindows() {
0699: return (wins);
0700: }
0701:
0702: public int getWindowIndex(WindowNode node) {
0703: for (int i = 0; i < wins.length; i++) {
0704: if (wins[i].equals(node)) {
0705: return (i);
0706: }
0707: }
0708: return (-1);
0709: }
0710:
0711: public WindowModel getWindowModel() {
0712: return (new WindowModel(this ));
0713: }
0714:
0715: public String toString() {
0716: return (clss + " \"" + title + "\"");
0717: }
0718: }
0719:
0720: private class RootNode extends WindowNode {
0721: public RootNode() {
0722: super ();
0723: Window[] wns = Frame.getFrames();
0724: wins = new WindowNode[wns.length];
0725: int count = 0;
0726: for (int i = 0; i < wns.length; i++) {
0727: if (propDialog.showAll || wns[i].isVisible()) {
0728: count++;
0729: }
0730: }
0731: wins = new WindowNode[count];
0732: count = 0;
0733: for (int i = 0; i < wns.length; i++) {
0734: if (propDialog.showAll || wns[i].isVisible()) {
0735: wins[count] = new WindowNode(wns[i]);
0736: count++;
0737: }
0738: }
0739: }
0740: }
0741:
0742: private class ClassModel implements TreeModel {
0743: ClassNode clsn;
0744:
0745: ClassModel(ClassNode clsn) {
0746: this .clsn = clsn;
0747: }
0748:
0749: public void addTreeModelListener(TreeModelListener l) {
0750: }
0751:
0752: public Object getChild(Object parent, int index) {
0753: if (parent == clsn) {
0754: return (clsn.getSuperClasses()[index]);
0755: } else if (parent instanceof SuperClassNode
0756: || parent instanceof InterfaceNode) {
0757: return (((ClassNode) parent).getSubNodes()[index]);
0758: } else if (parent instanceof MethodNode) {
0759: return (((MethodNode) parent).getParameters()[index]);
0760: }
0761: return (null);
0762: }
0763:
0764: public int getChildCount(Object parent) {
0765: if (parent == clsn) {
0766: return (clsn.getSuperClasses().length);
0767: } else if (parent instanceof SuperClassNode
0768: || parent instanceof InterfaceNode) {
0769: return (((ClassNode) parent).getSubNodes().length);
0770: } else if (parent instanceof MethodNode) {
0771: return (((MethodNode) parent).getParameters().length);
0772: }
0773: return (0);
0774: }
0775:
0776: public int getIndexOfChild(Object parent, Object child) {
0777: if (parent == clsn || parent instanceof MethodNode
0778: || parent instanceof SuperClassNode
0779: || parent instanceof InterfaceNode) {
0780: Object[] children;
0781: if (parent instanceof SuperClassNode
0782: || parent instanceof InterfaceNode) {
0783: children = ((ClassNode) parent).getSuperClasses();
0784: } else if (parent instanceof MethodNode) {
0785: children = ((MethodNode) parent).getParameters();
0786: } else {
0787: children = clsn.getSuperClasses();
0788: }
0789: for (int i = 0; i < children.length; i++) {
0790: if (children.equals(child)) {
0791: return (i);
0792: }
0793: }
0794: }
0795: return (0);
0796: }
0797:
0798: public Object getRoot() {
0799: return (clsn);
0800: }
0801:
0802: public boolean isLeaf(Object node) {
0803: return (getChildCount(node) == 0);
0804: }
0805:
0806: public void removeTreeModelListener(TreeModelListener l) {
0807: }
0808:
0809: public void valueForPathChanged(TreePath path, Object newValue) {
0810: }
0811: }
0812:
0813: private class WindowModel implements TreeModel {
0814: WindowNode win;
0815:
0816: WindowModel(WindowNode win) {
0817: this .win = win;
0818: }
0819:
0820: public void addTreeModelListener(TreeModelListener l) {
0821: }
0822:
0823: public Object getChild(Object parent, int index) {
0824: return (((WindowNode) parent).getWindows()[index]);
0825: }
0826:
0827: public int getChildCount(Object parent) {
0828: return (((WindowNode) parent).getWindows().length);
0829: }
0830:
0831: public int getIndexOfChild(Object parent, Object child) {
0832: return (((WindowNode) parent)
0833: .getWindowIndex((WindowNode) child));
0834: }
0835:
0836: public Object getRoot() {
0837: return (win);
0838: }
0839:
0840: public boolean isLeaf(Object node) {
0841: return (((WindowNode) node).getWindows().length == 0);
0842: }
0843:
0844: public void removeTreeModelListener(TreeModelListener l) {
0845: }
0846:
0847: public void valueForPathChanged(TreePath path, Object newValue) {
0848: }
0849: }
0850:
0851: private class ComponentModel implements TreeModel {
0852: ContainerNode cont;
0853:
0854: ComponentModel(ContainerNode cont) {
0855: this .cont = cont;
0856: }
0857:
0858: public void addTreeModelListener(TreeModelListener l) {
0859: }
0860:
0861: public Object getChild(Object parent, int index) {
0862: if (parent instanceof ContainerNode) {
0863: return (((ContainerNode) parent).getComponents()[index]);
0864: } else {
0865: return ("");
0866: }
0867: }
0868:
0869: public int getChildCount(Object parent) {
0870: if (parent instanceof ContainerNode) {
0871: return (((ContainerNode) parent).getComponents().length);
0872: } else {
0873: return (0);
0874: }
0875: }
0876:
0877: public int getIndexOfChild(Object parent, Object child) {
0878: if (parent instanceof ContainerNode) {
0879: return (((ContainerNode) parent)
0880: .getComponentIndex((ComponentNode) child));
0881: } else {
0882: return (-1);
0883: }
0884: }
0885:
0886: public Object getRoot() {
0887: return (cont);
0888: }
0889:
0890: public boolean isLeaf(Object node) {
0891: if (node instanceof ContainerNode) {
0892: return (((ContainerNode) node).getComponents().length == 0);
0893: } else {
0894: return (true);
0895: }
0896: }
0897:
0898: public void removeTreeModelListener(TreeModelListener l) {
0899: }
0900:
0901: public void valueForPathChanged(TreePath path, Object newValue) {
0902: }
0903: }
0904:
0905: private class WindowRenderer implements TreeCellRenderer,
0906: ListCellRenderer {
0907: public WindowRenderer() {
0908: }
0909:
0910: public Component getTreeCellRendererComponent(JTree tree,
0911: Object value, boolean selected, boolean expanded,
0912: boolean leaf, int row, boolean hasFocus) {
0913: return (get(value, selected));
0914: }
0915:
0916: public Component getListCellRendererComponent(JList list,
0917: Object value, int index, boolean isSelected,
0918: boolean cellHasFocus) {
0919: return (get(value, isSelected));
0920: }
0921:
0922: private Component get(Object value, boolean selected) {
0923: Component result = new JLabel(((ClassNode) value)
0924: .toString());
0925: if (selected) {
0926: result.setBackground(Color.blue);
0927: result.setForeground(Color.white);
0928: JPanel resPane = new JPanel();
0929: resPane.setLayout(new BorderLayout());
0930: resPane.add(result, BorderLayout.CENTER);
0931: return (resPane);
0932: } else {
0933: return (result);
0934: }
0935: }
0936: }
0937:
0938: private class PropertyDialog extends JDialog {
0939: public boolean showAll = false;
0940: JComboBox visibleCombo;
0941: JCheckBox showToString;
0942: JCheckBox showReflection;
0943: JCheckBox showEvents;
0944: DefaultListModel viewTabs;
0945: JList orderList;
0946: JButton up;
0947: JButton down;
0948: Properties props;
0949: File propFile;
0950:
0951: public PropertyDialog(JFrame owner) {
0952: super (owner, "Properties", true);
0953:
0954: propFile = new File(System.getProperty("user.home")
0955: + System.getProperty("file.separator")
0956: + ".guibrowser");
0957:
0958: props = new Properties();
0959:
0960: String[] cpItems = { "Showing", "All" };
0961: visibleCombo = new JComboBox(cpItems);
0962: visibleCombo.addActionListener(new ActionListener() {
0963: public void actionPerformed(ActionEvent e) {
0964: showAll = (visibleCombo.getSelectedIndex() == 1);
0965: }
0966: });
0967:
0968: JPanel visiblePane = new JPanel();
0969: visiblePane.add(new JLabel("Show "));
0970: visiblePane.add(visibleCombo);
0971:
0972: showToString = new JCheckBox(
0973: "Show toString() method result");
0974: showToString.setSelected(true);
0975:
0976: JPanel compTreePane = new JPanel();
0977: compTreePane.add(visiblePane);
0978:
0979: viewTabs = new DefaultListModel();
0980: viewTabs.addElement(WINDOWS_TAB);
0981: viewTabs.addElement(COMPONENTS_TAB);
0982: viewTabs.addElement(PROPERTIES_TAB);
0983: viewTabs.addElement(REFLECTION_TAB);
0984: viewTabs.addElement(IMAGE_TAB);
0985:
0986: orderList = new JList(viewTabs);
0987: orderList
0988: .addListSelectionListener(new ListSelectionListener() {
0989: public void valueChanged(ListSelectionEvent e) {
0990: up
0991: .setEnabled(orderList
0992: .getSelectedIndex() > -1);
0993: down.setEnabled(orderList
0994: .getSelectedIndex() > -1);
0995: }
0996: });
0997:
0998: showReflection = new JCheckBox("Show reflection tab");
0999: showReflection.setSelected(true);
1000: showReflection.addActionListener(new ActionListener() {
1001: public void actionPerformed(ActionEvent e) {
1002: if (showReflection.isSelected()) {
1003: viewTabs.addElement(REFLECTION_TAB);
1004: } else {
1005: viewTabs.remove(viewTabs
1006: .indexOf(REFLECTION_TAB));
1007: }
1008: up.setEnabled(orderList.getSelectedIndex() > -1);
1009: down.setEnabled(orderList.getSelectedIndex() > -1);
1010: }
1011: });
1012:
1013: showEvents = new JCheckBox("Show event tab");
1014: showEvents.setSelected(true);
1015: showEvents.addActionListener(new ActionListener() {
1016: public void actionPerformed(ActionEvent e) {
1017: if (showEvents.isSelected()) {
1018: viewTabs.addElement(EVENT_TAB);
1019: } else {
1020: viewTabs.remove(viewTabs.indexOf(EVENT_TAB));
1021: }
1022: up.setEnabled(orderList.getSelectedIndex() > -1);
1023: down.setEnabled(orderList.getSelectedIndex() > -1);
1024: }
1025: });
1026:
1027: up = new JButton("Move Up");
1028: up.setEnabled(false);
1029: up.addActionListener(new ActionListener() {
1030: public void actionPerformed(ActionEvent e) {
1031: int index = orderList.getSelectedIndex();
1032: if (index > 0) {
1033: viewTabs.add(index - 1, viewTabs.remove(index));
1034: orderList.setSelectedIndex(index - 1);
1035: }
1036: }
1037: });
1038:
1039: down = new JButton("Move Down");
1040: down.setEnabled(false);
1041: down.addActionListener(new ActionListener() {
1042: public void actionPerformed(ActionEvent e) {
1043: int index = orderList.getSelectedIndex();
1044: if (index < viewTabs.size() - 1) {
1045: viewTabs.add(index + 1, viewTabs.remove(index));
1046: orderList.setSelectedIndex(index + 1);
1047: }
1048: }
1049: });
1050:
1051: JPanel movePane = new JPanel();
1052: movePane.add(showEvents);
1053: movePane.add(showReflection);
1054: movePane.add(up);
1055: movePane.add(down);
1056:
1057: JPanel compViewPane = new JPanel();
1058: compViewPane.setLayout(new BorderLayout());
1059: compViewPane.add(new JLabel("Tab order:"),
1060: BorderLayout.NORTH);
1061: compViewPane.add(movePane, BorderLayout.SOUTH);
1062: compViewPane.add(orderList, BorderLayout.CENTER);
1063:
1064: JTabbedPane tbpn = new JTabbedPane();
1065: tbpn.add("Component Tree", compTreePane);
1066: tbpn.add("Component View", compViewPane);
1067:
1068: JButton okBUtton = new JButton("OK");
1069: okBUtton.addActionListener(new ActionListener() {
1070: public void actionPerformed(ActionEvent e) {
1071: save();
1072: setVisible(false);
1073: }
1074: });
1075:
1076: JButton cnBUtton = new JButton("Cancel");
1077: cnBUtton.addActionListener(new ActionListener() {
1078: public void actionPerformed(ActionEvent e) {
1079: setVisible(false);
1080: load();
1081: }
1082: });
1083:
1084: JPanel pn = new JPanel();
1085: pn.add(okBUtton);
1086: pn.add(cnBUtton);
1087:
1088: getContentPane().setLayout(new BorderLayout());
1089: getContentPane().add(pn, BorderLayout.SOUTH);
1090: getContentPane().add(tbpn, BorderLayout.CENTER);
1091:
1092: load();
1093:
1094: setSize(400, 400);
1095: }
1096:
1097: private void save() {
1098: try {
1099: props.setProperty("guibrowser.showall", showAll ? "on"
1100: : "off");
1101: for (int i = 0; i < viewTabs.size(); i++) {
1102: props.setProperty("guibrowser.viewpage_"
1103: + Integer.toString(i), (String) viewTabs
1104: .elementAt(i));
1105: }
1106: props.store(new FileOutputStream(propFile),
1107: "Jemmy GUIBrowser");
1108: } catch (IOException e) {
1109: e.printStackTrace();
1110: }
1111: }
1112:
1113: private void load() {
1114: if (propFile.exists()) {
1115: try {
1116: props.load(new FileInputStream(propFile));
1117: showAll = props.getProperty("guibrowser.showall") == null
1118: || props.getProperty("guibrowser.showall")
1119: .equals("")
1120: || props.getProperty("guibrowser.showall")
1121: .equals("on");
1122: visibleCombo.setSelectedIndex(showAll ? 1 : 0);
1123: if (props.getProperty("guibrowser.viewpage_0") != null
1124: && !props.getProperty(
1125: "guibrowser.viewpage_0").equals("")) {
1126: viewTabs.removeAllElements();
1127: viewTabs.addElement(props
1128: .getProperty("guibrowser.viewpage_0"));
1129: viewTabs.addElement(props
1130: .getProperty("guibrowser.viewpage_1"));
1131: viewTabs.addElement(props
1132: .getProperty("guibrowser.viewpage_2"));
1133: if (props.getProperty("guibrowser.viewpage_3") != null
1134: && !props.getProperty(
1135: "guibrowser.viewpage_3")
1136: .equals("")) {
1137: viewTabs
1138: .addElement(props
1139: .getProperty("guibrowser.viewpage_3"));
1140: }
1141: if (props.getProperty("guibrowser.viewpage_4") != null
1142: && !props.getProperty(
1143: "guibrowser.viewpage_4")
1144: .equals("")) {
1145: viewTabs
1146: .addElement(props
1147: .getProperty("guibrowser.viewpage_4"));
1148: }
1149: }
1150: } catch (IOException e) {
1151: e.printStackTrace();
1152: }
1153: showReflection.setSelected(viewTabs
1154: .indexOf(REFLECTION_TAB) > -1);
1155: showEvents
1156: .setSelected(viewTabs.indexOf(EVENT_TAB) > -1);
1157: }
1158: }
1159: }
1160:
1161: private class ComponentBrowser extends JFrame {
1162:
1163: JTree winTree;
1164: JTree componentTree;
1165: JTree methodTree;
1166: ClassNode compNode;
1167: JTabbedPane tbd;
1168: JList fList;
1169: JButton viewButton;
1170: JButton expandButton;
1171: JSplitPane winSplit = null;
1172: JSplitPane componentSplit = null;
1173: WindowRenderer renderer;
1174: SelectionManager selManager;
1175: JList eventList;
1176: ListListener listListener;
1177: DefaultListModel eventModel;
1178: JCheckBox mouseEvents;
1179: JCheckBox mouseMotionEvents;
1180: JCheckBox keyEvents;
1181:
1182: public ComponentBrowser(JFrame owner, ClassNode componentNode) {
1183: super ("Component " + componentNode.toString());
1184: fill(componentNode);
1185: }
1186:
1187: public ComponentBrowser(JDialog owner, ClassNode componentNode) {
1188: super ("Component " + componentNode.toString());
1189: fill(componentNode);
1190: }
1191:
1192: private void fill(ClassNode componentNode) {
1193: compNode = componentNode;
1194:
1195: viewButton = new JButton("View");
1196: viewButton.setEnabled(false);
1197: viewButton.addActionListener(new ActionListener() {
1198: public void actionPerformed(ActionEvent e) {
1199: new ComponentBrowser(getOwnr(), getSelectedNode())
1200: .show();
1201: }
1202: });
1203:
1204: expandButton = new JButton("Expand All");
1205: expandButton.setEnabled(false);
1206: expandButton.addActionListener(new ActionListener() {
1207: public void actionPerformed(ActionEvent e) {
1208: expandAll(getSelectedTree(), getSelectionPath());
1209: }
1210: });
1211:
1212: JPanel buttonPane = new JPanel();
1213: buttonPane.add(viewButton);
1214: buttonPane.add(expandButton);
1215:
1216: Component[] cpss = { viewButton, expandButton };
1217: selManager = new SelectionManager(cpss);
1218: renderer = new WindowRenderer();
1219:
1220: tbd = new JTabbedPane();
1221:
1222: for (int i = 0; i < propDialog.viewTabs.size(); i++) {
1223: String next = (String) propDialog.viewTabs.elementAt(i);
1224: if (next.equals(PROPERTIES_TAB)) {
1225: addPropertiesTab();
1226: } else if (next.equals(WINDOWS_TAB)) {
1227: addWindowTab();
1228: } else if (next.equals(COMPONENTS_TAB)) {
1229: addComponentTab();
1230: } else if (next.equals(REFLECTION_TAB)) {
1231: addReflectionTab();
1232: } else if (next.equals(EVENT_TAB)) {
1233: addEventTab();
1234: } else if (next.equals(IMAGE_TAB)) {
1235: addImageTab();
1236: }
1237: }
1238:
1239: tbd.addChangeListener(new ChangeListener() {
1240: public void stateChanged(ChangeEvent e) {
1241: viewButton.setEnabled(getSelectedNode() != null);
1242: }
1243: });
1244:
1245: getContentPane().setLayout(new BorderLayout());
1246: getContentPane().add(buttonPane, BorderLayout.SOUTH);
1247: getContentPane().add(tbd, BorderLayout.CENTER);
1248:
1249: addComponentListener(new ComponentListener() {
1250: public void componentHidden(ComponentEvent e) {
1251: }
1252:
1253: public void componentMoved(ComponentEvent e) {
1254: }
1255:
1256: public void componentResized(ComponentEvent e) {
1257: if (winSplit != null) {
1258: winSplit.setDividerLocation(0.8);
1259: }
1260: if (componentSplit != null) {
1261: componentSplit.setDividerLocation(0.8);
1262: }
1263: }
1264:
1265: public void componentShown(ComponentEvent e) {
1266: }
1267: });
1268:
1269: setSize(800, 400);
1270: }
1271:
1272: private void addImageTab() {
1273: BufferedImage image = null;
1274: if (compNode instanceof ComponentNode) {
1275: image = ((ComponentNode) compNode).getImage();
1276: }
1277: if (image != null) {
1278: JPanel imagePane = new ImagePane(image);
1279: imagePane.prepareImage(image, imagePane);
1280: JScrollPane pane = new JScrollPane(imagePane);
1281: tbd.add(IMAGE_TAB, pane);
1282: }
1283: }
1284:
1285: private void addWindowTab() {
1286: if (compNode instanceof WindowNode
1287: && ((WindowNode) compNode).getWindows().length > 0) {
1288: winTree = new JTree(((WindowNode) compNode)
1289: .getWindowModel());
1290: winTree.setCellRenderer(renderer);
1291: winTree.setEditable(false);
1292: winTree.addTreeSelectionListener(selManager);
1293: winSplit = createUnderPane(winTree);
1294: tbd.add(WINDOWS_TAB, winSplit);
1295: }
1296:
1297: }
1298:
1299: private void addComponentTab() {
1300: if (compNode instanceof ContainerNode
1301: && ((ContainerNode) compNode).getComponents().length > 0) {
1302: componentTree = new JTree(((ContainerNode) compNode)
1303: .getComponentModel());
1304: componentTree.setCellRenderer(renderer);
1305: componentTree.setEditable(false);
1306: componentTree.addTreeSelectionListener(selManager);
1307: componentSplit = createUnderPane(componentTree);
1308: tbd.add(COMPONENTS_TAB, componentSplit);
1309: }
1310:
1311: }
1312:
1313: private void addReflectionTab() {
1314: methodTree = new JTree(compNode.getMethodsModel());
1315: methodTree.setCellRenderer(renderer);
1316: methodTree.setEditable(false);
1317: methodTree.addTreeSelectionListener(selManager);
1318: tbd.add(REFLECTION_TAB, new JScrollPane(methodTree));
1319: }
1320:
1321: private void addPropertiesTab() {
1322: if (compNode instanceof ComponentNode) {
1323: Hashtable props = ((ContainerNode) compNode)
1324: .getProperties();
1325: if (props.size() > 0) {
1326: JTable propTable = new JTable(new MyModel(props));
1327: propTable
1328: .setAutoResizeMode(JTable.AUTO_RESIZE_LAST_COLUMN);
1329: tbd.add(PROPERTIES_TAB, new JScrollPane(propTable));
1330: /*
1331: propTable.addMouseListener(new MouseListener() {
1332: public void mouseClicked(MouseEvent e) {
1333: new ComponentBrowser(getOwnr(),
1334: getSelectedNode()).
1335: show();
1336: }
1337: public void mouseExited(MouseEvent e) {
1338: }
1339: public void mouseEntered(MouseEvent e) {
1340: }
1341: public void mousePressed(MouseEvent e) {
1342: }
1343: public void mouseReleased(MouseEvent e) {
1344: }
1345: });
1346: */
1347: }
1348: }
1349: }
1350:
1351: private void addEventTab() {
1352: if (compNode instanceof ComponentNode) {
1353: eventModel = new DefaultListModel();
1354: eventList = new JList(eventModel);
1355: listListener = new ListListener(eventModel,
1356: ((ComponentNode) compNode).comp);
1357: mouseEvents = new JCheckBox("Mouse events");
1358: mouseEvents.addActionListener(new ActionListener() {
1359: public void actionPerformed(ActionEvent e) {
1360: if (mouseEvents.isSelected()) {
1361: listListener.addMouseListener();
1362: } else {
1363: listListener.removeMouseListener();
1364: }
1365: }
1366: });
1367: mouseMotionEvents = new JCheckBox("Mouse motion events");
1368: mouseMotionEvents
1369: .addActionListener(new ActionListener() {
1370: public void actionPerformed(ActionEvent e) {
1371: if (mouseMotionEvents.isSelected()) {
1372: listListener
1373: .addMouseMotionListener();
1374: } else {
1375: listListener
1376: .removeMouseMotionListener();
1377: }
1378: }
1379: });
1380: keyEvents = new JCheckBox("Key events");
1381: keyEvents.addActionListener(new ActionListener() {
1382: public void actionPerformed(ActionEvent e) {
1383: if (keyEvents.isSelected()) {
1384: listListener.addKeyListener();
1385: } else {
1386: listListener.removeKeyListener();
1387: }
1388: }
1389: });
1390: JButton clear = new JButton("Clear list");
1391: clear.addActionListener(new ActionListener() {
1392: public void actionPerformed(ActionEvent e) {
1393: eventModel.removeAllElements();
1394: }
1395: });
1396: JPanel checkPane = new JPanel();
1397: checkPane.add(mouseEvents);
1398: checkPane.add(mouseMotionEvents);
1399: checkPane.add(keyEvents);
1400: checkPane.add(clear);
1401: JPanel subPane = new JPanel();
1402: subPane.setLayout(new BorderLayout());
1403: subPane.add(checkPane, BorderLayout.SOUTH);
1404: subPane.add(new JScrollPane(eventList),
1405: BorderLayout.CENTER);
1406: tbd.add(EVENT_TAB, subPane);
1407: }
1408: }
1409:
1410: private JFrame getOwnr() {
1411: return (this );
1412: }
1413:
1414: private JTree getSelectedTree() {
1415: String title = tbd.getTitleAt(tbd.getSelectedIndex());
1416: if (title.equals(WINDOWS_TAB)) {
1417: return (winTree);
1418: } else if (title.equals(COMPONENTS_TAB)) {
1419: return (componentTree);
1420: } else if (title.equals(REFLECTION_TAB)) {
1421: return (methodTree);
1422: }
1423: return (null);
1424: }
1425:
1426: private TreePath getSelectionPath() {
1427: JTree tree = getSelectedTree();
1428: if (tree != null) {
1429: return (tree.getSelectionPath());
1430: } else {
1431: return (null);
1432: }
1433: }
1434:
1435: private ClassNode getSelectedNode() {
1436: TreePath path = getSelectionPath();
1437: if (path != null) {
1438: return ((ClassNode) path.getLastPathComponent());
1439: } else {
1440: return (null);
1441: }
1442: }
1443:
1444: }
1445:
1446: private class SelectionManager implements TreeSelectionListener,
1447: ListSelectionListener {
1448: Component[] comps;
1449:
1450: public SelectionManager(Component[] comps) {
1451: this .comps = comps;
1452: }
1453:
1454: public void valueChanged(TreeSelectionEvent e) {
1455: for (int i = 0; i < comps.length; i++) {
1456: comps[i].setEnabled(e.getPath() != null);
1457: }
1458: }
1459:
1460: public void valueChanged(ListSelectionEvent e) {
1461: for (int i = 0; i < comps.length; i++) {
1462: comps[i].setEnabled(e.getFirstIndex() != -1);
1463: }
1464: }
1465: }
1466:
1467: private void expandAll(JTree tree, TreePath path) {
1468: tree.expandPath(path);
1469: TreeModel model = tree.getModel();
1470: Object lastComponent = path.getLastPathComponent();
1471: for (int i = 0; i < model.getChildCount(lastComponent); i++) {
1472: expandAll(tree, path.pathByAddingChild(model.getChild(
1473: lastComponent, i)));
1474: }
1475: }
1476:
1477: private class ToStringListener implements TreeSelectionListener {
1478: JTextArea area;
1479:
1480: public ToStringListener(JTextArea area) {
1481: this .area = area;
1482: }
1483:
1484: public void valueChanged(TreeSelectionEvent e) {
1485: if (e.getPath() != null
1486: && e.getPath().getLastPathComponent() instanceof ComponentNode) {
1487: area.setText("toString(): "
1488: + ((ComponentNode) e.getPath()
1489: .getLastPathComponent()).getToString());
1490: } else {
1491: area.setText("");
1492: }
1493: }
1494: }
1495:
1496: private JSplitPane createUnderPane(JTree tree) {
1497: JTextArea toStringArea = new JTextArea();
1498: toStringArea.setLineWrap(true);
1499: toStringArea.setEditable(false);
1500: tree
1501: .addTreeSelectionListener(new ToStringListener(
1502: toStringArea));
1503: JSplitPane result = new JSplitPane(JSplitPane.VERTICAL_SPLIT,
1504: new JScrollPane(tree), new JScrollPane(toStringArea));
1505: result.setOneTouchExpandable(true);
1506: result.setDividerSize(8);
1507: result.setDividerLocation(0.8);
1508: return (result);
1509: }
1510:
1511: private class MyModel extends DefaultTableModel {
1512: public MyModel(Hashtable props) {
1513: super ();
1514: Object[] keys = props.keySet().toArray();
1515: if (keys.length > 0) {
1516: addColumn("Name");
1517: addColumn("Value");
1518: setNumRows(keys.length);
1519: for (int i = 0; i < keys.length; i++) {
1520: setValueAt(keys[i].toString(), i, 0);
1521: setValueAt(props.get(keys[i]).toString(), i, 1);
1522: }
1523: String[] titles = { "Name", "Value" };
1524: Collections.sort(getDataVector(), new Comparator() {
1525: public int compare(Object o1, Object o2) {
1526: return (((Vector) o1).get(0).toString()
1527: .compareTo(((Vector) o2).get(0)
1528: .toString()));
1529: }
1530:
1531: public boolean equals(Object obj) {
1532: return (false);
1533: }
1534: });
1535: }
1536: }
1537:
1538: public boolean isCellEditable(int x, int y) {
1539: return (false);
1540: }
1541: }
1542:
1543: private class ListListener extends TrialListenerManager {
1544: DefaultListModel model;
1545:
1546: public ListListener(DefaultListModel m, Component comp) {
1547: super (comp);
1548: model = m;
1549: }
1550:
1551: void printEvent(AWTEvent e) {
1552: model.addElement(e);
1553: }
1554: }
1555:
1556: private class ImagePane extends JPanel {
1557: BufferedImage image;
1558:
1559: public ImagePane(BufferedImage image) {
1560: super ();
1561: this .image = image;
1562: setPreferredSize(new Dimension(image.getWidth(), image
1563: .getHeight()));
1564: }
1565:
1566: public void paint(Graphics g) {
1567: g.drawImage(image, 0, 0, null);
1568: }
1569: }
1570:
1571: private class ComponentImageProvider {
1572: BufferedImage image;
1573: int x;
1574: int y;
1575:
1576: public ComponentImageProvider(BufferedImage image, int x, int y) {
1577: this .image = image;
1578: this .x = x;
1579: this .y = y;
1580: }
1581:
1582: public BufferedImage getImage(int x, int y, int w, int h) {
1583: /*
1584: BufferedImage newImage = image.getSubimage(0, 0, image.getWidth(), image.getHeight());
1585: Graphics g = newImage.getGraphics();
1586: g.setColor(Color.RED);
1587: g.drawRect(x - this.x, y - this.y, w, h);
1588: return(newImage);
1589: */
1590: return (image.getSubimage(x - this.x, y - this.y, w, h));
1591: }
1592: }
1593: }
|