Index: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/IterativeDFSFilterStrategy.java
===================================================================
--- trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/IterativeDFSFilterStrategy.java	(revision 1135)
+++ trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/IterativeDFSFilterStrategy.java	(revision 1152)
@@ -22,9 +22,11 @@
 import de.ugoe.cs.autoquest.eventcore.IEventTarget;
 import de.ugoe.cs.autoquest.eventcore.IEventType;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IMarkingTemporalRelationship;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IStructuringTemporalRelationship;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel;
 import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTargetFilter;
 import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
-import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter;
 
 /**
@@ -35,5 +37,5 @@
  * @author Alexander Deicke
  */
-public class IterativeDFSFilterStrategy implements TaskTreeFilterStrategy {
+public class IterativeDFSFilterStrategy implements TaskModelFilterStrategy {
 
     private FilterResult filterStatistic;
@@ -41,8 +43,8 @@
     @SuppressWarnings("unchecked")
     @Override
-    public FilterResult filter(ITaskTree taskTree, EventTargetFilter eventTarget) {
+    public FilterResult filter(ITaskModel taskModel, EventTargetFilter eventTarget) {
         Predicate<IEventTarget> filterPredicate = eventTarget.filterPredicate();
         this.filterStatistic = new FilterResult(filterPredicate);
-        traverse(taskTree);
+        traverse(taskModel);
         return this.filterStatistic;
     }
@@ -50,8 +52,8 @@
     @SuppressWarnings("unchecked")
     @Override
-    public FilterResult filter(ITaskTree taskTree, EventTypeFilter eventType) {
+    public FilterResult filter(ITaskModel taskModel, EventTypeFilter eventType) {
         Predicate<IEventType> filterPredicate = eventType.filterPredicate();
         this.filterStatistic = new FilterResult(filterPredicate);
-        traverse(taskTree);
+        traverse(taskModel);
         return this.filterStatistic;
     }
@@ -59,34 +61,39 @@
     @SuppressWarnings("unchecked")
     @Override
-    public FilterResult filter(ITaskTree taskTree, TaskTreeNodeTypeFilter nodeType) {
-        Predicate<ITaskTreeNode> filterPredicate = nodeType.filterPredicate();
+    public FilterResult filter(ITaskModel taskModel, TaskTypeFilter nodeType) {
+        Predicate<ITask> filterPredicate = nodeType.filterPredicate();
         this.filterStatistic = new FilterResult(filterPredicate);
-        traverse(taskTree);
+        traverse(taskModel);
         return this.filterStatistic;
     }
 
-    private void traverse(ITaskTree taskTree) {
-        Queue<ITaskTreeNode> unvisitedNodes = new LinkedList<ITaskTreeNode>();
-        unvisitedNodes.add(taskTree.getRoot());
-        while (stillUnvisitedNodes(unvisitedNodes)) {
-            ITaskTreeNode node = unvisitedNodes.poll();
-            processCurrentNode(node);
-            processChildrenOfCurrentNode(unvisitedNodes, node);
+    private void traverse(ITaskModel taskModel) {
+        Queue<ITask> unvisitedTasks = new LinkedList<ITask>();
+        unvisitedTasks.addAll(taskModel.getTasks());
+        while (stillUnvisitedTasks(unvisitedTasks)) {
+            ITask task = unvisitedTasks.poll();
+            processCurrentTask(task);
+            processChildrenOfCurrentTask(unvisitedTasks, task);
         }
     }
 
-    private boolean stillUnvisitedNodes(Queue<ITaskTreeNode> unvisitedNodes) {
-        return !unvisitedNodes.isEmpty();
+    private boolean stillUnvisitedTasks(Queue<ITask> unvisitedTasks) {
+        return !unvisitedTasks.isEmpty();
     }
 
-    private void processCurrentNode(ITaskTreeNode node) {
-        this.filterStatistic.addNode(node);
+    private void processCurrentTask(ITask task) {
+        this.filterStatistic.addTask(task);
     }
 
-    private void processChildrenOfCurrentNode(Queue<ITaskTreeNode> unvisitedNodes,
-                                              ITaskTreeNode node)
+    private void processChildrenOfCurrentTask(Queue<ITask> unvisitedTasks,
+                                              ITask task)
     {
-        for (ITaskTreeNode child : node.getChildren()) {
-            unvisitedNodes.add(child);
+        if (task instanceof IStructuringTemporalRelationship) {
+            for (ITask child : ((IStructuringTemporalRelationship) task).getChildren()) {
+                unvisitedTasks.add(child);
+            }
+        }
+        else if (task instanceof IMarkingTemporalRelationship) {
+            unvisitedTasks.add(((IMarkingTemporalRelationship) task).getMarkedTask());
         }
     }
