Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/EvaluationMethodCaller.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/EvaluationMethodCaller.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/EvaluationMethodCaller.java	(revision 1150)
@@ -0,0 +1,39 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability;
+
+import com.google.common.base.Optional;
+
+import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
+import de.ugoe.cs.autoquest.usability.rules.UsabilityMetric;
+import de.ugoe.cs.autoquest.usability.rules.UsabilityUsageDefect;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class EvaluationMethodCaller {
+    
+    public Optional<UsabilityDefect> check(UsabilityMetric metric) {
+        return metric.calculate();
+    }
+    
+    public Optional<UsabilityDefect> check(UsabilityUsageDefect pattern) {
+        return pattern.check();
+    }
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluator.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluator.java	(revision 1140)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluator.java	(revision 1150)
@@ -63,7 +63,8 @@
     public UsabilityResult using(UsabilityRuleset ruleset) {
         Console.traceln(Level.INFO, "evaluating usability of task tree " + this.taskTree);
+        EvaluationMethodCaller evaluationMethodCaller = new EvaluationMethodCaller();
         UsabilityResult result = new UsabilityResult();
         for(UsabilityRule rule : ruleset.evaluationRules()) {
-            Optional<UsabilityDefect> defect = rule.check();
+            Optional<UsabilityDefect> defect = rule.callEvaluationMethod(evaluationMethodCaller);
             if(defect.isPresent()) {
                 result.addDefect(defect.get());
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityMetric.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityMetric.java	(revision 1140)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityMetric.java	(revision 1150)
@@ -15,4 +15,8 @@
 package de.ugoe.cs.autoquest.usability.rules;
 
+import com.google.common.base.Optional;
+
+import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
+
 /**
  * <p>
@@ -23,4 +27,6 @@
  */
 public interface UsabilityMetric {
+    
+    public Optional<UsabilityDefect> calculate();
 
 }
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityRule.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityRule.java	(revision 1140)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityRule.java	(revision 1150)
@@ -18,4 +18,5 @@
 
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller;
 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
 
@@ -45,5 +46,5 @@
     }
     
-    public abstract Optional<UsabilityDefect> check();
+    public abstract Optional<UsabilityDefect> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller);
 
 }
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityUsageDefect.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityUsageDefect.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityUsageDefect.java	(revision 1150)
@@ -0,0 +1,32 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules;
+
+import com.google.common.base.Optional;
+
+import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public interface UsabilityUsageDefect {
+    
+    public Optional<UsabilityDefect> check();
+
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/NoLetterOrDigitRatioMetric.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/NoLetterOrDigitRatioMetric.java	(revision 1140)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/NoLetterOrDigitRatioMetric.java	(revision 1150)
@@ -27,4 +27,5 @@
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller;
 import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver;
 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
@@ -61,5 +62,5 @@
      */
     @Override
-    public Optional<UsabilityDefect> check() {
+    public Optional<UsabilityDefect> calculate() {
         FilterResult textInputEvents = extractNodesFromTaskTree();
         float evaluationMetric = calculateEvaluationMetric(textInputEvents.nodesMatchedFilter());
@@ -88,3 +89,12 @@
     }
 
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller)
+     */
+    @Override
+    public Optional<UsabilityDefect> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller)
+    {
+        return evaluationMethodCaller.check(this);
+    }
+
 }
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputEntryRepetitionsMetric.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputEntryRepetitionsMetric.java	(revision 1140)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputEntryRepetitionsMetric.java	(revision 1150)
@@ -27,4 +27,5 @@
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller;
 import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver;
 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
@@ -61,5 +62,5 @@
      */
     @Override
-    public Optional<UsabilityDefect> check() {
+    public Optional<UsabilityDefect> calculate() {
         FilterResult textInputEvents = extractNodesFromTaskTree();
         float evaluationMetric = calculateEvaluationMetric(textInputEvents.nodesMatchedFilter());
@@ -103,3 +104,12 @@
     }
 
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller)
+     */
+    @Override
+    public Optional<UsabilityDefect> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller)
+    {
+        return evaluationMethodCaller.check(this);
+    }
+    
 }
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputRatioMetric.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputRatioMetric.java	(revision 1140)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputRatioMetric.java	(revision 1150)
@@ -25,4 +25,5 @@
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller;
 import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver;
 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
