+ * 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: /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/JFCListener.java =================================================================== --- /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/JFCListener.java (revision 540) +++ /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/JFCListener.java (revision 540) @@ -0,0 +1,160 @@ +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: /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/JarLauncher.java =================================================================== --- /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/JarLauncher.java (revision 540) +++ /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/JarLauncher.java (revision 540) @@ -0,0 +1,261 @@ +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: /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/Runner.java =================================================================== --- /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/Runner.java (revision 540) +++ /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/Runner.java (revision 540) @@ -0,0 +1,92 @@ +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: /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/WindowMonitor.java =================================================================== --- /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/WindowMonitor.java (revision 540) +++ /tags/quest-pre-eventrefactoring/JFCMonitor/src/de/ugoe/cs/eventbench/jfcmonitor/WindowMonitor.java (revision 540) @@ -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; + } + } + +} Index: /tags/quest-pre-eventrefactoring/JavaCommons/.project =================================================================== --- /tags/quest-pre-eventrefactoring/JavaCommons/.project (revision 540) +++ /tags/quest-pre-eventrefactoring/JavaCommons/.project (revision 540) @@ -0,0 +1,14 @@ + +