@@ -30,5 +31,5 @@ */ private TreeNode root = new TreeNode(); - + /** *
@@ -44,55 +45,54 @@ * a leaf node. Such a path can be added to the tree. The method checks, if any of the GUI * elements denoted by the path already exists. If so, it reuses it. It may therefore also - * return an existing GUI element being the leaf node of the provided path. If a GUI element - * of the path does not exist yet, it creates a new one using the provided GUI element factory. - *
- *- * If a GUI element specification describes an existing GUI element or not is determined - * through comparing the GUI element specifications of the existing GUI elements with the - * ones provided in the path. The comparison is done using the - * {@link IGUIElementSpec#getSimilarity(IGUIElementSpec)} method. The comparison is only done - * on the correct levels. I.e. the currently known root elements of the tree are only compared - * to the first element in the path. If the correct one is found or created, its children are + * return an existing GUI element being the leaf node of the provided path. If a GUI element of + * the path does not exist yet, it creates a new one using the provided GUI element factory. + *
+ *+ * If a GUI element specification describes an existing GUI element or not is determined through + * comparing the GUI element specifications of the existing GUI elements with the ones provided + * in the path. The comparison is done using the + * {@link IGUIElementSpec#getSimilarity(IGUIElementSpec)} method. The comparison is only done on + * the correct levels. I.e. the currently known root elements of the tree are only compared to + * the first element in the path. If the correct one is found or created, its children are * compared only to the second specification in the path, and so on. *
** The returned GUI elements are singletons. I.e. it is tried to return always the identical - * object for the same denoted element. However, while creating the GUI model, the similarity - * of GUI elements may change. Therefore, the method might determine, that two formerly - * different nodes are now similar. (This may happen, e.g. if GUI elements do not have initial - * names which are set afterwards. Therefore, first they are handled differently and later - * they can be identified as being the same.) In such a case, there are already several GUI - * element objects instantiated for the same GUI element. The singleton paradigm gets broken. - * Therefore, such GUI element objects are registered with each other, so that their equal - * method can determine equality again correctly, although the objects are no singletons - * anymore. - *
- * - * @param guiElementPath the path to integrate into the model - * @param guiElementFactory the GUI element factory to be used for instantiating GUI element - * objects - * + * object for the same denoted element. However, while creating the GUI model, the similarity of + * GUI elements may change. Therefore, the method might determine, that two formerly different + * nodes are now similar. (This may happen, e.g. if GUI elements do not have initial names which + * are set afterwards. Therefore, first they are handled differently and later they can be + * identified as being the same.) In such a case, there are already several GUI element objects + * instantiated for the same GUI element. The singleton paradigm gets broken. Therefore, such + * GUI element objects are registered with each other, so that their equal method can determine + * equality again correctly, although the objects are no singletons anymore. + * + * + * @param guiElementPath + * the path to integrate into the model + * @param guiElementFactory + * the GUI element factory to be used for instantiating GUI element objects + * * @return The GUI element object representing the GUI element denoted by the provided path * - * @throws GUIModelException thrown in cases such as the GUI element object could not be - * instantiated - * @throws IllegalArgumentException if the provided path is invalid. + * @throws GUIModelException + * thrown in cases such as the GUI element object could not be instantiated + * @throws IllegalArgumentException + * if the provided path is invalid. */ public IGUIElement integratePath(List guiElementPath, - IGUIElementFactory guiElementFactory) + IGUIElementFactory guiElementFactory) throws GUIModelException, IllegalArgumentException { if ((guiElementPath == null) || (guiElementPath.size() <= 0)) { - throw new IllegalArgumentException - ("GUI element path must contain at least one element"); - } - + throw new IllegalArgumentException("GUI element path must contain at least one element"); + } + List- * Returns all children of the provided GUI element or null, if it does not have any or the - * node is unknown. - *
- * - * @param guiElement the GUI element of which the children shall be returned + * Returns all children of the provided GUI element or null, if it does not have any or the node + * is unknown. + * + * + * @param guiElement + * the GUI element of which the children shall be returned * * @return As described @@ -112,15 +113,15 @@ if (node.guiElement.equals(guiElement)) { List- * internally integrates a path as the children of the provided parent node. This method - * is recursive and calls itself, for the child of the parent node, that matches the first - * element in the remaining path. - *
- * - * @param parentNode the parent node to add children for - * @param guiElementPath the path of children to be created starting with the parent node - * @param guiElementFactory the GUI element factory to be used for instantiating GUI element - * objects - * + * TODO: comment + * + * + */ + public void condenseModel() { + mergeSimilarChildren(root); + } + + /** + *+ * internally integrates a path as the children of the provided parent node. This method is + * recursive and calls itself, for the child of the parent node, that matches the first element + * in the remaining path. + *
+ * + * @param parentNode + * the parent node to add children for + * @param guiElementPath + * the path of children to be created starting with the parent node + * @param guiElementFactory + * the GUI element factory to be used for instantiating GUI element objects + * * @return The GUI element object representing the GUI element denoted by the provided path * - * @throws GUIModelException thrown in cases such as the GUI element object could not be - * instantiated - */ - private IGUIElement integratePath(TreeNode parentNode, + * @throws GUIModelException + * thrown in cases such as the GUI element object could not be instantiated + */ + private IGUIElement integratePath(TreeNode parentNode, List remainingPath, - IGUIElementFactory guiElementFactory) + IGUIElementFactory guiElementFactory) throws GUIModelException { IGUIElementSpec specToIntegrateElementFor = remainingPath.remove(0); - List- * Determines all children of the provided node, which are similar to the provided - * specification. - *
- */ - private List+ * TODO: comment + *
+ * + * @param parentNode + * @param specToMatch + * @return + */ + private TreeNode findEqualChild(TreeNode parentNode, IGUIElementSpec specToMatch) { if (parentNode.children != null) { for (TreeNode child : parentNode.children) { - if (specToMatch.getSimilarity(child.guiElement.getSpecification())) { - similarChildren.add(child); + if (specToMatch.equals(child.guiElement.getSpecification())) { + return child; } } } - - return similarChildren; - } - - /** - *- * This method is called in the case, that several child nodes of a parent node are similar - * to a node to be integrated into the model. This method tries to determine the similar child - * nodes of which the sub children match best to the further path to be integrated. This method - * does nothing, if the similar children do not have children yet of if the remaining path - * does not denote further children. - *
- * - * @return a hopefully reduced list of similar nodes based on their children. - */ - private List+ * merges similar children of a parent node. The method compares all children of the parent node + * with each other. If two of them are similar, it merges them, registers them with each other + * for equality checks, and removes one of them from the list of children. + *
+ */ + private void mergeSimilarChildren(TreeNode parentNode) { + if (parentNode.children == null || parentNode.children.isEmpty()) { + return; + } + + // lets first merge the grandchildren + for (TreeNode child : parentNode.children) { + mergeSimilarChildren(child); + } + + boolean performedMerge; + + do { + performedMerge = false; + for (int i = 0; !performedMerge && i < parentNode.children.size(); i++) { + IGUIElementSpec elemSpec1 = + parentNode.children.get(i).guiElement.getSpecification(); + for (int j = i + 1; !performedMerge && j < parentNode.children.size(); j++) { + IGUIElementSpec elemSpec2 = + parentNode.children.get(j).guiElement.getSpecification(); + if (elemSpec1.getSimilarity(elemSpec2)) { + TreeNode replacement = + mergeTreeNodes(parentNode.children.get(i), parentNode.children.get(j)); + + parentNode.children.set(i, replacement); + parentNode.children.remove(j); + performedMerge = true; + i--; + break; } } } } - - return reducedList; - } - - /** - *- * merges similar children of a parent node. The method compares all children of the parent - * node with each other. If two of them are similar, it merges them, registers them with each - * other for equality checks, and removes one of them from the list of children. - *
- */ - private void mergeSimilarChildren(TreeNode parentNode) { - boolean performedMerge; - - do { - performedMerge = false; - if (parentNode.children != null) { - for (int i = 0; (!performedMerge) && (i < parentNode.children.size()); i++) { - for (int j = i + 1; j < parentNode.children.size(); j++) { - IGUIElement elem1 = parentNode.children.get(i).guiElement; - IGUIElement elem2 = parentNode.children.get(j).guiElement; - if (elem1.getSpecification().getSimilarity(elem2.getSpecification())) { - TreeNode replacement = mergeTreeNodes(parentNode.children.get(i), - parentNode.children.get(j)); - - parentNode.children.set(i, replacement); - parentNode.children.remove(j); - performedMerge = true; - break; - } - } - } - } - } while (performedMerge); } @@ -375,16 +323,12 @@ /** *- * merges two nodes with each other. Merging means registering the GUI element objects with - * each other for equality checks. Further it add all children of both nodes to a new - * replacing node. Afterwards, all similar nodes of the replacement node are merged as well. - *
- * + * merges two nodes with each other. Merging means registering the GUI element objects with each + * other for equality checks. Further it add all children of both nodes to a new replacing node. + * Afterwards, all similar nodes of the replacement node are merged as well. + * + * * @return a tree node being the merge of the two provided nodes. */ private TreeNode mergeTreeNodes(TreeNode treeNode1, TreeNode treeNode2) { - TreeNode replacement = new TreeNode(); - - replacement.guiElement = treeNode1.guiElement; - // the following two lines are needed to preserve the references to the existing GUI // elements. If two elements are the same, one should be deleted to make the elements @@ -392,23 +336,33 @@ // these, we simply register the equal GUI elements with each other so that an equals // check can return true. - replacement.guiElement.addEqualGUIElement(treeNode2.guiElement); - treeNode2.guiElement.addEqualGUIElement(replacement.guiElement); - + treeNode1.guiElement.addEqualGUIElement(treeNode2.guiElement); + treeNode2.guiElement.addEqualGUIElement(treeNode1.guiElement); + + // and now a replacement node that is the merge of treeNode1 and treeNode2 is created + TreeNode replacement = new TreeNode(); + replacement.guiElement = treeNode1.guiElement; if (treeNode1.children != null) { for (TreeNode child : treeNode1.children) { - replacement.addChild(child.guiElement); - } - } - + // replacement.addChild(child.guiElement); + replacement.addChildNode(child); + } + } if (treeNode2.children != null) { for (TreeNode child : treeNode2.children) { - replacement.addChild(child.guiElement); - } - } - + // replacement.addChild(child.guiElement); + replacement.addChildNode(child); + } + } + mergeSimilarChildren(replacement); - + replacement.guiElement.updateSpecification(treeNode2.guiElement.getSpecification()); - + + // finally, update the known nodes list + // if you don't do this getChildren will return wrong things and very bad things happen! + allNodes.remove(treeNode1); + allNodes.remove(treeNode2); + allNodes.add(replacement); + return replacement; } @@ -416,6 +370,6 @@ /** *- * dumps a GUI element to the stream. A dump contains the toString() representation of the - * GUI element as well as a indented list of its children surrounded by braces. + * dumps a GUI element to the stream. A dump contains the toString() representation of the GUI + * element as well as a indented list of its children surrounded by braces. *
*/ @@ -445,15 +399,14 @@ * */ - private class TreeNode - { + private class TreeNode { /** */ private IGUIElement guiElement; - + /** */ private List@@ -461,22 +414,39 @@ *
*/ - private TreeNode addChild(IGUIElement guiElement) - { - if (children == null) - { + private TreeNode addChild(IGUIElement guiElement) { + if (children == null) { children = new ArrayList+ * TODO: comment + *
+ * + * @param node + * @return + */ + private TreeNode addChildNode(TreeNode node) { + if (children == null) { + children = new ArrayList+ * Command to condense the GUI model of a sequence, i.e., merge duplicate nodes. + *
+ * + * @version 1.0 + * @author Steffen Herbold + */ +public class CMDcondenseGuiModel implements Command { + + /* + * (non-Javadoc) + * + * @see de.ugoe.cs.util.console.Command#run(java.util.List) + */ + @Override + public void run(List