@@ -59,5 +60,5 @@
      */
     @Override
-    public Optional<UsabilityDefect> check() {
+    public Optional<UsabilityDefect> calculate() {
         FilterResult textInputEvents = extractNodesFromTaskTree();
         float evaluationMetric = calculateEvaluationMetric(textInputEvents.nodesMatchedFilter(), textInputEvents.nodesNotMatchedFilter());
@@ -88,3 +89,11 @@
     }
 
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller)
+     */
+    @Override
+    public Optional<UsabilityDefect> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller)
+    {
+        return evaluationMethodCaller.check(this);
+    }
 }
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/LongFormUsageDefect.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/LongFormUsageDefect.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/LongFormUsageDefect.java	(revision 1150)
@@ -0,0 +1,89 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns;
+
+import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.MOUSE_CLICK;
+import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.SCROLL;
+import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.TEXT_INPUT;
+import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter.ITERATION;
+import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter.SEQUENCE;
+
+import com.google.common.base.Optional;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller;
+import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver;
+import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
+import de.ugoe.cs.autoquest.usability.rules.UsabilityRule;
+import de.ugoe.cs.autoquest.usability.rules.UsabilityUsageDefect;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class LongFormUsageDefect extends UsabilityRule implements UsabilityUsageDefect {
+
+    private UsagePattern longFormUsagePattern;
+    
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param taskTree
+     */
+    public LongFormUsageDefect(ITaskTree taskTree) {
+        super(taskTree);
+        this.name = "LongFormUsagePattern";
+        this.defect = new DefectDescriptionResolver().descriptionFor(this.getClass().getSimpleName());
+        initUsagePattern();
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     */
+    private void initUsagePattern() {
+        UsagePatternBuilder builder = new UsagePatternBuilder();
+        UsagePattern fillFormPattern = builder.concernedNode(ITERATION).startsWith(TEXT_INPUT).endsWith(SCROLL).build();
+        this.longFormUsagePattern = builder.concernedNode(SEQUENCE).startsWith(MOUSE_CLICK).contains(fillFormPattern).endsWith(MOUSE_CLICK).build();
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#check()
+     */
+    @Override
+    public Optional<UsabilityDefect> check() {
+        Optional<UsabilityDefect> present = Optional.absent();
+        if(this.longFormUsagePattern.containedIn(taskTree)) {
+            present = Optional.of(this.defect);
+        }
+        return present;
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller)
+     */
+    @Override
+    public Optional<UsabilityDefect> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller)
+    {
+        return evaluationMethodCaller.check(this);
+    }
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePattern.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePattern.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePattern.java	(revision 1150)
@@ -0,0 +1,138 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.tasktree.IterativeDFSFilterStrategy;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeFilter;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class UsagePattern {
+    
+    private TaskTreeFilter taskTreeFilter = new TaskTreeFilter(new IterativeDFSFilterStrategy());
+    
+    private TaskTreeNodeTypeFilter concernedNode;
+
+    private List<UsagePatternVisitor> patternVisitors;
+    
+    private boolean present = false;
+    
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param concernedNode
+     * @param eventType
+     */
+    public UsagePattern(TaskTreeNodeTypeFilter concernedNode,
+                        UsagePatternVisitor... patternVisitor)
+    {
+        this.patternVisitors = Arrays.asList(patternVisitor);
+        this.concernedNode = concernedNode;
+    }
+
+    public boolean containedIn(ITaskTree taskTree) {
+        List<ITaskTreeNode> allConcernedNodes = filterAllConcernedNodeFrom(taskTree);
+        for(ITaskTreeNode concernedNode : allConcernedNodes) {
+            applyAllVisitors(concernedNode);
+            if(allVisitorsArePresent()) {
+                this.present = true;
+                break;
+            } else {
+                resetAllVisitors();
+            }
+            
+        }
+        return this.present;
+    }
+
+    private void applyAllVisitors(ITaskTreeNode concernedNode) {
+        Optional<UsagePatternVisitor> previousVisitor = Optional.absent();
+        for(UsagePatternVisitor visitor : patternVisitors) {
+            if(appliedOnSelectionNode(previousVisitor)) {
+                for(ITaskTreeNode selectionNode : previousVisitor.get().getRetainedSelectionNodes()) {
+                    selectionNode.accept(visitor);
+                }
+            } else {
+                previousVisitor = Optional.of(visitor);
+                concernedNode.accept(visitor);
+            }
+        }
+    }
+
+    private boolean appliedOnSelectionNode(Optional<UsagePatternVisitor> previousVisitor) {
+        return previousVisitor.isPresent() && previousVisitor.get().hasExcludedSelectionNodes();
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param taskTree
+     * @return
+     */
+    private List<ITaskTreeNode> filterAllConcernedNodeFrom(ITaskTree taskTree) {
+        return this.taskTreeFilter.filterByNodeType(this.concernedNode).from(taskTree).nodesMatchedFilter();
+    }
+    
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @return
+     */
+    private boolean allVisitorsArePresent() {
+        Iterable<UsagePatternVisitor> allPresent = Iterables.filter(this.patternVisitors, new Predicate<UsagePatternVisitor>() {
+            
+            public boolean apply(UsagePatternVisitor visitor) {
+                return visitor.isPresent();
+            }
+            
+        });
+        return Iterables.size(allPresent) == this.patternVisitors.size();
+    }
+    
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     */
+    private void resetAllVisitors() {
+        for(UsagePatternVisitor visitor : this.patternVisitors) {
+            visitor.reset();
+        }
+        
+    }
+
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternBuilder.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternBuilder.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternBuilder.java	(revision 1150)
@@ -0,0 +1,710 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns;
+
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.ContainsEventVisitor;
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.ContainsPatternVisitor;
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.EndsWithEventVisitor;
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.EndsWithPatternVisitor;
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.StartsWithEventVisitor;
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.StartsWithPatternVisitor;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class UsagePatternBuilder {
+
+    protected TaskTreeNodeTypeFilter concernedNode;
+    
+    protected EventTypeFilter startsWithEvent;
+    
+    protected UsagePattern startsWithPattern;
+    
+    protected EventTypeFilter endsWithEvent;
+    
+    protected UsagePattern endsWithPattern;
+    
+    protected EventTypeFilter containsEvent;
+    
+    protected UsagePattern containsPattern;
+    
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param sequence
+     * @return
+     */
+    public SpecifyPatternStep concernedNode(TaskTreeNodeTypeFilter concernedNode) {
+        this.concernedNode = concernedNode;
+        return new SpecifyPatternStep();
+    }
+    
+    public class SpecifyPatternStep {
+
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param textInput
+         * @return
+         */
+        public BuildStartsWithEventStep startsWith(EventTypeFilter startsWithType) {
+            UsagePatternBuilder.this.startsWithEvent = startsWithType;
+            return new BuildStartsWithEventStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param startsWithPattern
+         * @return
+         */
+        public BuildStartsWithPatternStep startsWith(UsagePattern startsWithPattern) {
+            UsagePatternBuilder.this.startsWithPattern = startsWithPattern;
+            return new BuildStartsWithPatternStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param textInput
+         * @return
+         */
+        public BuildEndsWithEventStep endsWith(EventTypeFilter endsWithType) {
+            UsagePatternBuilder.this.endsWithEvent = endsWithType;
+            return new BuildEndsWithEventStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param endsWithPattern
+         * @return
+         */
+        public BuildEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
+            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+            return new BuildEndsWithPatternStep();
+        }
+
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param textInput
+         * @return
+         */
+        public BuildContainsEventStep contains(EventTypeFilter containsType) {
+            UsagePatternBuilder.this.containsEvent = containsType;
+            return new BuildContainsEventStep();
+        }
+
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param containsPattern
+         * @return
+         */
+        public BuildContainsPatternStep contains(UsagePattern containsPattern) {
+            UsagePatternBuilder.this.containsPattern = containsPattern;
+            return new BuildContainsPatternStep();
+        }
+        
+    }
+    
+    public class BuildStartsWithEventStep {
+
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param endsWithType
+         * @return
+         */
+        public BuildStartsAndEndsWithEventStep endsWith(EventTypeFilter endsWithType) {
+            UsagePatternBuilder.this.endsWithEvent = endsWithType;
+            return new BuildStartsAndEndsWithEventStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param endsWithPattern
+         * @return
+         */
+        public BuildStartsWithEventAndEndsWithPattern endsWith(UsagePattern endsWithPattern) {
+            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+            return new BuildStartsWithEventAndEndsWithPattern();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param textInput
+         * @return
+         */
+        public BuildStartsWithEventAndContainsEventStep contains(EventTypeFilter containsType) {
+            UsagePatternBuilder.this.containsEvent = containsType;
+            return new BuildStartsWithEventAndContainsEventStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param containedPattern
+         * @return
+         */
+        public BuildStartsWithEventAndContainsPatternStep contains(UsagePattern containsPattern) {
+            UsagePatternBuilder.this.containsPattern = containsPattern;
+            return new BuildStartsWithEventAndContainsPatternStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent));
+        }
+        
+    }
+    
+    public class BuildStartsWithPatternStep {
+
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param containsEvent
+         * @return
+         */
+        public BuildStartsWithPatternAndContainsEventStep contains(EventTypeFilter containsEvent) {
+            UsagePatternBuilder.this.containsEvent = containsEvent;
+            return new BuildStartsWithPatternAndContainsEventStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param containedPattern
+         * @return
+         */
+        public BuildStartsWithPatternAndContainsPatternStep contains(UsagePattern containsPattern) {
+            UsagePatternBuilder.this.containsPattern = containsPattern;
+            return new BuildStartsWithPatternAndContainsPatternStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param textInput
+         * @return
+         */
+        public BuildStartsWithPatternAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
+            UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
+            return new BuildStartsWithPatternAndEndsWithEventStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param endsWithPattern
+         * @return
+         */
+        public BuildStartsAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
+            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+            return new BuildStartsAndEndsWithPatternStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern));
+        }
+        
+    }
+    
+    public class BuildEndsWithEventStep {
+
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new EndsWithEventVisitor(endsWithEvent));
+        }
+        
+    }
+    
+    public class BuildEndsWithPatternStep {
+
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new EndsWithPatternVisitor(endsWithPattern));
+        }
+        
+    }
+    
+    public class BuildContainsEventStep {
+
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param textInput
+         * @return
+         */
+        public BuildContainsAndEndsWithEventStep endsWith(EventTypeFilter endsWithType) {
+            UsagePatternBuilder.this.endsWithEvent = endsWithType;
+            return new BuildContainsAndEndsWithEventStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new ContainsEventVisitor(containsEvent));
+        }
+        
+    }
+    
+    public class BuildContainsPatternStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new ContainsPatternVisitor(containsPattern));
+        }
+        
+    }
+    
+    public class BuildStartsAndEndsWithEventStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new EndsWithEventVisitor(endsWithEvent));
+        }
+        
+    }
+    
+    public class BuildStartsWithEventAndEndsWithPattern {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new EndsWithPatternVisitor(endsWithPattern));
+        }
+        
+    }
+    
+    public class BuildStartsWithPatternAndEndsWithEventStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new EndsWithEventVisitor(endsWithEvent));
+        }
+        
+    }
+    
+    public class BuildStartsAndEndsWithPatternStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new EndsWithPatternVisitor(endsWithPattern));
+        }
+        
+    }
+    
+    public class BuildStartsWithEventAndContainsEventStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param textInput
+         * @return
+         */
+        public BuildStartsAndEndsWithEventAndContainsEventStep endsWith(EventTypeFilter endsWithEvent) {
+            UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
+            return new BuildStartsAndEndsWithEventAndContainsEventStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param endsWithPattern
+         * @return
+         */
+        public BuildStartsWithEventContainsEventAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
+            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+            return new BuildStartsWithEventContainsEventAndEndsWithPatternStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsEventVisitor(containsEvent));
+        }
+        
+    }
+    
+    public class BuildStartsWithPatternAndContainsPatternStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param textInput
+         * @return
+         */
+        public BuildStartsContainsPatternAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
+            UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
+            return new BuildStartsContainsPatternAndEndsWithEventStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param endsWithPattern
+         * @return
+         */
+        public BuildStartsAndEndsWithPatternAndContainsPatternStep endsWith(UsagePattern endsWithPattern) {
+            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+            return new BuildStartsAndEndsWithPatternAndContainsPatternStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsPatternVisitor(containsPattern));
+        }
+        
+    }
+    
+    public class BuildStartsWithEventAndContainsPatternStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param textInput
+         * @return
+         */
+        public BuildStartsWithEventContainsPatternAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
+            UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
+            return new BuildStartsWithEventContainsPatternAndEndsWithEventStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param endsWithPattern
+         * @return
+         */
+        public BuildStartsWithEventContainsPatternAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
+            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+            return new BuildStartsWithEventContainsPatternAndEndsWithPatternStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsPatternVisitor(containsPattern));
+        }
+        
+    }
+    
+    public class BuildStartsWithPatternAndContainsEventStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param textInput
+         * @return
+         */
+        public BuildStartsWithPatternContainsEventAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
+            UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
+            return new BuildStartsWithPatternContainsEventAndEndsWithEventStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @param endsWithPattern
+         * @return
+         */
+        public BuildStartsWithPatternContainsEventAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
+            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+            return new BuildStartsWithPatternContainsEventAndEndsWithPatternStep();
+        }
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsEventVisitor(containsEvent));
+        }
+        
+    }
+    
+    public class BuildStartsAndEndsWithEventAndContainsEventStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new EndsWithEventVisitor(endsWithEvent), new ContainsEventVisitor(containsEvent));
+        }
+        
+    }
+    
+    public class BuildStartsContainsPatternAndEndsWithEventStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsPatternVisitor(containsPattern), new EndsWithEventVisitor(endsWithEvent));
+        }
+        
+    }
+    
+    public class BuildStartsAndEndsWithPatternAndContainsPatternStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new EndsWithPatternVisitor(endsWithPattern), new ContainsPatternVisitor(containsPattern));
+        }
+        
+    }
+    
+    public class BuildStartsWithEventContainsEventAndEndsWithPatternStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsEventVisitor(containsEvent), new EndsWithPatternVisitor(endsWithPattern));
+        }
+        
+    }
+    
+    public class BuildStartsWithEventContainsPatternAndEndsWithEventStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsPatternVisitor(containsPattern), new EndsWithEventVisitor(endsWithEvent));
+        }
+        
+    }
+    
+    public class BuildStartsWithEventContainsPatternAndEndsWithPatternStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsPatternVisitor(containsPattern), new EndsWithPatternVisitor(endsWithPattern));
+        }
+        
+    }
+    
+    public class BuildStartsWithPatternContainsEventAndEndsWithEventStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsEventVisitor(containsEvent), new EndsWithEventVisitor(endsWithEvent));
+        }
+        
+    }
+    
+    public class BuildStartsWithPatternContainsEventAndEndsWithPatternStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsEventVisitor(containsEvent), new EndsWithPatternVisitor(endsWithPattern));
+        }
+        
+    }
+    
+    public class BuildContainsAndEndsWithEventStep {
+        
+        /**
+         * <p>
+         * TODO: comment
+         * </p>
+         *
+         * @return
+         */
+        public UsagePattern build() {
+            return new UsagePattern(concernedNode, new ContainsEventVisitor(containsEvent), new EndsWithEventVisitor(endsWithEvent));
+        }
+        
+    }
+
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternVisitor.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternVisitor.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternVisitor.java	(revision 1150)
@@ -0,0 +1,150 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns;
+
+import java.util.List;
+
+import org.apache.commons.lang.StringUtils;
+
+import com.google.common.base.Splitter;
+import com.google.common.collect.Lists;
+
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.eventcore.StringEventType;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public abstract class UsagePatternVisitor implements NodeVisitor {
+    
+    protected EventTypeFilter eventType;
+    
+    protected UsagePattern containedPattern;
+    
+    protected boolean present = false;
+    
+    protected List<ITaskTreeNode> retainedChildrenNodesFromSelectionNodes = Lists.newArrayList();
+    
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask)
+     */
+    public void visit(IEventTask event) {
+        if(!this.present && isEventVisitor()) {
+            IEventType eventType = event.getEventType();
+            if(eventType instanceof StringEventType) {
+                this.present = eventType.toString().equals(nameOfEventType());
+            } else {
+                this.present = eventType.getClass().equals(this.eventType.clazz());
+            }
+        }
+    }
+    
+    public boolean isEventVisitor() {
+        return this.eventType != null && this.containedPattern == null;
+    }
+    
+    protected String nameOfEventType() {
+        String ret = StringUtils.EMPTY;
+        Iterable<String> splitted = Splitter.on("_").split(this.eventType.name());
+        for(String str : splitted) {
+            str = str.toLowerCase();
+            ret += Character.toString(str.charAt(0)).toUpperCase() + str.substring(1);
+        }
+        return ret;
+    }
+    
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection)
+     */
+    public void visit(ISelection selection) {
+        if(isEventVisitor()) {
+            retainNodesWherePatternIsPresent(selection.getChildren());
+            this.present = patternIsPresent();
+        } else {
+            ITaskTree taskTree = PatternsVisitorUtil.createTaskTreeFromNode(selection);
+            this.present = containedPattern.containedIn(taskTree);  
+        }
+    }
+
+    protected void retainNodesWherePatternIsPresent(List<ITaskTreeNode> children) {
+        for(ITaskTreeNode node : children) {
+            this.present = false;
+            node.accept(this);
+            if(this.present) {
+                this.retainedChildrenNodesFromSelectionNodes.add(node);
+            }
+        }
+    }
+    
+    private boolean patternIsPresent() {
+        return !this.retainedChildrenNodesFromSelectionNodes.isEmpty();
+    }
+    
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @return
+     */
+    public boolean isPresent() {
+        return this.present;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     */
+    public void reset() {
+        this.retainedChildrenNodesFromSelectionNodes.clear();
+        this.present = false;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @return
+     */
+    public boolean hasExcludedSelectionNodes() {
+        return patternIsPresent();
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @return
+     */
+    public List<ITaskTreeNode> getRetainedSelectionNodes() {
+        return this.retainedChildrenNodesFromSelectionNodes;
+    }
+    
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsEventVisitor.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsEventVisitor.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsEventVisitor.java	(revision 1150)
@@ -0,0 +1,68 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import java.util.List;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class ContainsEventVisitor extends UsagePatternVisitor {
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param containsType
+     */
+    public ContainsEventVisitor(EventTypeFilter containsType) {
+        this.eventType = containsType;
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+     */
+    public void visit(IIteration iteration) {
+        checkAllChildrenAndReturnIfPatternIsPresent(iteration.getChildren());
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+     */
+    public void visit(ISequence sequence) {
+        checkAllChildrenAndReturnIfPatternIsPresent(sequence.getChildren());
+    }
+    
+    private void checkAllChildrenAndReturnIfPatternIsPresent(List<ITaskTreeNode> children) {
+        for(ITaskTreeNode node : children) {
+            node.accept(this);
+            if(this.present) {
+                break;
+            }
+        }
+    }
+
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsPatternVisitor.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsPatternVisitor.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsPatternVisitor.java	(revision 1150)
@@ -0,0 +1,80 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePattern;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class ContainsPatternVisitor extends UsagePatternVisitor {
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param containsPattern
+     */
+    public ContainsPatternVisitor(UsagePattern containsPattern) {
+        this.containedPattern = containsPattern;
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+     */
+    public void visit(IIteration iteration) {
+        checkAllChildrenAndReturnIfPatternIsPresent(iteration);
+
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+     */
+    public void visit(ISequence sequence) {
+        checkAllChildrenAndReturnIfPatternIsPresent(sequence);
+
+    }
+    
+    private void checkAllChildrenAndReturnIfPatternIsPresent(ITaskTreeNode node) {
+        for(ITaskTreeNode child : node.getChildren()) {
+            ITaskTree taskTree;
+            if(isEvent(child)) {
+                taskTree = PatternsVisitorUtil.createTaskTreeFromNode(node);
+            } else {
+                taskTree = PatternsVisitorUtil.createTaskTreeFromNode(child);
+            }
+            this.present = containedPattern.containedIn(taskTree); 
+            if(this.present) {
+                break;
+            }
+        }
+    }
+    
+    private boolean isEvent(ITaskTreeNode firstNode) {
+        return firstNode.getChildren().isEmpty();
+    }
+
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithEventVisitor.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithEventVisitor.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithEventVisitor.java	(revision 1150)
@@ -0,0 +1,57 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class EndsWithEventVisitor extends UsagePatternVisitor {
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param eventType
+     */
+    public EndsWithEventVisitor(EventTypeFilter eventType) {
+        this.eventType = eventType;
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+     */
+    public void visit(IIteration iteration) {
+        PatternsVisitorUtil.lastNodeOf(iteration.getChildren()).accept(this);
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+     */
+    public void visit(ISequence sequence) {
+        PatternsVisitorUtil.lastNodeOf(sequence.getChildren()).accept(this);   
+    }
+    
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithPatternVisitor.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithPatternVisitor.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithPatternVisitor.java	(revision 1150)
@@ -0,0 +1,72 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePattern;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class EndsWithPatternVisitor extends UsagePatternVisitor {
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param endsWithPattern
+     */
+    public EndsWithPatternVisitor(UsagePattern endsWithPattern) {
+        this.containedPattern = endsWithPattern;
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+     */
+    public void visit(IIteration iteration) {
+        ITaskTree taskTree = PatternsVisitorUtil.createTaskTreeFromNode(iteration);
+        this.present = containedPattern.containedIn(taskTree); 
+
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+     */
+    public void visit(ISequence sequence) {
+        ITaskTreeNode lastNode = PatternsVisitorUtil.lastNodeOf(sequence.getChildren());
+        ITaskTree taskTree;
+        if(isEvent(lastNode)) {
+            taskTree = PatternsVisitorUtil.createTaskTreeFromNode(sequence);
+        } else {
+            taskTree = PatternsVisitorUtil.createTaskTreeFromNode(lastNode);
+        }
+        this.present = containedPattern.containedIn(taskTree);      
+    }
+
+    private boolean isEvent(ITaskTreeNode firstNode) {
+        return firstNode.getChildren().isEmpty();
+    }
+
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithEventVisitor.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithEventVisitor.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithEventVisitor.java	(revision 1150)
@@ -0,0 +1,57 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class StartsWithEventVisitor extends UsagePatternVisitor {
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param eventType
+     */
+    public StartsWithEventVisitor(EventTypeFilter eventType) {
+        this.eventType = eventType;
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+     */
+    public void visit(IIteration iteration) {
+        PatternsVisitorUtil.firstNodeOf(iteration.getChildren()).accept(this);
+    }
+    
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+     */
+    public void visit(ISequence sequence) {
+        PatternsVisitorUtil.firstNodeOf(sequence.getChildren()).accept(this);   
+    }
+    
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithPatternVisitor.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithPatternVisitor.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithPatternVisitor.java	(revision 1150)
@@ -0,0 +1,71 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePattern;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class StartsWithPatternVisitor extends UsagePatternVisitor {
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param startsWithPattern
+     */
+    public StartsWithPatternVisitor(UsagePattern startsWithPattern) {
+        this.containedPattern = startsWithPattern;
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+     */
+    public void visit(IIteration iteration) {
+        ITaskTree taskTree = PatternsVisitorUtil.createTaskTreeFromNode(iteration);
+        this.present = containedPattern.containedIn(taskTree);  
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+     */
+    public void visit(ISequence sequence) {
+        ITaskTreeNode firstNode = PatternsVisitorUtil.firstNodeOf(sequence.getChildren());
+        ITaskTree taskTree;
+        if(isEvent(firstNode)) {
+            taskTree = PatternsVisitorUtil.createTaskTreeFromNode(sequence);
+        } else {
+            taskTree = PatternsVisitorUtil.createTaskTreeFromNode(firstNode);
+        }
+        this.present = containedPattern.containedIn(taskTree);      
+    }
+
+    private boolean isEvent(ITaskTreeNode firstNode) {
+        return firstNode.getChildren().isEmpty();
+    }
+
+}
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/EventTypeFilter.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/EventTypeFilter.java	(revision 1140)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/EventTypeFilter.java	(revision 1150)
@@ -22,5 +22,7 @@
 import de.ugoe.cs.autoquest.eventcore.gui.IInteraction;
 import de.ugoe.cs.autoquest.eventcore.gui.MouseButtonInteraction;
+import de.ugoe.cs.autoquest.eventcore.gui.MouseClick;
 import de.ugoe.cs.autoquest.eventcore.gui.MouseInteraction;
+import de.ugoe.cs.autoquest.eventcore.gui.Scroll;
 import de.ugoe.cs.autoquest.eventcore.gui.TextInput;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
@@ -38,7 +40,11 @@
     MOUSE_BUTTON_INTERACTION(MouseButtonInteraction.class),
     
+    MOUSE_CLICK(MouseClick.class),
+    
     MOUSE_INTERACTION(MouseInteraction.class),
     
     TEXT_INPUT(TextInput.class),
+    
+    SCROLL(Scroll.class),
     
     USER_INTERACTION(IInteraction.class);
@@ -49,5 +55,5 @@
         this.eventTypeClazz = eventTypeClazz;
     }
-
+    
     @SuppressWarnings("unchecked")
     @Override
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/TaskTreeNodeTypeFilter.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/TaskTreeNodeTypeFilter.java	(revision 1140)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/TaskTreeNodeTypeFilter.java	(revision 1150)
@@ -19,4 +19,7 @@
 
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
 
@@ -30,5 +33,11 @@
 public enum TaskTreeNodeTypeFilter implements TaskTreeNodeFilter<ITaskTreeNode> {
 
-    EVENT_TASK_NODE(IEventTask.class);
+    EVENT_TASK_NODE(IEventTask.class),
+    
+    ITERATION(IIteration.class),
+    
+    SEQUENCE(ISequence.class),
+    
+    SELECTION(ISelection.class),;
 
     private Class<? extends ITaskTreeNode> nodeTypeClazz;
@@ -47,5 +56,5 @@
     @Override
     public Predicate filterPredicate() {
-        return Predicates.instanceOf(IEventTask.class);
+        return Predicates.instanceOf(nodeTypeClazz);
     }
 
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/NullNode.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/NullNode.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/NullNode.java	(revision 1150)
@@ -0,0 +1,78 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.util;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.commons.lang.StringUtils;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class NullNode implements ITaskTreeNode {
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode#getName()
+     */
+    public String getName() {
+        return StringUtils.EMPTY;
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode#getDescription()
+     */
+    public String getDescription() {
+        return StringUtils.EMPTY;
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode#getChildren()
+     */
+    public List<ITaskTreeNode> getChildren() {
+        return Collections.emptyList();
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode#equals(de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode)
+     */
+    public boolean equals(ITaskTreeNode taskTreeNode) {
+        return false;
+    }
+    
+    /* (non-Javadoc)
+     * @see java.lang.Object#clone()
+     */
+    @Override
+    public NullNode clone() {
+        return (NullNode) this;
+    }
+
+    /* (non-Javadoc)
+     * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode#accept(de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor)
+     */
+    public void accept(NodeVisitor visitor) {
+        
+    }
+    
+}
+
Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/PatternsVisitorUtil.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/PatternsVisitorUtil.java	(revision 1150)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/PatternsVisitorUtil.java	(revision 1150)
@@ -0,0 +1,74 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.util;
+
+import java.util.List;
+
+import com.google.common.collect.Iterables;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+
+/**
+ * <p>
+ * TODO comment
+ * </p>
+ * 
+ * @author Alexander Deicke
+ */
+public class PatternsVisitorUtil {
+
+    private PatternsVisitorUtil() {
+        // no instantiation
+    }
+    
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param taskTreeNode
+     * @return
+     */
+    public static ITaskTree createTaskTreeFromNode(ITaskTreeNode taskTreeNode) {
+        return new TaskTreeNodeFactory().createTaskTree(taskTreeNode);
+    }
+    
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param taskTreeNodes
+     * @return
+     */
+    public static ITaskTreeNode firstNodeOf(List<ITaskTreeNode> taskTreeNodes) {
+        return Iterables.getFirst(taskTreeNodes, new NullNode());
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param taskTreeNodes
+     * @return
+     */
+    public static ITaskTreeNode lastNodeOf(List<ITaskTreeNode> taskTreeNodes) {
+        return Iterables.getLast(taskTreeNodes, new NullNode());
+    }
+    
+}
