+ * This class manages information about the current GUI. It always contains the current GUI + * hierarchy. + *
+ * + * @author Steffen Herbold + * @version 1.0 + */ +public class JFCComponent { + + /** + *+ * Map of all known GUI components. + *
+ */ + private static Map+ * Adds a AWT component to the GUI hierarchy. If the component already exists in the hierarchy, + * it is not added a second time. + *
+ * + * @param component + * component that is added + */ + public static void add(Component component) { + add(component, find(component.getParent())); + } + + /** + *+ * Adds a AWT component to the GUI hierarchy. If the component already exists in the hierarchy, + * it is not added a second time. + *
+ * + * @param component + * component that is added + * @param parent + * parent of the component + */ + public static void add(Component component, JFCComponent parent) { + if (!knownComponents.containsKey(component)) { + knownComponents.put(component, new JFCComponent(component, parent)); + } + } + + /** + *+ * Finds a component in the GUI hierarchy and returns the corresponding JFComponent instance. + * Returns null if the component is not found. + *
+ * + * @param component + * component that is searched for + * @return corresponding JFComponent instance; null if the compenent is not found + */ + public static JFCComponent find(Component component) { + return knownComponents.get(component); + } + + /** + *+ * Removes a component from the GUI hierarchy. In case the component is not part of the known + * hierachy, nothing happens. + *
+ * + * @param component + * component to be removed + */ + public static void remove(Component component) { + JFCComponent jfcComponent = knownComponents.remove(component); + if (jfcComponent != null) { + jfcComponent.removeFromParent(); + jfcComponent.removeChildren(); + } + } + + /** + *+ * Parent of the GUI component. null means, that the component has no parent. + *
+ */ + private JFCComponent parent = null; + + /** + *+ * Child components of the component. + *
+ */ + private List+ * Reference to the actual GUI component. + *
+ */ + private Component component; + + /** + *+ * Helper attribute that contains the title of the component. Set by {@link #setTitle()}. + *
+ */ + private String title = null; + + /** + *+ * Helper attribute that contains the class of the component. Set by {@link #setClass()}. + *
+ */ + private String componentClass = null; + + /** + *+ * Helper attribute that contains the icon of the component. Set by {@link #setIcon()}. + *
+ */ + private String icon = null; + + /** + *+ * Helper attribute that contains the icon of the component. Set by {@link #setIndex()}. + *
+ */ + private int index = -1; + + /** + *+ * Constructor. Creates a new JFCComponent. Only used internally by + * {@link #add(Component, JFCComponent)}. + *
+ * + * @param component + * component associated with the JFCComponent + * @param parent + * parent of the component; null if there is no parent + */ + private JFCComponent(Component component, JFCComponent parent) { + if (component == null) { + throw new InvalidParameterException("parameter component must not be null"); + } + this.component = component; + this.parent = parent; + if (parent != null) { + parent.addChild(this); + } + + if (component instanceof Container) { + for (Component childComponent : ((Container) component).getComponents()) { + add(childComponent, this); + } + } + } + + /** + *+ * Adds a child component to the current component. + *
+ * + * @param child + * child component to be added + */ + private void addChild(JFCComponent child) { + children.add(child); + } + + /** + *+ * Returns an XML representation of the component. + *
+ * + * @return XLM snippet + */ + public String getXML() { + setClass(); + setIcon(); + setIndex(); + setTitle(); + StringBuilder builder = new StringBuilder(); + if (parent != null) { + builder.append(parent.getXML()); + } + builder.append("+ * Removes a child component from the current component. + *
+ * + * @param child + * child component to be removed + */ + private void removeChild(JFCComponent child) { + children.remove(child); + } + + /** + *+ * Removes the component from the list of children of its parent. + *
+ */ + private void removeFromParent() { + if (parent != null) { + parent.removeChild(this); + } + } + + /** + *+ * Triggers the removals of all child components from the GUI hierarchy, i.e., calls + * {@link #remove(Component)} for all child components. + *
+ */ + private void removeChildren() { + for (JFCComponent child : children) { + remove(child.component); + } + } + + /** + *+ * Sets the {@link #title} of the component. The title is defined as follows (first in the list, + * that is not null): + *
+ * Sets the {@link #componentClass} of the component. + *
+ */ + private void setClass() { + componentClass = component.getClass().getName(); + } + + /** + *+ * Sets the {@link #icon} of the component. + *
+ */ + private void setIcon() { + icon = null; // reset icon + + Method getIconMethod; + try { + getIconMethod = component.getClass().getMethod("getIcon", new Class[0]); + if (getIconMethod != null) { + Object iconObject = getIconMethod.invoke(component, new Object[] { }); + if (iconObject != null) { + String iconPath = iconObject.toString(); + if (!iconPath.contains("@")) { + System.out.println("iconPath"); + String[] splitResult = + iconPath.split(File.separatorChar == '\\' ? "\\\\" : File.separator); + icon = splitResult[splitResult.length - 1]; + } + } + } + } + catch (SecurityException e) {} + catch (NoSuchMethodException e) {} + catch (IllegalArgumentException e) {} + catch (IllegalAccessException e) {} + catch (InvocationTargetException e) { + System.err.println("Found method with name " + "getIcon" + " but could not access it."); + } + } + + /** + *+ * Sets the {@link #index} of the component as the index in the parent, if it is accessible. + *
+ */ + private void setIndex() { + index = -1; // reset index + + AccessibleContext accessibleContext = component.getAccessibleContext(); + if (accessibleContext != null) { + index = accessibleContext.getAccessibleIndexInParent(); + } + } + +} Index: trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/JFCListener.java =================================================================== --- trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/JFCListener.java (revision 823) +++ trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/JFCListener.java (revision 823) @@ -0,0 +1,149 @@ + +package de.ugoe.cs.eventbench.jfcmonitor; + +import java.awt.AWTEvent; +import java.awt.Component; +import java.awt.event.AWTEventListener; +import java.awt.event.FocusEvent; +import java.awt.event.KeyEvent; +import java.awt.event.MouseEvent; +import java.io.IOException; +import java.io.OutputStreamWriter; + +import de.ugoe.cs.util.StringTools; + +/** + *+ * This class implements monitoring of AWT and Swing mouse and keyboard events. Each of the events + * is written to an output stream. + *
+ * + * @author Steffen Herbold + * @version 1.0 + */ +public class JFCListener implements AWTEventListener { + + /** + *+ * Writer for logging events. + *
+ */ + final private OutputStreamWriter outputWriter; + + /** + *+ * Constructor. Creates a new JFCListener with a given {@link OutputStreamWriter}, where the + * monitored information is logged. + *
+ * + * @param outputWriter + * writer for the logged information + */ + public JFCListener(OutputStreamWriter outputWriter) { + this.outputWriter = outputWriter; + try { + outputWriter.write("" + StringTools.ENDLINE); + outputWriter.write("+ * Writes all received {@link MouseEvent}s and {@link KeyEvent}s to the {@link #outputWriter}. + *
+ * + * @see java.awt.event.AWTEventListener#eventDispatched(java.awt.AWTEvent) + */ + @Override + public void eventDispatched(AWTEvent event) { + StringBuilder builder = new StringBuilder(); + + if (event instanceof MouseEvent) { + if (!isMouseMovement(event.getID())) { + MouseEvent mouseEvent = (MouseEvent) event; + builder.append("+ * Appends information about the event to a {@link StringBuilder}. + *
+ * + * @param builder + * {@link StringBuilder} where the information is appended + * @param event + * event whose information is appended + */ + private void addSourceInfo(StringBuilder builder, AWTEvent event) { + builder.append("+ * Checks if the Id of an {@link AWTEvent} is a mouse movement Id. + *
+ * + * @param eventId + * id of the {@link AWTEvent} + * @return true, if the event is a mouse movement event; false otherwise + */ + private boolean isMouseMovement(int eventId) { + return eventId == MouseEvent.MOUSE_MOVED || eventId == MouseEvent.MOUSE_DRAGGED || + eventId == MouseEvent.MOUSE_ENTERED || eventId == MouseEvent.MOUSE_EXITED; + } + +} Index: trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/JarLauncher.java =================================================================== --- trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/JarLauncher.java (revision 823) +++ trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/JarLauncher.java (revision 823) @@ -0,0 +1,271 @@ + +package de.ugoe.cs.eventbench.jfcmonitor; + +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.Arrays; +import java.util.jar.JarInputStream; +import java.util.jar.Manifest; + +/** + *+ * Class that launches an executable Jar-file in the same thread and VM where the JarLauncher + * instance is created. The requirements on the Jar file are: + *
+ * Name of the Jar file to be executed. + *
+ */ + private String jarfile; + + /** + *+ * Arguments for launching the Jar file. + *
+ */ + private String[] args; + + /** + *+ * Helper variable with the path to the working directory. + *
+ */ + final String workingDir = System.getProperty("user.dir") + "/"; + + /** + *+ * Internal variable used to store the classpath extracted from the Jar file's MANIFEST. + *
+ */ + private String[] classPath = new String[] { }; + + /** + *+ * Internal variable used to store the name (including package information) of the Jar file's + * main function extracted from the Jar file's MANIFEST. + *
+ */ + private String mainClassName = ""; + + /** + *+ * Inner class that defines an exception that is thrown if launching the application in the Jar + * file fails. + *
+ * + * @author Steffen Herbold + * @version 1.0 + */ + private static class JarLaunchException extends Exception { + + /** + *+ * Id for object serialization. + *
+ */ + private static final long serialVersionUID = 1L; + + /** + *+ * Constructor. Creates a new JarLaunchException. + *
+ * + * @param string + * error message of the exception + */ + public JarLaunchException(String string) { + super(string); + } + + /** + *+ * Constructor. Creates a new JarLaunchException as a copy of an existing exception. + *
+ * + * @param e + * exception that is copied + */ + public JarLaunchException(Exception e) { + super(e); + } + + } + + /** + *+ * Constructor. Creates a new JarLauncher. + *
+ * + * @param jarfile + * file to be launched; must not be complete path but in relation to the current + * working directory + * @param args + * arguments with which the main function of the Jar file is called + */ + public JarLauncher(String jarfile, String[] args) { + this.jarfile = jarfile; + this.args = Arrays.copyOf(args, args.length); + } + + /** + *+ * Executes the main function of the Jar file associated with this launcher. + *
+ */ + public void exec() { + try { + getInfoFromJar(); + initClassLoader(); + runMain(); + } + catch (JarLaunchException e) { + System.err.println("Failure to launch application."); + System.err.println(e.getMessage()); + } + } + + /** + *+ * Retrieves the classpath and main function from the Jar file's MANIFEST. + *
+ * + * @throws JarLaunchException + * thrown if reading of Jar file or MANIFEST fails + */ + private void getInfoFromJar() throws JarLaunchException { + JarInputStream jarInputStream; + try { + jarInputStream = new JarInputStream(new FileInputStream(workingDir + jarfile)); + } + catch (FileNotFoundException e) { + throw new JarLaunchException(e); + } + catch (IOException e) { + throw new JarLaunchException(e); + } + Manifest manifest = jarInputStream.getManifest(); + mainClassName = manifest.getMainAttributes().getValue("Main-Class"); + String jarClassPath = manifest.getMainAttributes().getValue("Class-Path"); + String[] jarClassPathElements = jarClassPath.split(" "); + classPath = new String[jarClassPathElements.length]; + for (int i = 0; i < jarClassPathElements.length; i++) { + classPath[i] = "file:" + workingDir + jarClassPathElements[i]; + } + try { + jarInputStream.close(); + } + catch (IOException e) { + e.printStackTrace(); + } + } + + /** + *+ * Modifies the {@link ClassLoader} of the current VM such that it includes the class path + * defined in the Jar file's MANIFEST. + *
+ * + * @throws JarLaunchException + * thrown if modification of {@link ClassLoader} fails. + */ + private void initClassLoader() throws JarLaunchException { + URLClassLoader classLoader = (URLClassLoader) ClassLoader.getSystemClassLoader(); + Method method; + try { + method = URLClassLoader.class.getDeclaredMethod("addURL", new Class[] + { URL.class }); + } + catch (SecurityException e) { + throw new JarLaunchException( + "addURL method of URLClassLoader not accessible via reflection."); + } + catch (NoSuchMethodException e) { + throw new JarLaunchException( + "URLClassLoader does not have addURL method. Should be impossible!!"); + } + method.setAccessible(true); + + try { + method.invoke(classLoader, new Object[] + { new URL("file:" + workingDir + jarfile) }); + for (String element : classPath) { + method.invoke(classLoader, new Object[] + { new URL(element) }); + } + } + catch (IllegalArgumentException e) { + throw new JarLaunchException( + "Illegal arguments for addURL method. Should be impossible!!"); + } + catch (MalformedURLException e) { + throw new JarLaunchException(e); + } + catch (IllegalAccessException e) { + throw new JarLaunchException( + "addURL method of URLClassLoader not accessible via reflection."); + } + catch (InvocationTargetException e) { + e.printStackTrace(); + } + } + + /** + *+ * Executes the main function. + *
+ * + * @throws JarLaunchException + * thrown if execution of main function fails or the main function itself throws an + * exception + */ + private void runMain() throws JarLaunchException { + Class mainClass; + try { + mainClass = Class.forName(mainClassName); + } + catch (ClassNotFoundException e) { + throw new JarLaunchException("Main class not found: " + mainClassName); + } + Method mainMethod; + try { + mainMethod = mainClass.getMethod("main", new Class[] + { String[].class }); + } + catch (SecurityException e) { + throw new JarLaunchException("Main method not accessible."); + } + catch (NoSuchMethodException e) { + throw new JarLaunchException("Main method not found."); + } + try { + mainMethod.invoke(null, new Object[] + { args }); + } + catch (IllegalArgumentException e) { + throw new JarLaunchException( + "Illegal arguments for main method. Should be impossible!!"); + } + catch (IllegalAccessException e) { + throw new JarLaunchException("Main method not accessible."); + } + catch (InvocationTargetException e) { + throw new JarLaunchException(e); + } + } +} Index: trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/Runner.java =================================================================== --- trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/Runner.java (revision 823) +++ trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/Runner.java (revision 823) @@ -0,0 +1,86 @@ + +package de.ugoe.cs.eventbench.jfcmonitor; + +import java.awt.AWTEvent; +import java.awt.Toolkit; +import java.awt.event.AWTEventListener; +import java.awt.event.FocusEvent; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.OutputStreamWriter; +import java.io.UnsupportedEncodingException; +import java.util.Arrays; + +/** + *+ * Start-up class of the application. + *
+ *+ * Launches the application under test in the same JVM. + *
+ * + * @author Steffen Herbold + * @version 1.0 + */ +public class Runner { + + /** + *+ * Debugging variable. If set to true, the logging is also written to the console. + *
+ */ + private final static boolean stdOutputWrite = true; + + /** + *+ * Main method of the application. + *
+ * + * @param args + * the first parameter defines the Jar file that contains the start-up information of + * the application under test. The remaining parameters are passed on the toe + * application under test. + */ + public static void main(String[] args) { + String logfileName = "jfcmonitor_" + System.currentTimeMillis() + ".log"; + + FileOutputStream fis; + OutputStreamWriter writer; + try { + // the writer is not closed explicitly! + fis = new FileOutputStream(logfileName, true); + writer = new OutputStreamWriter(fis, "UTF-16"); + } + catch (IOException e) { + System.err.println("JFCMONITOR -- failure opening logfile: " + e.getMessage()); + return; + } + + AWTEventListener listenerFile = new JFCListener(writer); + Toolkit.getDefaultToolkit().addAWTEventListener(listenerFile, AWTEvent.KEY_EVENT_MASK); + Toolkit.getDefaultToolkit().addAWTEventListener(listenerFile, AWTEvent.MOUSE_EVENT_MASK); + Toolkit.getDefaultToolkit().addAWTEventListener(listenerFile, FocusEvent.FOCUS_EVENT_MASK); + Toolkit.getDefaultToolkit().addAWTEventListener(new WindowMonitor(), + AWTEvent.WINDOW_EVENT_MASK); + + if (stdOutputWrite) { + AWTEventListener listenerStdOut; + try { + listenerStdOut = new JFCListener(new OutputStreamWriter(System.out, "UTF-8")); + Toolkit.getDefaultToolkit().addAWTEventListener(listenerStdOut, + AWTEvent.KEY_EVENT_MASK); + Toolkit.getDefaultToolkit().addAWTEventListener(listenerStdOut, + AWTEvent.MOUSE_EVENT_MASK); + Toolkit.getDefaultToolkit().addAWTEventListener(listenerStdOut, + FocusEvent.FOCUS_EVENT_MASK); + } + catch (UnsupportedEncodingException e) { + System.err + .println("JFCMONITOR -- failure to create OutputStreamWriter with UTF-8 encoding to System.out"); + } + } + + JarLauncher launcher = new JarLauncher(args[0], Arrays.copyOfRange(args, 1, args.length)); + launcher.exec(); + } +} Index: trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/WindowMonitor.java =================================================================== --- trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/WindowMonitor.java (revision 823) +++ trunk/quest-jfcmonitor/src/main/java/de/ugoe/cs/eventbench/jfcmonitor/WindowMonitor.java (revision 823) @@ -0,0 +1,46 @@ + +package de.ugoe.cs.eventbench.jfcmonitor; + +import java.awt.AWTEvent; +import java.awt.Window; +import java.awt.event.AWTEventListener; +import java.awt.event.WindowEvent; + +/** + *+ * An AWT event listener responsible to monitor the window creation and destruction. + *
+ * + * @author Steffen Herbold + * @version 1.0 + */ +public class WindowMonitor implements AWTEventListener { + + /** + *+ * Adds all created windows (and their child components) to the GUI hierarchy maintained by + * {@link JFCComponent} and removes them if a window is destroyed. + *
+ * + * + * @see java.awt.event.AWTEventListener#eventDispatched(java.awt.AWTEvent) + */ + @Override + public void eventDispatched(AWTEvent event) { + Window window; + switch (event.getID()) + { + case WindowEvent.WINDOW_OPENED: + window = ((WindowEvent) event).getWindow(); + JFCComponent.add(window); + break; + case WindowEvent.WINDOW_CLOSED: + window = ((WindowEvent) event).getWindow(); + JFCComponent.remove(window); + break; + default: + break; + } + } + +}