Ignore:
Timestamp:
08/17/12 08:33:29 (12 years ago)
Author:
pharms
Message:
  • adapted task tree creation stuff to more general event handling
Location:
trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl
Files:
10 moved

Legend:

Unmodified
Added
Removed

  • trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/EventTask.java

    r498 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: InteractionTask.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: Patrick $  $Date: 06.11.2011 10:57:52 $ 
    … …  
    54// Creation  : 2011 by Patrick 
    65// Copyright : Patrick Harms, 2011 
    7 //------------------------------------------------------------------------------------------------- 
    86 
    97package de.ugoe.cs.quest.tasktrees.treeimpl; 
    108 
    11 import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; 
    12 import de.ugoe.cs.quest.eventcore.userinteraction.Interaction; 
    13 import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; 
    14 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 
     9import de.ugoe.cs.quest.eventcore.IEventTarget; 
     10import de.ugoe.cs.quest.eventcore.IEventType; 
     11import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; 
     12import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 
    1513 
    16 //------------------------------------------------------------------------------------------------- 
    1714/** 
    1815 * TODO comment 
    19  * 
     16 *  
    2017 * @version $Revision: $ $Date: $ 
    21  * @author  2011, last modified by $Author: $ 
     18 * @author 2011, last modified by $Author: $ 
    2219 */ 
    23 //------------------------------------------------------------------------------------------------- 
    24 public class InteractionTaskImpl extends TaskTreeNodeImpl implements InteractionTask 
    25 { 
    26   /** */ 
    27   private GUIElement mGUIElement; 
    28    
    29   /** */ 
    30   private Interaction mInteraction; 
     20public class EventTask extends TaskTreeNode implements IEventTask { 
     21     
     22    /** */ 
     23    private IEventType eventType; 
    3124 
    32   //----------------------------------------------------------------------------------------------- 
    33   /** 
    34    * @param guiElement 
    35    * @param interaction 
    36    */ 
    37   //----------------------------------------------------------------------------------------------- 
    38   InteractionTaskImpl(GUIElement guiElement, Interaction interaction) 
    39   { 
    40     super(interaction.getName() + "(" + guiElement + ")"); 
    41     super.setDescription(interaction + " on " + guiElement); 
    42     mGUIElement = guiElement; 
    43     mInteraction = interaction; 
    44   } 
     25    /** */ 
     26    private IEventTarget eventTarget; 
    4527 
    46   //----------------------------------------------------------------------------------------------- 
    47   /** 
    48    * @return Returns the interaction. 
    49    */ 
    50   //----------------------------------------------------------------------------------------------- 
    51   public Interaction getInteraction() 
    52   { 
    53     return mInteraction; 
    54   } 
     28    /** 
     29     * @param eventType 
     30     * @param eventTarget 
     31     */ 
     32    EventTask(IEventType eventType, IEventTarget eventTarget) { 
     33        super(eventType.getName() + "(" + eventTarget + ")"); 
     34        super.setDescription(eventType + " on " + eventTarget); 
     35        this.eventType = eventType; 
     36        this.eventTarget = eventTarget; 
     37    } 
    5538 
    56    
    57   //----------------------------------------------------------------------------------------------- 
    58   /** 
    59    * @return Returns the GUIElement. 
    60    */ 
    61   //----------------------------------------------------------------------------------------------- 
    62   public GUIElement getGUIElement() 
    63   { 
    64     return mGUIElement; 
    65   } 
     39    /** 
     40     * @return Returns the interaction. 
     41     */ 
     42    public IEventType getEventType() { 
     43        return eventType; 
     44    } 
    6645 
    67   //----------------------------------------------------------------------------------------------- 
    68   /* (non-Javadoc) 
    69    * @see de.harms.ctte.Task#equals(de.harms.ctte.Task) 
    70    */ 
    71   //----------------------------------------------------------------------------------------------- 
    72   @Override 
    73   public boolean equals(TaskTreeNode task) 
    74   { 
    75     if (!(task instanceof InteractionTask)) 
    76     { 
    77       return false; 
     46    /** 
     47     * @return Returns the GUIElement. 
     48     */ 
     49    public IEventTarget getEventTarget() { 
     50        return eventTarget; 
    7851    } 
    79      
    80     GUIElement otherInteractionElem = ((InteractionTask) task).getGUIElement(); 
    81     Interaction otherInteraction = ((InteractionTask) task).getInteraction(); 
    82      
    83     if ((((mGUIElement == null) && (otherInteractionElem == null)) || 
    84          ((mGUIElement != null) && (mGUIElement.equals(otherInteractionElem)))) && 
    85         (((mInteraction == null) && (otherInteraction == null)) || 
    86          ((mInteraction != null) && (mInteraction.equals(otherInteraction))))) 
    87     { 
    88       return true; 
     52 
     53    /* 
     54     * (non-Javadoc) 
     55     *  
     56     * @see de.harms.ctte.Task#equals(de.harms.ctte.Task) 
     57     */ 
     58    @Override 
     59    public boolean equals(ITaskTreeNode task) { 
     60        if (!(task instanceof IEventTask)) { 
     61            return false; 
     62        } 
     63 
     64        IEventType otherType = ((IEventTask) task).getEventType(); 
     65        IEventTarget otherTarget = ((IEventTask) task).getEventTarget(); 
     66 
     67        if (((eventType == otherType) || 
     68             ((eventType != null) && (eventType.equals(otherType)))) && 
     69            ((eventTarget == otherTarget) || 
     70             ((eventTarget != null) && (eventTarget.equals(otherTarget))))) 
     71        { 
     72            return true; 
     73        } 
     74 
     75        return false; 
    8976    } 
    90      
    91     return false; 
    92   } 
    9377 
    94   //----------------------------------------------------------------------------------------------- 
    95   /* (non-Javadoc) 
    96    * @see de.harms.tasktrees.TreeNode#clone() 
    97    */ 
    98   //----------------------------------------------------------------------------------------------- 
    99   @Override 
    100   public InteractionTaskImpl clone() 
    101   { 
    102     // GUI element and interaction are unchangeable and do not need to be cloned 
    103     return (InteractionTaskImpl) super.clone(); 
    104   } 
     78    /* 
     79     * (non-Javadoc) 
     80     *  
     81     * @see de.harms.tasktrees.TreeNode#clone() 
     82     */ 
     83    @Override 
     84    public EventTask clone() { 
     85        // Event type and target are unchangeable and do not need to be cloned 
     86        return (EventTask) super.clone(); 
     87    } 
    10588 
    10689} 

  • trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/Iteration.java

    r498 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: Iteration.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: patrick $  $Date: 19.02.2012 $ 
    … …  
    54// Creation  : 2012 by patrick 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
     7 
    88package de.ugoe.cs.quest.tasktrees.treeimpl; 
    99 
    10 import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; 
    11 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 
     10import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; 
     11import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 
    1212 
    13 //------------------------------------------------------------------------------------------------- 
    1413/** 
    1514 * TODO comment 
    … …  
    1817 * @author 2012, last modified by $Author: patrick$ 
    1918 */ 
    20 //------------------------------------------------------------------------------------------------- 
    21 public class IterationImpl extends TaskTreeNodeImpl implements Iteration 
    22 { 
     19public class Iteration extends TaskTreeNode implements IIteration { 
    2320 
    24   //----------------------------------------------------------------------------------------------- 
    25   /** 
    26    * 
    27    */ 
    28   //----------------------------------------------------------------------------------------------- 
    29   IterationImpl() 
    30   { 
    31     super("Iteration"); 
    32   } 
     21    /** 
     22     * 
     23     */ 
     24    Iteration() { 
     25        super("Iteration"); 
     26    } 
    3327 
    34   //----------------------------------------------------------------------------------------------- 
    35   /* (non-Javadoc) 
    36    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#addChild(TaskTreeNode) 
    37    */ 
    38   //----------------------------------------------------------------------------------------------- 
    39   @Override 
    40   public void addChild(TaskTreeNode child) 
    41   { 
    42     // adding more children is not allowed 
    43     throw new UnsupportedOperationException(); 
    44   } 
     28    /* 
     29     * (non-Javadoc) 
     30     *  
     31     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#addChild(TaskTreeNode) 
     32     */ 
     33    @Override 
     34    public void addChild(ITaskTreeNode child) { 
     35        // adding more children is not allowed 
     36        throw new UnsupportedOperationException 
     37          ("iterations may not have a list of children. Use setChild() instead."); 
     38    } 
    4539 
    46   //----------------------------------------------------------------------------------------------- 
    47   /** 
    48    * TODO: comment 
    49    * 
    50    * @param selection 
    51    * @return 
    52    */ 
    53   //----------------------------------------------------------------------------------------------- 
    54   public void setChild(TaskTreeNode child) 
    55   { 
    56     if (super.getChildren().size() > 0) 
    57     { 
    58       super.removeChild(0); 
     40    /** 
     41     * TODO: comment 
     42     *  
     43     * @param selection 
     44     * @return 
     45     */ 
     46    public void setChild(ITaskTreeNode child) { 
     47        if (super.getChildren().size() > 0) { 
     48            super.removeChild(0); 
     49        } 
     50        super.addChild(child); 
    5951    } 
    60     super.addChild(child); 
    61   } 
    6252 
    63   //----------------------------------------------------------------------------------------------- 
    64   /* (non-Javadoc) 
    65    * @see java.lang.Object#clone() 
    66    */ 
    67   //----------------------------------------------------------------------------------------------- 
    68   @Override 
    69   public IterationImpl clone() 
    70   { 
    71     return (IterationImpl) super.clone(); 
    72   } 
     53    /* 
     54     * (non-Javadoc) 
     55     *  
     56     * @see java.lang.Object#clone() 
     57     */ 
     58    @Override 
     59    public Iteration clone() { 
     60        return (Iteration) super.clone(); 
     61    } 
    7362 
    7463} 

  • trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/NodeInfo.java

    r498 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: NodeInfo.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: Patrick $  $Date: 05.11.2011 19:24:14 $ 
    … …  
    54// Creation  : 2011 by Patrick 
    65// Copyright : Patrick Harms, 2011 
    7 //------------------------------------------------------------------------------------------------- 
    86 
    97package de.ugoe.cs.quest.tasktrees.treeimpl; 
    … …  
    1210import java.util.List; 
    1311 
    14 import de.ugoe.cs.quest.tasktrees.treeifc.NodeInfo; 
    15 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 
     12import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeInfo; 
     13import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 
    1614 
    17  
    18 //------------------------------------------------------------------------------------------------- 
    1915/** 
    2016 * TODO comment 
    21  * 
     17 *  
    2218 * @version $Revision: $ $Date: $ 
    23  * @author  2011, last modified by $Author: $ 
     19 * @author 2011, last modified by $Author: $ 
    2420 */ 
    25 //------------------------------------------------------------------------------------------------- 
    26 public class NodeInfoImpl implements NodeInfo 
    27 { 
    28   /** */ 
    29   private TaskTreeNode mTask; 
    30    
    31   /** */ 
    32   private long mLastUpdate; 
     21public class NodeInfo implements ITaskTreeNodeInfo { 
     22     
     23    /** */ 
     24    private ITaskTreeNode task; 
    3325 
    34   /** */ 
    35   private List<TaskTreeNode> mParentNodes = new ArrayList<TaskTreeNode>(); 
     26    /** */ 
     27    private long lastUpdate; 
    3628 
    37   //----------------------------------------------------------------------------------------------- 
    38   /** 
    39    * @param node  
    40    */ 
    41   //----------------------------------------------------------------------------------------------- 
    42   NodeInfoImpl(TaskTreeNode task) 
    43   { 
    44     mTask = task; 
    45     mLastUpdate = System.currentTimeMillis(); 
    46   } 
     29    /** */ 
     30    private List<ITaskTreeNode> parentNodes = new ArrayList<ITaskTreeNode>(); 
    4731 
    48   //----------------------------------------------------------------------------------------------- 
    49   /* (non-Javadoc) 
    50    * @see de.ugoe.cs.tasktree.treeifc.NodeInfo#getTask() 
    51    */ 
    52   //----------------------------------------------------------------------------------------------- 
    53   @Override 
    54   public TaskTreeNode getTask() 
    55   { 
    56     return mTask; 
    57   } 
     32    /** 
     33     * @param node 
     34     */ 
     35    NodeInfo(ITaskTreeNode task) { 
     36        this.task = task; 
     37        lastUpdate = System.currentTimeMillis(); 
     38    } 
    5839 
    59   //----------------------------------------------------------------------------------------------- 
    60   /* (non-Javadoc) 
    61    * @see de.ugoe.cs.tasktree.treeimpl.NodeInfo#getNoOfOccurencesInTree() 
    62    */ 
    63   //----------------------------------------------------------------------------------------------- 
    64   @Override 
    65   public int getNoOfOccurencesInTree() 
    66   { 
    67     return mParentNodes.size(); 
    68   } 
     40    /* 
     41     * (non-Javadoc) 
     42     *  
     43     * @see de.ugoe.cs.tasktree.treeifc.NodeInfo#getTask() 
     44     */ 
     45    @Override 
     46    public ITaskTreeNode getTask() { 
     47        return task; 
     48    } 
    6949 
    70   //----------------------------------------------------------------------------------------------- 
    71   /* (non-Javadoc) 
    72    * @see de.ugoe.cs.tasktree.treeimpl.NodeInfo#getLastUpdate() 
    73    */ 
    74   //----------------------------------------------------------------------------------------------- 
    75   @Override 
    76   public long getLastUpdate() 
    77   { 
    78     return mLastUpdate; 
    79   } 
     50    /* 
     51     * (non-Javadoc) 
     52     *  
     53     * @see de.ugoe.cs.tasktree.treeimpl.NodeInfo#getNoOfOccurencesInTree() 
     54     */ 
     55    @Override 
     56    public int getNoOfOccurencesInTree() { 
     57        return parentNodes.size(); 
     58    } 
    8059 
    81   //----------------------------------------------------------------------------------------------- 
    82   /** 
    83    * TODO: comment 
    84    * 
    85    */ 
    86   //----------------------------------------------------------------------------------------------- 
    87   void addParent(TaskTreeNode parent) 
    88   { 
    89     mParentNodes.add(parent); 
    90   } 
     60    /* 
     61     * (non-Javadoc) 
     62     *  
     63     * @see de.ugoe.cs.tasktree.treeimpl.NodeInfo#getLastUpdate() 
     64     */ 
     65    @Override 
     66    public long getLastUpdate() { 
     67        return lastUpdate; 
     68    } 
    9169 
    92   //----------------------------------------------------------------------------------------------- 
    93   /** 
    94    * TODO: comment 
    95    * 
    96    */ 
    97   //----------------------------------------------------------------------------------------------- 
    98   void removeParent(TaskTreeNode parent) 
    99   { 
    100     mParentNodes.remove(parent); 
    101   } 
     70    /** 
     71     * TODO: comment 
     72     *  
     73     */ 
     74    void addParent(ITaskTreeNode parent) { 
     75        parentNodes.add(parent); 
     76    } 
    10277 
    103   //----------------------------------------------------------------------------------------------- 
    104   /* (non-Javadoc) 
    105    * @see java.lang.Object#toString() 
    106    */ 
    107   //----------------------------------------------------------------------------------------------- 
    108   @Override 
    109   public synchronized String toString() 
    110   { 
    111     return "NodeInfo(" + mTask + ", " + mParentNodes.size() + " parents)"; 
    112   } 
    113    
     78    /** 
     79     * TODO: comment 
     80     *  
     81     */ 
     82    void removeParent(ITaskTreeNode parent) { 
     83        parentNodes.remove(parent); 
     84    } 
     85 
     86    /* 
     87     * (non-Javadoc) 
     88     *  
     89     * @see java.lang.Object#toString() 
     90     */ 
     91    @Override 
     92    public synchronized String toString() { 
     93        return "NodeInfo(" + task + ", " + parentNodes.size() + " parents)"; 
     94    } 
     95 
    11496} 

  • trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/Selection.java

    r498 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: Selection.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: patrick $  $Date: 19.02.2012 $ 
    … …  
    54// Creation  : 2012 by patrick 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
    87package de.ugoe.cs.quest.tasktrees.treeimpl; 
    98 
    10 import de.ugoe.cs.quest.tasktrees.treeifc.Selection; 
     9import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; 
    1110 
    12 //------------------------------------------------------------------------------------------------- 
    1311/** 
    1412 * TODO comment 
    … …  
    1715 * @author 2012, last modified by $Author: patrick$ 
    1816 */ 
    19 //------------------------------------------------------------------------------------------------- 
    20 public class SelectionImpl extends TaskTreeNodeImpl implements Selection 
    21 { 
     17public class Selection extends TaskTreeNode implements ISelection { 
    2218 
    23   //----------------------------------------------------------------------------------------------- 
    24   /** 
    25    * TODO: comment 
    26    * 
    27    * @param name 
    28    */ 
    29   //----------------------------------------------------------------------------------------------- 
    30   SelectionImpl() 
    31   { 
    32     super("Selection"); 
    33   } 
     19    /** 
     20     * TODO: comment 
     21     *  
     22     * @param name 
     23     */ 
     24    Selection() { 
     25        super("Selection"); 
     26    } 
    3427 
    35   //----------------------------------------------------------------------------------------------- 
    36   /* (non-Javadoc) 
    37    * @see java.lang.Object#clone() 
    38    */ 
    39   //----------------------------------------------------------------------------------------------- 
    40   @Override 
    41   public SelectionImpl clone() 
    42   { 
    43     return (SelectionImpl) super.clone(); 
    44   } 
     28    /* 
     29     * (non-Javadoc) 
     30     *  
     31     * @see java.lang.Object#clone() 
     32     */ 
     33    @Override 
     34    public Selection clone() { 
     35        return (Selection) super.clone(); 
     36    } 
    4537 
    4638} 

  • trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/Sequence.java

    r498 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: Sequence.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: patrick $  $Date: 19.02.2012 $ 
    … …  
    54// Creation  : 2012 by patrick 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
    87package de.ugoe.cs.quest.tasktrees.treeimpl; 
    98 
    10 import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; 
     9import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; 
    1110 
    12 //------------------------------------------------------------------------------------------------- 
    1311/** 
    1412 * TODO comment 
    … …  
    1715 * @author 2012, last modified by $Author: patrick$ 
    1816 */ 
    19 //------------------------------------------------------------------------------------------------- 
    20 public class SequenceImpl extends TaskTreeNodeImpl implements Sequence 
    21 { 
    22   //----------------------------------------------------------------------------------------------- 
    23   /** 
    24    * TODO: comment 
    25    * 
    26    * @param name 
    27    */ 
    28   //----------------------------------------------------------------------------------------------- 
    29   SequenceImpl() 
    30   { 
    31     super("Sequence"); 
    32   } 
     17public class Sequence extends TaskTreeNode implements ISequence { 
     18     
     19    /** 
     20     * TODO: comment 
     21     *  
     22     * @param name 
     23     */ 
     24    Sequence() { 
     25        super("Sequence"); 
     26    } 
    3327 
    34   //----------------------------------------------------------------------------------------------- 
    35   /** 
    36    * TODO: comment 
    37    * 
    38    * @param name 
    39    */ 
    40   //----------------------------------------------------------------------------------------------- 
    41   SequenceImpl(String name) 
    42   { 
    43     super(name); 
    44   } 
     28    /** 
     29     * TODO: comment 
     30     *  
     31     * @param name 
     32     */ 
     33    Sequence(String name) { 
     34        super(name); 
     35    } 
    4536 
    46   //----------------------------------------------------------------------------------------------- 
    47   /* (non-Javadoc) 
    48    * @see de.ugoe.cs.tasktree.treeimpl.TaskTreeNodeImpl#clone() 
    49    */ 
    50   //----------------------------------------------------------------------------------------------- 
    51   @Override 
    52   public SequenceImpl clone() 
    53   { 
    54     return (SequenceImpl) super.clone(); 
    55   } 
     37    /* 
     38     * (non-Javadoc) 
     39     *  
     40     * @see de.ugoe.cs.tasktree.treeimpl.TaskTreeNodeImpl#clone() 
     41     */ 
     42    @Override 
     43    public Sequence clone() { 
     44        return (Sequence) super.clone(); 
     45    } 
    5646 
    5747} 

  • trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTree.java

    r498 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: TaskTree.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: patrick $  $Date: 21.02.2012 $ 
    … …  
    54// Creation  : 2012 by patrick 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
    87package de.ugoe.cs.quest.tasktrees.treeimpl; 
    98 
    … …  
    1110import java.util.Map; 
    1211 
    13 import de.ugoe.cs.quest.tasktrees.treeifc.NodeInfo; 
    14 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; 
    15 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 
     12import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeInfo; 
     13import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; 
     14import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 
    1615 
    17 //------------------------------------------------------------------------------------------------- 
    1816/** 
    1917 * TODO comment 
    … …  
    2220 * @author 2012, last modified by $Author: patrick$ 
    2321 */ 
    24 //------------------------------------------------------------------------------------------------- 
    25 public class TaskTreeImpl implements TaskTree 
    26 { 
    27   /** the map of nodes */ 
    28   private Map<TaskTreeNode, NodeInfo> mTaskMap; 
    29    
    30   /** the root node of the task tree */ 
    31   private TaskTreeNode mRootNode; 
    32    
    33   //----------------------------------------------------------------------------------------------- 
    34   /** 
    35    * TODO: comment 
    36    * 
    37    */ 
    38   //----------------------------------------------------------------------------------------------- 
    39   TaskTreeImpl(TaskTreeNode rootNode) 
    40   { 
    41     mRootNode = rootNode; 
    42   } 
     22public class TaskTree implements ITaskTree { 
     23     
     24    /** the map of nodes */ 
     25    private Map<ITaskTreeNode, ITaskTreeNodeInfo> taskMap; 
    4326 
    44   //----------------------------------------------------------------------------------------------- 
    45   /* (non-Javadoc) 
    46    * @see de.ugoe.cs.tasktree.treeifc.TaskTree#getRoot() 
    47    */ 
    48   //----------------------------------------------------------------------------------------------- 
    49   @Override 
    50   public TaskTreeNode getRoot() 
    51   { 
    52     return mRootNode; 
    53   } 
     27    /** the root node of the task tree */ 
     28    private ITaskTreeNode rootNode; 
    5429 
    55   //----------------------------------------------------------------------------------------------- 
    56   /* (non-Javadoc) 
    57    * @see de.ugoe.cs.tasktree.treeifc.TaskTree#getTaskMap() 
    58    */ 
    59   //----------------------------------------------------------------------------------------------- 
    60   @Override 
    61   public synchronized Map<TaskTreeNode, NodeInfo> getTaskMap() 
    62   { 
    63     if (mTaskMap == null) 
    64     { 
    65       mTaskMap = new HashMap<TaskTreeNode, NodeInfo>(); 
    66       addNodeToMap(mRootNode, null); 
     30    /** 
     31     * TODO: comment 
     32     *  
     33     */ 
     34    TaskTree(ITaskTreeNode rootNode) { 
     35        this.rootNode = rootNode; 
    6736    } 
    68     return mTaskMap; 
    69   } 
    7037 
    71   //----------------------------------------------------------------------------------------------- 
    72   /** 
    73    * TODO: comment 
    74    * 
    75    * @param rootNode 
    76    */ 
    77   //----------------------------------------------------------------------------------------------- 
    78   private void addNodeToMap(TaskTreeNode node, TaskTreeNode parent) 
    79   { 
    80     NodeInfoImpl nodeInfo = (NodeInfoImpl) mTaskMap.get(node); 
    81      
    82     if (nodeInfo == null) 
    83     { 
    84       nodeInfo = new NodeInfoImpl(node); 
    85       mTaskMap.put(node, nodeInfo); 
     38    /* 
     39     * (non-Javadoc) 
     40     *  
     41     * @see de.ugoe.cs.tasktree.treeifc.TaskTree#getRoot() 
     42     */ 
     43    @Override 
     44    public ITaskTreeNode getRoot() { 
     45        return rootNode; 
    8646    } 
    87      
    88     if (parent != null) 
    89     { 
    90       // through first removing an existing parent it is assured, that a parent is recorded 
    91       // only once. This is needed, because parent may be reused in a tree as well, but we always 
    92       // iterate the whole tree 
    93       nodeInfo.removeParent(parent); 
    94       nodeInfo.addParent(parent); 
     47 
     48    /* 
     49     * (non-Javadoc) 
     50     *  
     51     * @see de.ugoe.cs.tasktree.treeifc.TaskTree#getTaskMap() 
     52     */ 
     53    @Override 
     54    public synchronized Map<ITaskTreeNode, ITaskTreeNodeInfo> getTaskMap() { 
     55        if (taskMap == null) { 
     56            taskMap = new HashMap<ITaskTreeNode, ITaskTreeNodeInfo>(); 
     57            addNodeToMap(rootNode, null); 
     58        } 
     59        return taskMap; 
    9560    } 
    96      
    97     for (TaskTreeNode child : node.getChildren()) 
    98     { 
    99       addNodeToMap(child, node); 
     61 
     62    /** 
     63     * TODO: comment 
     64     *  
     65     * @param rootNode 
     66     */ 
     67    private void addNodeToMap(ITaskTreeNode node, ITaskTreeNode parent) { 
     68        NodeInfo nodeInfo = (NodeInfo) taskMap.get(node); 
     69 
     70        if (nodeInfo == null) { 
     71            nodeInfo = new NodeInfo(node); 
     72            taskMap.put(node, nodeInfo); 
     73        } 
     74 
     75        if (parent != null) { 
     76            // through first removing an existing parent it is assured, that a parent is recorded 
     77            // only once. This is needed, because parent may be reused in a tree as well, but we 
     78            // always iterate the whole tree 
     79            nodeInfo.removeParent(parent); 
     80            nodeInfo.addParent(parent); 
     81        } 
     82 
     83        for (ITaskTreeNode child : node.getChildren()) { 
     84            addNodeToMap(child, node); 
     85        } 
    10086    } 
    101   } 
    10287 
    103   //----------------------------------------------------------------------------------------------- 
    104   /* (non-Javadoc) 
    105    * @see java.lang.Object#clone() 
    106    */ 
    107   //----------------------------------------------------------------------------------------------- 
    108   @Override 
    109   public TaskTreeImpl clone() 
    110   { 
    111     TaskTreeImpl clone = null; 
    112     try 
    113     { 
    114       clone = (TaskTreeImpl) super.clone(); 
    115        
    116       clone.mRootNode = mRootNode.clone(); 
    117        
    118       // the clone will create the task map itself, when it is first retrieved 
    119       clone.mTaskMap = null; 
    120        
     88    /* 
     89     * (non-Javadoc) 
     90     *  
     91     * @see java.lang.Object#clone() 
     92     */ 
     93    @Override 
     94    public TaskTree clone() { 
     95        TaskTree clone = null; 
     96        try { 
     97            clone = (TaskTree) super.clone(); 
     98 
     99            clone.rootNode = rootNode.clone(); 
     100 
     101            // the clone will create the task map itself, when it is first retrieved 
     102            clone.taskMap = null; 
     103 
     104        } 
     105        catch (CloneNotSupportedException e) { 
     106            // this should never happen. Therefore simply dump the exception 
     107            e.printStackTrace(); 
     108        } 
     109 
     110        return clone; 
    121111    } 
    122     catch (CloneNotSupportedException e) 
    123     { 
    124       // this should never happen. Therefore simply dump the exception 
    125       e.printStackTrace(); 
    126     } 
    127      
    128     return clone; 
    129   } 
    130112 
    131113} 

  • trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeBuilder.java

    r498 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: TaskTreeBuilderImpl.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: patrick $  $Date: 21.02.2012 $ 
    … …  
    54// Creation  : 2012 by patrick 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
    87package de.ugoe.cs.quest.tasktrees.treeimpl; 
    98 
    10 import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; 
    11 import de.ugoe.cs.quest.tasktrees.treeifc.Selection; 
    12 import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; 
    13 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeBuilder; 
    14 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 
    15 import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; 
     9import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; 
     10import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; 
     11import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; 
     12import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeBuilder; 
     13import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 
     14import de.ugoe.cs.quest.tasktrees.treeifc.ITextInputEventTask; 
    1615 
    17 //------------------------------------------------------------------------------------------------- 
    1816/** 
    1917 * TODO comment 
    … …  
    2220 * @author 2012, last modified by $Author: patrick$ 
    2321 */ 
    24 //------------------------------------------------------------------------------------------------- 
    25 public class TaskTreeBuilderImpl implements TaskTreeBuilder 
    26 { 
    27   //----------------------------------------------------------------------------------------------- 
    28   /* (non-Javadoc) 
    29    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(Sequence, TaskTreeNode) 
    30    */ 
    31   //----------------------------------------------------------------------------------------------- 
    32   @Override 
    33   public void addChild(Sequence parent, TaskTreeNode child) 
    34   { 
    35     if (!(parent instanceof SequenceImpl)) 
    36     { 
    37       throw new IllegalArgumentException 
    38         ("illegal type of task tree node provided: " + parent.getClass()); 
     22public class TaskTreeBuilder implements ITaskTreeBuilder { 
     23 
     24    /* 
     25     * (non-Javadoc) 
     26     *  
     27     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(Sequence, TaskTreeNode) 
     28     */ 
     29    @Override 
     30    public void addChild(ISequence parent, ITaskTreeNode child) { 
     31        if (!(parent instanceof Sequence)) { 
     32            throw new IllegalArgumentException 
     33                ("illegal type of task tree node provided: " + parent.getClass()); 
     34        } 
     35 
     36        addChildInternal(parent, -1, child); 
    3937    } 
    4038 
    41     addChildInternal(parent, -1, child); 
    42   } 
     39    /* 
     40     * (non-Javadoc) 
     41     *  
     42     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(Sequence, int, TaskTreeNode) 
     43     */ 
     44    @Override 
     45    public void addChild(ISequence parent, int index, ITaskTreeNode child) { 
     46        if (!(parent instanceof Sequence)) { 
     47            throw new IllegalArgumentException 
     48                ("illegal type of task tree node provided: " + parent.getClass()); 
     49        } 
    4350 
    44   //----------------------------------------------------------------------------------------------- 
    45   /* (non-Javadoc) 
    46    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(Sequence, int, TaskTreeNode) 
    47    */ 
    48   //----------------------------------------------------------------------------------------------- 
    49   @Override 
    50   public void addChild(Sequence parent, int index, TaskTreeNode child) 
    51   { 
    52     if (!(parent instanceof SequenceImpl)) 
    53     { 
    54       throw new IllegalArgumentException 
    55         ("illegal type of task tree node provided: " + parent.getClass()); 
     51        addChildInternal(parent, index, child); 
    5652    } 
    5753 
    58     addChildInternal(parent, index, child); 
    59   } 
     54    /* 
     55     * (non-Javadoc) 
     56     *  
     57     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(Selection, TaskTreeNode) 
     58     */ 
     59    @Override 
     60    public void addChild(ISelection parent, ITaskTreeNode child) { 
     61        if (!(parent instanceof Selection)) { 
     62            throw new IllegalArgumentException 
     63                ("illegal type of task tree node provided: " + parent.getClass()); 
     64        } 
    6065 
    61   //----------------------------------------------------------------------------------------------- 
    62   /* (non-Javadoc) 
    63    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(Selection, TaskTreeNode) 
    64    */ 
    65   //----------------------------------------------------------------------------------------------- 
    66   @Override 
    67   public void addChild(Selection parent, TaskTreeNode child) 
    68   { 
    69     if (!(parent instanceof SelectionImpl)) 
    70     { 
    71       throw new IllegalArgumentException 
    72         ("illegal type of task tree node provided: " + parent.getClass()); 
     66        addChildInternal(parent, -1, child); 
    7367    } 
    7468 
    75     addChildInternal(parent, -1, child); 
    76   } 
     69    /* 
     70     * (non-Javadoc) 
     71     *  
     72     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(de.ugoe.cs.tasktree.treeifc. 
     73     * TextInputEventTask, de.ugoe.cs.tasktree.treeifc.TaskTreeNode) 
     74     */ 
     75    @Override 
     76    public void addChild(ITextInputEventTask parent, ITaskTreeNode child) { 
     77        if (!(parent instanceof TextInputEventTask)) { 
     78            throw new IllegalArgumentException 
     79                ("illegal type of task tree node provided: " + parent.getClass()); 
     80        } 
    7781 
    78   //----------------------------------------------------------------------------------------------- 
    79   /* (non-Javadoc) 
    80    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#addChild(de.ugoe.cs.tasktree.treeifc.TextInputInteractionTask, de.ugoe.cs.tasktree.treeifc.TaskTreeNode) 
    81    */ 
    82   //----------------------------------------------------------------------------------------------- 
    83   @Override 
    84   public void addChild(TextInputInteractionTask parent, TaskTreeNode child) 
    85   { 
    86     if (!(parent instanceof TextInputInteractionTaskImpl)) 
    87     { 
    88       throw new IllegalArgumentException 
    89         ("illegal type of task tree node provided: " + parent.getClass()); 
     82        addChildInternal(parent, -1, child); 
    9083    } 
    9184 
    92     addChildInternal(parent, -1, child); 
    93   } 
     85    /* 
     86     * (non-Javadoc) 
     87     *  
     88     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#setChild(Iteration, TaskTreeNode) 
     89     */ 
     90    @Override 
     91    public void setChild(IIteration iteration, ITaskTreeNode newChild) { 
     92        if (!(iteration instanceof Iteration)) { 
     93            throw new IllegalArgumentException 
     94                ("illegal type of iteration provided: " + iteration.getClass()); 
     95        } 
    9496 
    95   //----------------------------------------------------------------------------------------------- 
    96   /* (non-Javadoc) 
    97    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#setChild(Iteration, TaskTreeNode) 
    98    */ 
    99   //----------------------------------------------------------------------------------------------- 
    100   @Override 
    101   public void setChild(Iteration iteration, TaskTreeNode newChild) 
    102   { 
    103     if (!(iteration instanceof IterationImpl)) 
    104     { 
    105       throw new IllegalArgumentException 
    106         ("illegal type of iteration provided: " + iteration.getClass()); 
     97        if (!(newChild instanceof TaskTreeNode)) { 
     98            throw new IllegalArgumentException 
     99                ("illegal type of task tree node provided: " + newChild.getClass()); 
     100        } 
     101 
     102        ((Iteration) iteration).setChild(newChild); 
    107103    } 
    108104 
    109     if (!(newChild instanceof TaskTreeNodeImpl)) 
    110     { 
    111       throw new IllegalArgumentException 
    112         ("illegal type of task tree node provided: " + newChild.getClass()); 
    113     } 
    114      
    115     ((IterationImpl) iteration).setChild(determineNode(newChild)); 
    116   } 
     105    /* 
     106     * (non-Javadoc) 
     107     *  
     108     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#removeChild(Sequence, int) 
     109     */ 
     110    @Override 
     111    public void removeChild(ISequence parent, int index) { 
     112        if (!(parent instanceof TaskTreeNode)) { 
     113            throw new IllegalArgumentException 
     114                ("illegal type of task tree node provided: " + parent.getClass()); 
     115        } 
    117116 
    118   //----------------------------------------------------------------------------------------------- 
    119   /* (non-Javadoc) 
    120    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#removeChild(Sequence, int) 
    121    */ 
    122   //----------------------------------------------------------------------------------------------- 
    123   @Override 
    124   public void removeChild(Sequence parent, int index) 
    125   { 
    126     if (!(parent instanceof TaskTreeNodeImpl)) 
    127     { 
    128       throw new IllegalArgumentException 
    129         ("illegal type of task tree node provided: " + parent.getClass()); 
     117        ((TaskTreeNode) parent).removeChild(index); 
    130118    } 
    131119 
    132     ((TaskTreeNodeImpl) parent).removeChild(index); 
    133   } 
     120    /* 
     121     * (non-Javadoc) 
     122     *  
     123     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#removeChild(Selection, TaskTreeNode) 
     124     */ 
     125    @Override 
     126    public void removeChild(ISelection parent, ITaskTreeNode child) { 
     127        if (!(parent instanceof TaskTreeNode)) { 
     128            throw new IllegalArgumentException 
     129                ("illegal type of task tree node provided: " + parent.getClass()); 
     130        } 
    134131 
    135   //----------------------------------------------------------------------------------------------- 
    136   /* (non-Javadoc) 
    137    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#removeChild(Selection, TaskTreeNode) 
    138    */ 
    139   //----------------------------------------------------------------------------------------------- 
    140   @Override 
    141   public void removeChild(Selection parent, TaskTreeNode child) 
    142   { 
    143     if (!(parent instanceof TaskTreeNodeImpl)) 
    144     { 
    145       throw new IllegalArgumentException 
    146         ("illegal type of task tree node provided: " + parent.getClass()); 
     132        for (int i = 0; i < parent.getChildren().size(); i++) { 
     133            if ((parent.getChildren().get(i) == child) || 
     134                ((parent.getChildren().get(i) != null) && 
     135                 (parent.getChildren().get(i).equals(child)))) 
     136            { 
     137                ((TaskTreeNode) parent).removeChild(i); 
     138                break; 
     139            } 
     140        } 
    147141    } 
    148142 
    149     for (int i = 0; i < parent.getChildren().size(); i++) 
    150     { 
    151       if ((parent.getChildren().get(i) == child) || 
    152           ((parent.getChildren().get(i) != null) && (parent.getChildren().get(i).equals(child)))) 
    153       { 
    154         ((TaskTreeNodeImpl) parent).removeChild(i); 
    155         break; 
    156       } 
    157     } 
    158   } 
     143    /* 
     144     * (non-Javadoc) 
     145     *  
     146     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#setDescription(TaskTreeNode, String) 
     147     */ 
     148    @Override 
     149    public void setDescription(ITaskTreeNode parent, String description) { 
     150        if (!(parent instanceof TaskTreeNode)) { 
     151            throw new IllegalArgumentException 
     152                ("illegal type of task tree node provided: " + parent.getClass()); 
     153        } 
    159154 
    160   //----------------------------------------------------------------------------------------------- 
    161   /* (non-Javadoc) 
    162    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeBuilder#setDescription(TaskTreeNode, String) 
    163    */ 
    164   //----------------------------------------------------------------------------------------------- 
    165   @Override 
    166   public void setDescription(TaskTreeNode parent, String description) 
    167   { 
    168     if (!(parent instanceof TaskTreeNodeImpl)) 
    169     { 
    170       throw new IllegalArgumentException 
    171         ("illegal type of task tree node provided: " + parent.getClass()); 
     155        ((TaskTreeNode) parent).setDescription(description); 
    172156    } 
    173157 
    174     ((TaskTreeNodeImpl) parent).setDescription(description); 
    175   } 
    176  
    177   //----------------------------------------------------------------------------------------------- 
    178   /** 
     158    /** 
    179159   *  
    180160   */ 
    181   //----------------------------------------------------------------------------------------------- 
    182   private void addChildInternal(TaskTreeNode parent, int index, TaskTreeNode child) 
    183   { 
    184     if (!(child instanceof TaskTreeNodeImpl)) 
    185     { 
    186       throw new IllegalArgumentException 
    187         ("illegal type of task tree node provided: " + child.getClass()); 
     161    private void addChildInternal(ITaskTreeNode parent, int index, ITaskTreeNode child) { 
     162        if (!(child instanceof TaskTreeNode)) { 
     163            throw new IllegalArgumentException 
     164                ("illegal type of task tree node provided: " + child.getClass()); 
     165        } 
     166 
     167        if (index > -1) { 
     168            ((TaskTreeNode) parent).addChild(index, child); 
     169        } 
     170        else { 
     171            ((TaskTreeNode) parent).addChild(child); 
     172        } 
    188173    } 
    189      
    190     if (index > -1) 
    191     { 
    192       ((TaskTreeNodeImpl) parent).addChild(index, determineNode(child)); 
    193     } 
    194     else 
    195     { 
    196       ((TaskTreeNodeImpl) parent).addChild(determineNode(child)); 
    197     } 
    198   } 
    199  
    200   //----------------------------------------------------------------------------------------------- 
    201   /** 
    202    * TODO: comment 
    203    * 
    204    * @param newChild 
    205    * @return 
    206    */ 
    207   //----------------------------------------------------------------------------------------------- 
    208   private TaskTreeNode determineNode(TaskTreeNode newNode) 
    209   { 
    210     return newNode; 
    211     /*TaskTreeNode node = mTaskMap.get(newNode); 
    212     if (node == null) 
    213     { 
    214       node = newNode; 
    215       mTaskMap.put(node, node); 
    216     } 
    217      
    218     return node;*/ 
    219   } 
    220174 
    221175} 

  • trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeNode.java

    r498 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: TreeNode.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: Patrick $  $Date: 06.11.2011 11:00:46 $ 
    … …  
    54// Creation  : 2011 by Patrick 
    65// Copyright : Patrick Harms, 2011 
    7 //------------------------------------------------------------------------------------------------- 
    86 
    97package de.ugoe.cs.quest.tasktrees.treeimpl; 
    … …  
    1210import java.util.List; 
    1311 
    14 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 
    15  
    16  
    17 //------------------------------------------------------------------------------------------------- 
     12import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 
     13 
    1814/** 
    1915 * TODO comment 
    20  * 
     16 *  
    2117 * @version $Revision: $ $Date: $ 
    22  * @author  2011, last modified by $Author: $ 
     18 * @author 2011, last modified by $Author: $ 
    2319 */ 
    24 //------------------------------------------------------------------------------------------------- 
    25 public class TaskTreeNodeImpl implements TaskTreeNode 
    26 { 
    27   /** */ 
    28   private static int sTemporalId = 0; 
    29  
    30   /** */ 
    31   private String mName; 
    32  
    33   /** */ 
    34   private String mDescription; 
    35    
    36   /** */ 
    37   private int mId; 
    38    
    39   /** children */ 
    40   private List<TaskTreeNode> mChildren; 
    41  
    42   //----------------------------------------------------------------------------------------------- 
    43   /** 
    44    */ 
    45   //----------------------------------------------------------------------------------------------- 
    46   TaskTreeNodeImpl(String name) 
    47   { 
    48     mName = name; 
    49     mId = getNewId(); 
    50   } 
    51    
    52   //----------------------------------------------------------------------------------------------- 
    53   /** 
    54    * TODO: comment 
    55    * 
    56    * @return 
    57    */ 
    58   //----------------------------------------------------------------------------------------------- 
    59   private static synchronized int getNewId() 
    60   { 
    61     if (sTemporalId == Integer.MAX_VALUE) 
    62     { 
    63       sTemporalId = 0; 
    64     } 
    65      
    66     return sTemporalId++; 
    67   } 
    68  
    69   //----------------------------------------------------------------------------------------------- 
    70   /** 
    71    * @return Returns the name. 
    72    */ 
    73   //----------------------------------------------------------------------------------------------- 
    74   public String getName() 
    75   { 
    76     return mName; 
    77   } 
    78  
    79   //----------------------------------------------------------------------------------------------- 
    80   /* (non-Javadoc) 
    81    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#getDescription() 
    82    */ 
    83   //----------------------------------------------------------------------------------------------- 
    84   @Override 
    85   public String getDescription() 
    86   { 
    87     return mDescription; 
    88   } 
    89  
    90   //----------------------------------------------------------------------------------------------- 
    91   /** 
    92    */ 
    93   //----------------------------------------------------------------------------------------------- 
    94   public synchronized List<TaskTreeNode> getChildren() 
    95   { 
    96     if ((mChildren == null) || (mChildren.size() == 0)) 
    97     { 
    98       return new ArrayList<TaskTreeNode>(); 
    99     } 
    100      
    101     return mChildren.subList(0, mChildren.size()); 
    102   } 
    103    
    104   //----------------------------------------------------------------------------------------------- 
    105   /* (non-Javadoc) 
    106    * @see de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode#equals(TaskTreeNode) 
    107    */ 
    108   //----------------------------------------------------------------------------------------------- 
    109   @Override 
    110   public boolean equals(TaskTreeNode taskTreeNode) 
    111   { 
    112     if (!this.getClass().isInstance(taskTreeNode)) 
    113     { 
    114       return false; 
    115     } 
    116      
    117     if (taskTreeNode.hashCode() != hashCode()) 
    118     { 
    119       return false; 
    120     } 
    121      
    122     TaskTreeNodeImpl other = (TaskTreeNodeImpl) taskTreeNode; 
    123      
    124     if (mId != other.mId) 
    125     { 
    126       return false; 
    127     } 
    128      
    129     if (!mName.equals(other.mName)) 
    130     { 
    131       return false; 
    132     } 
    133      
    134     synchronized (other) 
    135     { 
    136       if (mChildren == null) 
    137       { 
    138         return (other.mChildren == null); 
    139       } 
    140       else if (other.mChildren == null) 
    141       { 
    142         return (mChildren == null); 
    143       } 
    144       else if (other.mChildren.size() != mChildren.size()) 
    145       { 
    146         return false; 
    147       } 
    148        
    149       for (int i = 0; i < mChildren.size(); i++) 
    150       { 
    151         if (!mChildren.get(i).equals(other.mChildren.get(i))) 
    152         { 
    153           return false; 
    154         } 
    155       } 
    156     } 
    157  
    158     return true; 
    159   } 
    160  
    161   //----------------------------------------------------------------------------------------------- 
    162   /* (non-Javadoc) 
    163    * @see java.lang.Object#hashCode() 
    164    */ 
    165   //----------------------------------------------------------------------------------------------- 
    166   @Override 
    167   public synchronized int hashCode() 
    168   { 
    169     return getClass().getSimpleName().hashCode(); 
    170   } 
    171  
    172   //----------------------------------------------------------------------------------------------- 
    173   /* (non-Javadoc) 
    174    * @see java.lang.Object#toString() 
    175    */ 
    176   //----------------------------------------------------------------------------------------------- 
    177   @Override 
    178   public synchronized String toString() 
    179   { 
    180     if (mChildren == null) 
    181     { 
    182       return mName + "(" + mId + ")"; 
    183     } 
    184     else 
    185     { 
    186       return mName + "(" + mId + ", " + mChildren.size() + " children)"; 
    187     } 
    188   } 
    189    
    190   //----------------------------------------------------------------------------------------------- 
    191   /** 
    192    * TODO: comment 
    193    * 
    194    * @param i 
    195    * @return  
    196    */ 
    197   //----------------------------------------------------------------------------------------------- 
    198   void setDescription(String description) 
    199   { 
    200     mDescription = description; 
    201   } 
    202  
    203   //----------------------------------------------------------------------------------------------- 
    204   /** 
    205    */ 
    206   //----------------------------------------------------------------------------------------------- 
    207   synchronized void addChild(TaskTreeNode child) 
    208   { 
    209     if (mChildren == null) 
    210     { 
    211       mChildren = new ArrayList<TaskTreeNode>(); 
    212     } 
    213      
    214     mChildren.add(child); 
    215   } 
    216    
    217   //----------------------------------------------------------------------------------------------- 
    218   /** 
    219    */ 
    220   //----------------------------------------------------------------------------------------------- 
    221   synchronized void addChild(int index, TaskTreeNode child) 
    222   { 
    223     if (mChildren == null) 
    224     { 
    225       mChildren = new ArrayList<TaskTreeNode>(); 
    226     } 
    227      
    228     mChildren.add(index, child); 
    229   } 
    230    
    231   //----------------------------------------------------------------------------------------------- 
    232   /** 
    233    * TODO: comment 
    234    * 
    235    * @param i 
    236    * @return  
    237    */ 
    238   //----------------------------------------------------------------------------------------------- 
    239   synchronized TaskTreeNode removeChild(int index) 
    240   { 
    241     return mChildren.remove(index); 
    242   } 
    243  
    244   //----------------------------------------------------------------------------------------------- 
    245   /* (non-Javadoc) 
    246    * @see java.lang.Object#clone() 
    247    */ 
    248   //----------------------------------------------------------------------------------------------- 
    249   @Override 
    250   public TaskTreeNode clone() 
    251   { 
    252     TaskTreeNodeImpl clone = null; 
    253     try 
    254     { 
    255       clone = (TaskTreeNodeImpl) super.clone(); 
    256        
    257       if (mChildren != null) 
    258       { 
    259         clone.mChildren = new ArrayList<TaskTreeNode>(); 
    260        
    261         for (TaskTreeNode child : mChildren) 
    262         { 
    263           clone.mChildren.add(child.clone()); 
    264         } 
    265       } 
    266        
    267     } 
    268     catch (CloneNotSupportedException e) 
    269     { 
    270       // this should never happen. Therefore simply dump the exception 
    271       e.printStackTrace(); 
    272     } 
    273      
    274     return clone; 
    275   } 
     20public class TaskTreeNode implements ITaskTreeNode { 
     21    /** */ 
     22    private static int temporalId = 0; 
     23 
     24    /** */ 
     25    private String name; 
     26 
     27    /** */ 
     28    private String description; 
     29 
     30    /** */ 
     31    private int id; 
     32 
     33    /** children */ 
     34    private List<ITaskTreeNode> children; 
     35 
     36    /** 
     37     *  
     38     */ 
     39    public TaskTreeNode(String name) { 
     40        this.name = name; 
     41        id = getNewId(); 
     42    } 
     43 
     44    /** 
     45     * TODO: comment 
     46     *  
     47     * @return 
     48     */ 
     49    private static synchronized int getNewId() { 
     50        if (temporalId == Integer.MAX_VALUE) { 
     51            temporalId = 0; 
     52        } 
     53 
     54        return temporalId++; 
     55    } 
     56 
     57    /** 
     58     * @return Returns the name. 
     59     */ 
     60    public String getName() { 
     61        return name; 
     62    } 
     63 
     64    /* 
     65     * (non-Javadoc) 
     66     *  
     67     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNode#getDescription() 
     68     */ 
     69    @Override 
     70    public String getDescription() { 
     71        return description; 
     72    } 
     73 
     74    /** 
     75     *  
     76     */ 
     77    public synchronized List<ITaskTreeNode> getChildren() { 
     78        if ((children == null) || (children.size() == 0)) { 
     79            return new ArrayList<ITaskTreeNode>(); 
     80        } 
     81 
     82        return children.subList(0, children.size()); 
     83    } 
     84 
     85    /* 
     86     * (non-Javadoc) 
     87     *  
     88     * @see de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode#equals(TaskTreeNode) 
     89     */ 
     90    @Override 
     91    public boolean equals(ITaskTreeNode taskTreeNode) { 
     92        if (!this.getClass().isInstance(taskTreeNode)) { 
     93            return false; 
     94        } 
     95 
     96        if (taskTreeNode.hashCode() != hashCode()) { 
     97            return false; 
     98        } 
     99 
     100        TaskTreeNode other = (TaskTreeNode) taskTreeNode; 
     101 
     102        if (id != other.id) { 
     103            return false; 
     104        } 
     105 
     106        if (!name.equals(other.name)) { 
     107            return false; 
     108        } 
     109 
     110        synchronized (other) { 
     111            if (children == null) { 
     112                return (other.children == null); 
     113            } 
     114            else if (other.children == null) { 
     115                return (children == null); 
     116            } 
     117            else if (other.children.size() != children.size()) { 
     118                return false; 
     119            } 
     120 
     121            for (int i = 0; i < children.size(); i++) { 
     122                if (!children.get(i).equals(other.children.get(i))) { 
     123                    return false; 
     124                } 
     125            } 
     126        } 
     127 
     128        return true; 
     129    } 
     130 
     131    /* 
     132     * (non-Javadoc) 
     133     *  
     134     * @see java.lang.Object#hashCode() 
     135     */ 
     136    @Override 
     137    public synchronized int hashCode() { 
     138        return getClass().getSimpleName().hashCode(); 
     139    } 
     140 
     141    /* 
     142     * (non-Javadoc) 
     143     *  
     144     * @see java.lang.Object#toString() 
     145     */ 
     146    @Override 
     147    public synchronized String toString() { 
     148        if (children == null) { 
     149            return name + "(" + id + ")"; 
     150        } 
     151        else { 
     152            return name + "(" + id + ", " + children.size() + " children)"; 
     153        } 
     154    } 
     155 
     156    /** 
     157     * TODO: comment 
     158     *  
     159     * @param i 
     160     * @return 
     161     */ 
     162    void setDescription(String description) { 
     163        this.description = description; 
     164    } 
     165 
     166    /** 
     167     *  
     168     */ 
     169    synchronized void addChild(ITaskTreeNode child) { 
     170        if (children == null) { 
     171            children = new ArrayList<ITaskTreeNode>(); 
     172        } 
     173 
     174        children.add(child); 
     175    } 
     176 
     177    /** 
     178     *  
     179     */ 
     180    synchronized void addChild(int index, ITaskTreeNode child) { 
     181        if (children == null) { 
     182            children = new ArrayList<ITaskTreeNode>(); 
     183        } 
     184 
     185        children.add(index, child); 
     186    } 
     187 
     188    /** 
     189     * TODO: comment 
     190     *  
     191     * @param i 
     192     * @return 
     193     */ 
     194    synchronized ITaskTreeNode removeChild(int index) { 
     195        return children.remove(index); 
     196    } 
     197 
     198    /* 
     199     * (non-Javadoc) 
     200     *  
     201     * @see java.lang.Object#clone() 
     202     */ 
     203    @Override 
     204    public ITaskTreeNode clone() { 
     205        TaskTreeNode clone = null; 
     206        try { 
     207            clone = (TaskTreeNode) super.clone(); 
     208 
     209            if (children != null) { 
     210                clone.children = new ArrayList<ITaskTreeNode>(); 
     211 
     212                for (ITaskTreeNode child : children) { 
     213                    clone.children.add(child.clone()); 
     214                } 
     215            } 
     216 
     217        } 
     218        catch (CloneNotSupportedException e) { 
     219            // this should never happen. Therefore simply dump the exception 
     220            e.printStackTrace(); 
     221        } 
     222 
     223        return clone; 
     224    } 
    276225 
    277226} 

  • trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TaskTreeNodeFactory.java

    r498 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: TaskTreeNodeFactoryImpl.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: patrick $  $Date: 21.02.2012 $ 
    … …  
    54// Creation  : 2012 by patrick 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
     7 
    88package de.ugoe.cs.quest.tasktrees.treeimpl; 
    99 
    10 import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; 
    11 import de.ugoe.cs.quest.eventcore.userinteraction.Interaction; 
    12 import de.ugoe.cs.quest.tasktrees.treeifc.InteractionTask; 
    13 import de.ugoe.cs.quest.tasktrees.treeifc.Iteration; 
    14 import de.ugoe.cs.quest.tasktrees.treeifc.Selection; 
    15 import de.ugoe.cs.quest.tasktrees.treeifc.Sequence; 
    16 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; 
    17 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 
    18 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNodeFactory; 
    19 import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; 
     10import de.ugoe.cs.quest.eventcore.IEventTarget; 
     11import de.ugoe.cs.quest.eventcore.IEventType; 
     12import de.ugoe.cs.quest.tasktrees.treeifc.IEventTask; 
     13import de.ugoe.cs.quest.tasktrees.treeifc.IIteration; 
     14import de.ugoe.cs.quest.tasktrees.treeifc.ISelection; 
     15import de.ugoe.cs.quest.tasktrees.treeifc.ISequence; 
     16import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; 
     17import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 
     18import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNodeFactory; 
     19import de.ugoe.cs.quest.tasktrees.treeifc.ITextInputEventTask; 
    2020 
    21 //------------------------------------------------------------------------------------------------- 
    2221/** 
    2322 * TODO comment 
    … …  
    2625 * @author 2012, last modified by $Author: patrick$ 
    2726 */ 
    28 //------------------------------------------------------------------------------------------------- 
    29 public class TaskTreeNodeFactoryImpl implements TaskTreeNodeFactory 
    30 { 
     27public class TaskTreeNodeFactory implements ITaskTreeNodeFactory { 
    3128 
    32   //----------------------------------------------------------------------------------------------- 
    33   /* (non-Javadoc) 
    34    * @see TaskTreeNodeFactory#createNewInteractionTask(GUIElement, Interaction) 
    35    */ 
    36   //----------------------------------------------------------------------------------------------- 
    37   @Override 
    38   public InteractionTask createNewInteractionTask(GUIElement  guiElement, 
    39                                                   Interaction interaction) 
    40   { 
    41     return new InteractionTaskImpl(guiElement, interaction); 
    42   } 
     29    /* 
     30     * (non-Javadoc) 
     31     *  
     32     * @see TaskTreeNodeFactory#createNewEventTask(IEventType, IEventTarget) 
     33     */ 
     34    @Override 
     35    public IEventTask createNewEventTask(IEventType eventType, IEventTarget eventTarget) { 
     36        return new EventTask(eventType, eventTarget); 
     37    } 
    4338 
    44   //----------------------------------------------------------------------------------------------- 
    45   /* (non-Javadoc) 
    46    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewSequence() 
    47    */ 
    48   //----------------------------------------------------------------------------------------------- 
    49   @Override 
    50   public Sequence createNewSequence() 
    51   { 
    52     return new SequenceImpl(); 
    53   } 
     39    /* 
     40     * (non-Javadoc) 
     41     *  
     42     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewSequence() 
     43     */ 
     44    @Override 
     45    public ISequence createNewSequence() { 
     46        return new Sequence(); 
     47    } 
    5448 
    55   //----------------------------------------------------------------------------------------------- 
    56   /* (non-Javadoc) 
    57    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewTextInputInteractionTask() 
    58    */ 
    59   //----------------------------------------------------------------------------------------------- 
    60   @Override 
    61   public TextInputInteractionTask createNewTextInputInteractionTask(GUIElement guiElement) 
    62   { 
    63     return new TextInputInteractionTaskImpl(guiElement); 
    64   } 
     49    /* 
     50     * (non-Javadoc) 
     51     *  
     52     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewTextInputEventTask(eventTarget) 
     53     */ 
     54    @Override 
     55    public ITextInputEventTask createNewTextInputEventTask(IEventTarget eventTarget) { 
     56        return new TextInputEventTask(eventTarget); 
     57    } 
    6558 
    66   //----------------------------------------------------------------------------------------------- 
    67   /* (non-Javadoc) 
    68    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewIteration() 
    69    */ 
    70   //----------------------------------------------------------------------------------------------- 
    71   @Override 
    72   public Iteration createNewIteration() 
    73   { 
    74     return new IterationImpl(); 
    75   } 
     59    /* 
     60     * (non-Javadoc) 
     61     *  
     62     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewIteration() 
     63     */ 
     64    @Override 
     65    public IIteration createNewIteration() { 
     66        return new Iteration(); 
     67    } 
    7668 
    77   //----------------------------------------------------------------------------------------------- 
    78   /* (non-Javadoc) 
    79    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewSelection() 
    80    */ 
    81   //----------------------------------------------------------------------------------------------- 
    82   @Override 
    83   public Selection createNewSelection() 
    84   { 
    85     return new SelectionImpl(); 
    86   } 
     69    /* 
     70     * (non-Javadoc) 
     71     *  
     72     * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createNewSelection() 
     73     */ 
     74    @Override 
     75    public ISelection createNewSelection() { 
     76        return new Selection(); 
     77    } 
    8778 
    88   //----------------------------------------------------------------------------------------------- 
    89   /* (non-Javadoc) 
    90    * @see de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createTaskTree(de.ugoe.cs.tasktree.treeifc.TaskTreeNode) 
    91    */ 
    92   //----------------------------------------------------------------------------------------------- 
    93   @Override 
    94   public TaskTree createTaskTree(TaskTreeNode root) 
    95   { 
    96     return new TaskTreeImpl(root); 
    97   } 
     79    /* 
     80     * (non-Javadoc) 
     81     *  
     82     * @see 
     83     * de.ugoe.cs.tasktree.treeifc.TaskTreeNodeFactory#createTaskTree(de.ugoe.cs.tasktree.treeifc 
     84     * .TaskTreeNode) 
     85     */ 
     86    @Override 
     87    public ITaskTree createTaskTree(ITaskTreeNode root) { 
     88        return new TaskTree(root); 
     89    } 
    9890 
    9991} 

  • trunk/quest-core-tasktrees/src/main/java/de/ugoe/cs/quest/tasktrees/treeimpl/TextInputEventTask.java

    r498 r557  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: TextInputSequenceImpl.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: patrick $  $Date: 10.06.2012 $ 
    … …  
    54// Creation  : 2012 by patrick 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
    87package de.ugoe.cs.quest.tasktrees.treeimpl; 
    98 
    10 import de.ugoe.cs.quest.eventcore.guimodel.GUIElement; 
    11 import de.ugoe.cs.quest.eventcore.userinteraction.TextInput; 
    12 import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; 
     9import de.ugoe.cs.quest.eventcore.IEventTarget; 
     10import de.ugoe.cs.quest.eventcore.gui.TextInput; 
     11import de.ugoe.cs.quest.tasktrees.treeifc.ITextInputEventTask; 
    1312 
    14 //------------------------------------------------------------------------------------------------- 
    1513/** 
    1614 * TODO comment 
    … …  
    1917 * @author 2012, last modified by $Author: patrick$ 
    2018 */ 
    21 //------------------------------------------------------------------------------------------------- 
    22 public class TextInputInteractionTaskImpl extends InteractionTaskImpl 
    23   implements TextInputInteractionTask 
    24 { 
     19public class TextInputEventTask extends EventTask implements ITextInputEventTask { 
    2520 
    26   /** the text, that was finally entered in this sequence without all backspaces, etc. */ 
    27   private String mEnteredText; 
    28    
    29   //----------------------------------------------------------------------------------------------- 
    30   /** 
    31    * TODO: comment 
    32    * 
    33    * @param name 
    34    */ 
    35   //----------------------------------------------------------------------------------------------- 
    36   TextInputInteractionTaskImpl(GUIElement guiElement) 
    37   { 
    38     super(guiElement, new TextInput()); 
    39   } 
     21    /** the text, that was finally entered in this sequence without all backspaces, etc. */ 
     22    private String enteredText; 
    4023 
    41   //----------------------------------------------------------------------------------------------- 
    42   /* (non-Javadoc) 
    43    * @see de.ugoe.cs.tasktree.treeimpl.TaskTreeNodeImpl#clone() 
    44    */ 
    45   //----------------------------------------------------------------------------------------------- 
    46   @Override 
    47   public TextInputInteractionTaskImpl clone() 
    48   { 
    49     // entered text is unchangeable and does not need to be cloned 
    50     return (TextInputInteractionTaskImpl) super.clone(); 
    51   } 
     24    /** 
     25     * TODO: comment 
     26     *  
     27     * @param name 
     28     */ 
     29    TextInputEventTask(IEventTarget eventTarget) { 
     30        super(new TextInput(), eventTarget); 
     31    } 
    5232 
    53   //----------------------------------------------------------------------------------------------- 
    54   /* (non-Javadoc) 
    55    * @see de.ugoe.cs.tasktree.treeifc.TextInputSequence#getEnteredText() 
    56    */ 
    57   //----------------------------------------------------------------------------------------------- 
    58   @Override 
    59   public String getEnteredText() 
    60   { 
    61     return mEnteredText; 
    62   } 
     33    /* 
     34     * (non-Javadoc) 
     35     *  
     36     * @see de.ugoe.cs.tasktree.treeimpl.TaskTreeNodeImpl#clone() 
     37     */ 
     38    @Override 
     39    public TextInputEventTask clone() { 
     40        // entered text is unchangeable and does not need to be cloned 
     41        return (TextInputEventTask) super.clone(); 
     42    } 
    6343 
    64   //----------------------------------------------------------------------------------------------- 
    65   /* (non-Javadoc) 
    66    * @see de.ugoe.cs.tasktree.treeifc.TextInputSequence#setEnteredText(java.lang.String) 
    67    */ 
    68   //----------------------------------------------------------------------------------------------- 
    69   @Override 
    70   public void setEnteredText(String text) 
    71   { 
    72     mEnteredText = text; 
    73   } 
     44    /* 
     45     * (non-Javadoc) 
     46     *  
     47     * @see de.ugoe.cs.tasktree.treeifc.TextInputSequence#getEnteredText() 
     48     */ 
     49    @Override 
     50    public String getEnteredText() { 
     51        return enteredText; 
     52    } 
    7453 
    75   //----------------------------------------------------------------------------------------------- 
    76   /* (non-Javadoc) 
    77    * @see java.lang.Object#toString() 
    78    */ 
    79   //----------------------------------------------------------------------------------------------- 
    80   @Override 
    81   public synchronized String toString() 
    82   { 
    83     if (super.getChildren() == null) 
    84     { 
    85       return super.getName(); 
     54    /* 
     55     * (non-Javadoc) 
     56     *  
     57     * @see de.ugoe.cs.tasktree.treeifc.TextInputSequence#setEnteredText(java.lang.String) 
     58     */ 
     59    @Override 
     60    public void setEnteredText(String text) { 
     61        enteredText = text; 
    8662    } 
    87     else 
    88     { 
    89       return "TextInputInteraction(\"" + mEnteredText + "\", " + super.getChildren().size() + 
    90         " children)"; 
     63 
     64    /* 
     65     * (non-Javadoc) 
     66     *  
     67     * @see java.lang.Object#toString() 
     68     */ 
     69    @Override 
     70    public synchronized String toString() { 
     71        if (super.getChildren() == null) { 
     72            return super.getName(); 
     73        } 
     74        else { 
     75            return 
     76                "TextInputInteraction(\"" + enteredText + "\", " + super.getChildren().size() + 
     77                " children)"; 
     78        } 
    9179    } 
    92   } 
    93    
     80 
    9481} 
Note: See TracChangeset for help on using the changeset viewer.