Ignore:
Timestamp:
06/06/13 17:08:25 (11 years ago)
Author:
adeicke
Message:
  • Added proper formating and JavaDoc?.
  • Several renaming refactorings.
Location:
trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules
Files:
2 added
1 deleted
16 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityMetric.java

    r1150 r1217  
    1717import com.google.common.base.Optional; 
    1818 
    19 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect; 
     19import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescription; 
    2020 
    2121/** 
    2222 * <p> 
    23  * TODO comment 
     23 * Interface for usability metrics. A metric is a way of measuring or evaluating a particular 
     24 * phenomenon or thing, in this case usability. 
    2425 * </p> 
    2526 *  
    … …  
    2728 */ 
    2829public interface UsabilityMetric { 
    29      
    30     public Optional<UsabilityDefect> calculate(); 
     30 
     31    /** 
     32     *  
     33     * <p> 
     34     * Calculates the metric. 
     35     * </p> 
     36     *  
     37     * @return Detailed description of the usability problem, if calculated metric exceeds defined 
     38     *         threshold. 
     39     */ 
     40    public Optional<UsabilityProblemDescription> calculate(); 
    3141 
    3242} 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityMetricsRuleset.java

    r1152 r1217  
    2626/** 
    2727 * <p> 
    28  * TODO comment 
     28 * A ruleset containing usability metrics, which might be indicators for potential usability 
     29 * problems. 
    2930 * </p> 
    3031 *  
    … …  
    3435 
    3536    private List<UsabilityRule> metrics; 
    36      
     37 
    3738    /** 
    3839     * <p> 
    39      * TODO: comment 
     40     * Constructor. Creates new {@code UsabilityMetricsRuleset} for a given task model. 
    4041     * </p> 
    41      * 
     42     *  
    4243     */ 
    4344    private UsabilityMetricsRuleset(ITaskModel taskModel) { 
    … …  
    4849    } 
    4950 
    50     /* (non-Javadoc) 
     51    /* 
     52     * (non-Javadoc) 
     53     *  
    5154     * @see de.ugoe.cs.autoquest.usability.UsabilityRuleset#evaluationRules() 
    5255     */ 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityResult.java

    r1138 r1217  
    1818import com.google.common.collect.Multimap; 
    1919 
    20 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect; 
    21 import de.ugoe.cs.autoquest.usability.result.UsabilityDefectSeverityLevel; 
    22  
     20import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescription; 
     21import de.ugoe.cs.autoquest.usability.result.UsabilityProblemSeverityLevel; 
    2322 
    2423/** 
    2524 * <p> 
    26  * TODO comment 
     25 * The result of the usability evaluation, which contains all detected problems. 
    2726 * </p> 
    2827 *  
    … …  
    3029 */ 
    3130public class UsabilityResult { 
    32      
    33     private Multimap<UsabilityDefectSeverityLevel, UsabilityDefect> detectedDefects; 
    34      
     31 
     32    /** 
     33     * <p> 
     34     * All detected problems and their appropriate severity level. 
     35     * </p> 
     36     */ 
     37    private Multimap<UsabilityProblemSeverityLevel, UsabilityProblemDescription> detectedProblems; 
     38 
     39    /** 
     40     *  
     41     * <p> 
     42     * Constructor. Creates a new result. 
     43     * </p> 
     44     *  
     45     */ 
    3546    public UsabilityResult() { 
    36         this.detectedDefects = ArrayListMultimap.create(); 
     47        this.detectedProblems = ArrayListMultimap.create(); 
    3748    } 
    3849 
    3950    /** 
    4051     * <p> 
    41      * TODO: comment 
     52     * Adds a usability problem to the result. 
    4253     * </p> 
    43      * 
    44      * @param usabilityDefect 
     54     *  
     55     * @param usabilityProblem 
     56     *            the problem, which should be added. 
    4557     */ 
    46     public void addDefect(UsabilityDefect usabilityDefect) { 
    47         this.detectedDefects.put(usabilityDefect.getSeverityLevel(), usabilityDefect); 
     58    public void addProblem(UsabilityProblemDescription usabilityProblem) { 
     59        this.detectedProblems.put(usabilityProblem.getSeverityLevel(), usabilityProblem); 
    4860    } 
    49      
    50     public boolean hasDefects() { 
    51         return !this.detectedDefects.isEmpty(); 
     61 
     62    /** 
     63     *  
     64     * <p> 
     65     * Checks, if problems were found during the usability evaluation. 
     66     * </p> 
     67     *  
     68     * @return true, iff problems were found 
     69     */ 
     70    public boolean hasDetectedProblems() { 
     71        return !this.detectedProblems.isEmpty(); 
    5272    } 
    5373 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityRule.java

    r1152 r1217  
    1919import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
    2020import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller; 
    21 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect; 
     21import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescription; 
    2222 
    2323/** 
    2424 * <p> 
    25  * TODO comment 
     25 * A {@code UsabilityRule} is a abstract class, representing a usability guideline, metric 
     26 * interaction pattern etc., which should be checked during a automatic usability evaluation. 
    2627 * </p> 
    2728 *  
    … …  
    2930 */ 
    3031public abstract class UsabilityRule { 
    31      
    32     protected final ITaskModel taskModel; 
    33      
    34     protected String name; 
    35      
    36     protected UsabilityDefect defect; 
    37      
     32 
    3833    /** 
    3934     * <p> 
    40      * TODO: comment 
     35     * {@link ITaskModel}, which is evaluated 
    4136     * </p> 
    42      * 
     37     */ 
     38    protected final ITaskModel taskModel; 
     39 
     40    /** 
     41     * <p> 
     42     * Name of the usability rule 
     43     * </p> 
     44     */ 
     45    protected String name; 
     46 
     47    /** 
     48     * <p> 
     49     * Corresponding defect description. 
     50     * </p> 
     51     */ 
     52    protected UsabilityProblemDescription defect; 
     53 
     54    /** 
     55     * <p> 
     56     * Constructor. Creates a new {@code UsabilityRule} for a given task model 
     57     * </p> 
     58     *  
    4359     */ 
    4460    public UsabilityRule(ITaskModel taskModel) { 
    4561        this.taskModel = taskModel; 
    4662    } 
    47      
    48     public abstract Optional<UsabilityDefect> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller); 
     63 
     64    /** 
     65     *  
     66     * <p> 
     67     * Calls the evaluation method of this {@code UsabilityRule}. 
     68     * </p> 
     69     *  
     70     * @param evaluationMethodCaller 
     71     *            helper class, which calls the evaluation method based on the type of the 
     72     *            {@code UsabilityRule} 
     73     * @return {@link UsabilityProblemDescription}, iff violation against usability rule was detected 
     74     */ 
     75    public abstract Optional<UsabilityProblemDescription> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller); 
    4976 
    5077} 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityRuleset.java

    r1138 r1217  
    1919/** 
    2020 * <p> 
    21  * TODO comment 
     21 * A {@code UsabilityRuleset} is a container for {@link UsabilityRule}s. 
    2222 * </p> 
    2323 *  
    … …  
    2828    /** 
    2929     * <p> 
    30      * TODO: comment 
     30     * Gets all {@link UsabilityRule}s contained in the {@code UsabilityRuleset}. 
    3131     * </p> 
    32      * 
    33      * @return 
     32     *  
     33     * @return all contained {@link UsabilityRule}s 
    3434     */ 
    3535    public List<UsabilityRule> evaluationRules(); 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityUsageProblem.java

    r1216 r1217  
    1717import com.google.common.base.Optional; 
    1818 
    19 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect; 
     19import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescription; 
    2020 
    2121/** 
    2222 * <p> 
    23  * TODO comment 
     23 * Common interface for usability problems. Simple speaking, a usability problem is a specific 
     24 * problem that negatively affects the usage of a application. 
    2425 * </p> 
    2526 *  
    2627 * @author Alexander Deicke 
    2728 */ 
    28 public interface UsabilityUsageDefect { 
    29      
    30     public Optional<UsabilityDefect> check(); 
     29public interface UsabilityUsageProblem { 
     30 
     31    /** 
     32     *  
     33     * <p> 
     34     * Checks, if usability problem is present. 
     35     * </p> 
     36     *  
     37     * @return Detailed description of the usability problem, if it was detected. 
     38     */ 
     39    public Optional<UsabilityProblemDescription> check(); 
    3140 
    3241} 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/NoLetterOrDigitRatioMetric.java

    r1152 r1217  
    1515package de.ugoe.cs.autoquest.usability.rules.metrics; 
    1616 
    17 import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.TEXT_INPUT; 
     17import static de.ugoe.cs.autoquest.usability.taskmodel.filter.types.EventTypeFilter.TEXT_INPUT; 
    1818import static de.ugoe.cs.autoquest.usability.util.TextInputUtil.aggregateEnteredTextFromTextInputs; 
    19 import static de.ugoe.cs.autoquest.usability.util.TextInputUtil.characterIsLetterOrDigitPredicate; 
     19import static de.ugoe.cs.autoquest.usability.util.TextInputUtil.characterIsNoLetterOrDigitPredicate; 
    2020 
    2121import java.util.List; 
    … …  
    2828import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
    2929import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller; 
    30 import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver; 
    31 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect; 
     30import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescriptionResolver; 
     31import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescription; 
    3232import de.ugoe.cs.autoquest.usability.rules.UsabilityMetric; 
    3333import de.ugoe.cs.autoquest.usability.rules.UsabilityRule; 
    34 import de.ugoe.cs.autoquest.usability.tasktree.FilterResult; 
    35 import de.ugoe.cs.autoquest.usability.tasktree.IterativeDFSFilterStrategy; 
    36 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskModelFilter; 
     34import de.ugoe.cs.autoquest.usability.taskmodel.filter.FilterResult; 
     35import de.ugoe.cs.autoquest.usability.taskmodel.filter.IterativeDFSFilterStrategy; 
     36import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskModelFilter; 
    3737 
    3838/** 
    3939 * <p> 
    40  * TODO comment 
     40 * Metric, which calculates the ratio ratio between non letter or digit characters and all entered 
     41 * characters. 
    4142 * </p> 
    4243 *  
    … …  
    4748    /** 
    4849     * <p> 
    49      * TODO: comment 
     50     * Constructor. Creates a new {@code NoLetterOrDigitRatioMetric} for a given task model. 
    5051     * </p> 
    51      * 
    52      * @param taskTree 
     52     *  
     53     * @param taskModel 
    5354     */ 
    5455    public NoLetterOrDigitRatioMetric(ITaskModel taskModel) { 
    5556        super(taskModel); 
    5657        this.name = "NoLetterOrDigitRatio"; 
    57         this.defect = new DefectDescriptionResolver().descriptionFor(this.getClass().getSimpleName()); 
     58        this.defect = 
     59            new UsabilityProblemDescriptionResolver().descriptionFor(this.getClass() 
     60                .getSimpleName()); 
    5861    } 
    5962 
    60     /* (non-Javadoc) 
     63    /* 
     64     * (non-Javadoc) 
     65     *  
    6166     * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#check() 
    6267     */ 
    6368    @Override 
    64     public Optional<UsabilityDefect> calculate() { 
     69    public Optional<UsabilityProblemDescription> calculate() { 
    6570        FilterResult textInputEvents = extractNodesFromTaskTree(); 
    6671        float evaluationMetric = calculateEvaluationMetric(textInputEvents.tasksMatchedFilter()); 
    6772        return this.defect.isPresent(evaluationMetric); 
    6873    } 
    69      
     74 
     75    /** 
     76     *  
     77     * <p> 
     78     * Filters all text input events from task model. 
     79     * </p> 
     80     *  
     81     * @return {@code FilterResult} 
     82     */ 
    7083    private FilterResult extractNodesFromTaskTree() { 
    7184        return new TaskModelFilter(new IterativeDFSFilterStrategy()).filterByEventType(TEXT_INPUT) 
    7285            .from(this.taskModel); 
    7386    } 
    74      
     87 
     88    /** 
     89     *  
     90     * <p> 
     91     * Calculates the metric. 
     92     * </p> 
     93     *  
     94     * @param textInputEvents 
     95     *            all text input events 
     96     * @return ratio between non letter or digit characters and all entered characters 
     97     */ 
    7598    private float calculateEvaluationMetric(List<ITask> textInputEvents) { 
    76         Multiset<String> enteredTextFragments = 
    77             aggregateEnteredTextFromTextInputs(textInputEvents); 
     99        Multiset<String> enteredTextFragments = aggregateEnteredTextFromTextInputs(textInputEvents); 
    78100        int allCharactersCount = 0; 
    79101        int noLetterOrDigitCount = 0; 
    … …  
    82104            allCharactersCount += CharMatcher.ANY.countIn(textFragment) * occurencesOfTextFragment; 
    83105            noLetterOrDigitCount += 
    84                 CharMatcher.forPredicate(characterIsLetterOrDigitPredicate()).countIn(textFragment) * 
    85                     occurencesOfTextFragment; 
     106                CharMatcher.forPredicate(characterIsNoLetterOrDigitPredicate()) 
     107                    .countIn(textFragment) * occurencesOfTextFragment; 
    86108        } 
    87109        return allCharactersCount != 0 ? (float) noLetterOrDigitCount / (float) allCharactersCount 
    … …  
    89111    } 
    90112 
    91     /* (non-Javadoc) 
    92      * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller) 
     113    /* 
     114     * (non-Javadoc) 
     115     *  
     116     * @see 
     117     * de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest 
     118     * .usability.EvaluationMethodCaller) 
    93119     */ 
    94120    @Override 
    95     public Optional<UsabilityDefect> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller) 
     121    public Optional<UsabilityProblemDescription> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller) 
    96122    { 
    97123        return evaluationMethodCaller.check(this); 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputEntryRepetitionsMetric.java

    r1199 r1217  
    1515package de.ugoe.cs.autoquest.usability.rules.metrics; 
    1616 
    17 import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.TEXT_INPUT; 
     17import static de.ugoe.cs.autoquest.usability.taskmodel.filter.types.EventTypeFilter.TEXT_INPUT; 
    1818import static de.ugoe.cs.autoquest.usability.util.TextInputUtil.aggregateEnteredTextFromTextInputs; 
    1919 
    … …  
    2828import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
    2929import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller; 
    30 import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver; 
    31 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect; 
     30import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescriptionResolver; 
     31import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescription; 
    3232import de.ugoe.cs.autoquest.usability.rules.UsabilityMetric; 
    3333import de.ugoe.cs.autoquest.usability.rules.UsabilityRule; 
    34 import de.ugoe.cs.autoquest.usability.tasktree.FilterResult; 
    35 import de.ugoe.cs.autoquest.usability.tasktree.IterativeDFSFilterStrategy; 
    36 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskModelFilter; 
     34import de.ugoe.cs.autoquest.usability.taskmodel.filter.FilterResult; 
     35import de.ugoe.cs.autoquest.usability.taskmodel.filter.IterativeDFSFilterStrategy; 
     36import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskModelFilter; 
    3737 
    3838/** 
    3939 * <p> 
    40  * TODO comment 
     40 * Metric, which measures either the repetition of entered words or the maximum repetition of a 
     41 * single word. 
    4142 * </p> 
    4243 *  
    … …  
    4748    /** 
    4849     * <p> 
    49      * TODO: comment 
     50     * Constructor. Creates a new {@link TextInputEntryRepetitionsMetric} for a given task model. 
    5051     * </p> 
    51      * 
    52      * @param taskTree 
     52     *  
     53     * @param taskModel 
    5354     */ 
    5455    public TextInputEntryRepetitionsMetric(ITaskModel taskModel) { 
    5556        super(taskModel); 
    5657        this.name = "TextInputEntryRepetitions"; 
    57         this.defect = new DefectDescriptionResolver().descriptionFor(this.getClass().getSimpleName()); 
     58        this.defect = 
     59            new UsabilityProblemDescriptionResolver().descriptionFor(this.getClass() 
     60                .getSimpleName()); 
    5861    } 
    5962 
    60     /* (non-Javadoc) 
     63    /* 
     64     * (non-Javadoc) 
     65     *  
    6166     * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#check() 
    6267     */ 
    6368    @Override 
    64     public Optional<UsabilityDefect> calculate() { 
     69    public Optional<UsabilityProblemDescription> calculate() { 
    6570        FilterResult textInputEvents = extractNodesFromTaskTree(); 
    6671        float evaluationMetric = calculateEvaluationMetric(textInputEvents.tasksMatchedFilter()); 
    6772        return this.defect.isPresent(evaluationMetric); 
    6873    } 
    69      
     74 
     75    /** 
     76     *  
     77     * <p> 
     78     * Filters all text input events from task model. 
     79     * </p> 
     80     *  
     81     * @return {@code FilterResult} 
     82     */ 
    7083    private FilterResult extractNodesFromTaskTree() { 
    7184        return new TaskModelFilter(new IterativeDFSFilterStrategy()).filterByEventType(TEXT_INPUT) 
    7285            .from(this.taskModel); 
    7386    } 
    74      
     87 
     88    /** 
     89     *  
     90     * <p> 
     91     * Calculates the metric. 
     92     * </p> 
     93     *  
     94     * @param textInputEvents 
     95     *            all text input events 
     96     * @return either number of repeated words or the number of repetitions of the most entered word 
     97     */ 
    7598    private float calculateEvaluationMetric(List<ITask> textInputEvents) { 
    76         Multiset<String> enteredTextFragments = 
    77             aggregateEnteredTextFromTextInputs(textInputEvents); 
     99        Multiset<String> enteredTextFragments = aggregateEnteredTextFromTextInputs(textInputEvents); 
    78100        Multiset<String> orderedTextFragmentsWithMultipleOccurences = 
    79101            onlyTextFragmentsWithMultipleOccurences(enteredTextFragments); 
    … …  
    86108            orderedTextFragmentsWithMultipleOccurences 
    87109                .count(wordWithHighestRepetitionInTextFragments); 
    88         return Math.max(numberOfRepeatedWords, maxRepetitions-1); 
     110        return Math.max(numberOfRepeatedWords, maxRepetitions - 1); 
    89111    } 
    90      
     112 
     113    /** 
     114     *  
     115     * <p> 
     116     * Return only words, which at least entered twice. 
     117     * </p> 
     118     *  
     119     * @param allTextInputs 
     120     *            all text input events 
     121     * @return all word, which used min. twice 
     122     */ 
    91123    private Multiset<String> onlyTextFragmentsWithMultipleOccurences(final Multiset<String> allTextInputs) 
    92124    { 
    … …  
    104136    } 
    105137 
    106     /* (non-Javadoc) 
    107      * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller) 
     138    /* 
     139     * (non-Javadoc) 
     140     *  
     141     * @see 
     142     * de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest 
     143     * .usability.EvaluationMethodCaller) 
    108144     */ 
    109145    @Override 
    110     public Optional<UsabilityDefect> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller) 
     146    public Optional<UsabilityProblemDescription> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller) 
    111147    { 
    112148        return evaluationMethodCaller.check(this); 
    113149    } 
    114      
     150 
    115151} 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputRatioMetric.java

    r1152 r1217  
    1515package de.ugoe.cs.autoquest.usability.rules.metrics; 
    1616 
    17 import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.TEXT_INPUT; 
     17import static de.ugoe.cs.autoquest.usability.taskmodel.filter.types.EventTypeFilter.TEXT_INPUT; 
    1818 
    1919import java.util.List; 
    … …  
    2727import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
    2828import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller; 
    29 import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver; 
    30 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect; 
     29import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescriptionResolver; 
     30import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescription; 
    3131import de.ugoe.cs.autoquest.usability.rules.UsabilityMetric; 
    3232import de.ugoe.cs.autoquest.usability.rules.UsabilityRule; 
    33 import de.ugoe.cs.autoquest.usability.tasktree.FilterResult; 
    34 import de.ugoe.cs.autoquest.usability.tasktree.IterativeDFSFilterStrategy; 
    35 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskModelFilter; 
     33import de.ugoe.cs.autoquest.usability.taskmodel.filter.FilterResult; 
     34import de.ugoe.cs.autoquest.usability.taskmodel.filter.IterativeDFSFilterStrategy; 
     35import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskModelFilter; 
    3636 
    3737/** 
    3838 * <p> 
    39  * TODO comment 
     39 * Metric, which measures the ratio between the text input and the non text input events. 
    4040 * </p> 
    4141 *  
    … …  
    4646    /** 
    4747     * <p> 
    48      * TODO: comment 
     48     * Constructor. Creates a new {@code TextInputRatioMetric} for a given task model. 
    4949     * </p> 
    50      * 
     50     *  
    5151     * @param taskTree 
    5252     */ 
    … …  
    5454        super(taskModel); 
    5555        this.name = "TextInputRatio"; 
    56         this.defect = new DefectDescriptionResolver().descriptionFor(this.getClass().getSimpleName()); 
     56        this.defect = 
     57            new UsabilityProblemDescriptionResolver().descriptionFor(this.getClass() 
     58                .getSimpleName()); 
    5759    } 
    5860 
    59     /* (non-Javadoc) 
     61    /* 
     62     * (non-Javadoc) 
     63     *  
    6064     * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#check() 
    6165     */ 
    6266    @Override 
    63     public Optional<UsabilityDefect> calculate() { 
     67    public Optional<UsabilityProblemDescription> calculate() { 
    6468        FilterResult textInputEvents = extractNodesFromTaskTree(); 
    65         float evaluationMetric = calculateEvaluationMetric(textInputEvents.tasksMatchedFilter(), textInputEvents.tasksNotMatchedFilter()); 
     69        float evaluationMetric = 
     70            calculateEvaluationMetric(textInputEvents.tasksMatchedFilter(), 
     71                                      textInputEvents.tasksNotMatchedFilter()); 
    6672        return this.defect.isPresent(evaluationMetric); 
    6773    } 
    68      
     74 
     75    /** 
     76     *  
     77     * <p> 
     78     * Filters all text input events from task model. 
     79     * </p> 
     80     *  
     81     * @return {@code FilterResult} 
     82     */ 
    6983    private FilterResult extractNodesFromTaskTree() { 
    7084        return new TaskModelFilter(new IterativeDFSFilterStrategy()).filterByEventType(TEXT_INPUT) 
    7185            .from(this.taskModel); 
    7286    } 
    73      
    74     private float calculateEvaluationMetric(List<ITask> textInputEvents, List<ITask> nonTextInputEvents) { 
     87 
     88    /** 
     89     *  
     90     * <p> 
     91     * Calculates the metric. 
     92     * </p> 
     93     *  
     94     * @param textInputEvents 
     95     *            all text input events 
     96     * @param nonTextInputEvents 
     97     *            all non text input events 
     98     * @return ratio between text input and non text input events 
     99     */ 
     100    private float calculateEvaluationMetric(List<ITask> textInputEvents, 
     101                                            List<ITask> nonTextInputEvents) 
     102    { 
    75103        float numberOfTextInputEvents = textInputEvents.size(); 
    76104        float numberOfNonTextInputEvents = nrOfEventTasksNotMatchedFilter(nonTextInputEvents); 
    … …  
    78106    } 
    79107 
     108    /** 
     109     *  
     110     * <p> 
     111     * Filters all {@link IEventTask}s from non text input event. 
     112     * </p> 
     113     *  
     114     * @param nonTextInputEvents 
     115     *            all non text input events 
     116     * @return number of {@link IEventTask}s 
     117     */ 
    80118    private int nrOfEventTasksNotMatchedFilter(List<ITask> nonTextInputEvents) { 
    81         return Iterables.size(Iterables.filter(nonTextInputEvents, 
    82                                                new Predicate<ITask>() { 
     119        return Iterables.size(Iterables.filter(nonTextInputEvents, new Predicate<ITask>() { 
    83120 
    84                                                    @Override 
    85                                                    public boolean apply(ITask task) { 
    86                                                        return task instanceof IEventTask; 
    87                                                    } 
    88                                                })); 
     121            @Override 
     122            public boolean apply(ITask task) { 
     123                return task instanceof IEventTask; 
     124            } 
     125        })); 
    89126    } 
    90127 
    91     /* (non-Javadoc) 
    92      * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller) 
     128    /* 
     129     * (non-Javadoc) 
     130     *  
     131     * @see 
     132     * de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest 
     133     * .usability.EvaluationMethodCaller) 
    93134     */ 
    94135    @Override 
    95     public Optional<UsabilityDefect> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller) 
     136    public Optional<UsabilityProblemDescription> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller) 
    96137    { 
    97138        return evaluationMethodCaller.check(this); 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/InteractionPattern.java

    r1204 r1217  
    1515package de.ugoe.cs.autoquest.usability.rules.patterns; 
    1616 
    17 import java.util.Arrays; 
    1817import java.util.List; 
    1918 
    … …  
    2423import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2524import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
    26 import de.ugoe.cs.autoquest.usability.tasktree.IterativeDFSFilterStrategy; 
    27 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskModelFilter; 
    28 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter; 
     25import de.ugoe.cs.autoquest.usability.taskmodel.filter.IterativeDFSFilterStrategy; 
     26import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskModelFilter; 
     27import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskTypeFilter; 
    2928 
    3029/** 
    3130 * <p> 
    32  * TODO comment 
     31 * A interaction pattern is a simple approach to describe the structure of usage behaviour. 
    3332 * </p> 
    3433 *  
    … …  
    3635 */ 
    3736public class InteractionPattern { 
    38      
     37 
     38    /** 
     39     * <p> 
     40     * {@link TaskModelFilter}, which is used to filter a task model after different {@link ITask}s 
     41     * </p> 
     42     */ 
    3943    private TaskModelFilter taskTreeFilter = new TaskModelFilter(new IterativeDFSFilterStrategy()); 
    40      
    41     private TaskTypeFilter concernedTask; 
    42  
     44 
     45    /** 
     46     * <p> 
     47     * Type of root task. Determines the order in which sub task appear. 
     48     * </p> 
     49     */ 
     50    private TaskTypeFilter rootTask; 
     51 
     52    /** 
     53     * <p> 
     54     * Helper objects, which decide whether or not a defined pattern condition holds. 
     55     * </p> 
     56     */ 
    4357    private List<InteractionPatternVisitor> patternVisitors; 
    44      
     58 
     59    /** 
     60     * <p> 
     61     * Flag, which indicates if the interaction pattern was found within a given task model. 
     62     * </p> 
     63     */ 
    4564    private boolean present = false; 
    46      
    47     /** 
    48      * <p> 
    49      * TODO: comment 
    50      * </p> 
    51      * 
    52      * @param concernedNode 
    53      * @param eventType 
    54      */ 
    55     public InteractionPattern(TaskTypeFilter concernedNode, 
    56                         InteractionPatternVisitor... patternVisitor) 
     65 
     66    /** 
     67     * <p> 
     68     * Constructor. Creates a new interaction pattern for a given root task and a collection of 
     69     * {@link InteractionPatternVisitor}s. 
     70     * </p> 
     71     *  
     72     * @param rootTask 
     73     *            Type of root task, which determines the order in which sub task appear. 
     74     * @param patternVisitors 
     75     *            {@link InteractionPatternVisitor}s, which decide whether or not a defined pattern 
     76     *            condition holds 
     77     */ 
     78    public InteractionPattern(TaskTypeFilter rootTask, 
     79                              List<InteractionPatternVisitor> patternVisitors) 
    5780    { 
    58         this.patternVisitors = Arrays.asList(patternVisitor); 
    59         this.concernedTask = concernedNode; 
    60     } 
    61  
     81        this.patternVisitors = patternVisitors; 
     82        this.rootTask = rootTask; 
     83    } 
     84 
     85    /** 
     86     *  
     87     * <p> 
     88     * Checks if a interaction pattern is contained in a given task model. 
     89     * </p> 
     90     *  
     91     * @param taskModel 
     92     *            {@link ITaskModel}, which might contain the interaction pattern 
     93     * @return true, iff interaction pattern is contained 
     94     */ 
    6295    public boolean containedIn(ITaskModel taskModel) { 
    6396        List<ITask> allConcernedTasks = filterAllConcernedTasksFrom(taskModel); 
    64         for(ITask concernedTask : allConcernedTasks) { 
    65             checkTask(concernedTask);   
    66             if(this.present) break; 
     97        for (ITask concernedTask : allConcernedTasks) { 
     98            checkTask(concernedTask); 
     99            if (this.present) 
     100                break; 
    67101        } 
    68102        return this.present; 
    69103    } 
    70104 
    71     private void checkTask(ITask concernedTask) { 
    72         applyAllVisitors(concernedTask); 
    73         if(allVisitorsArePresent()) { 
     105    /** 
     106     *  
     107     * <p> 
     108     * Checks a single {@link ITask} for the interaction pattern. 
     109     * </p> 
     110     *  
     111     * @param task 
     112     *            task, which might contain the interaction pattern 
     113     */ 
     114    private void checkTask(ITask task) { 
     115        applyAllVisitors(task); 
     116        if (allVisitorsArePresent()) { 
    74117            this.present = true; 
    75         } else { 
     118        } 
     119        else { 
    76120            resetAllVisitors(); 
    77121        } 
    78122    } 
    79      
     123 
     124    /** 
     125     *  
     126     * <p> 
     127     * Checks if a interaction pattern is contained in a given task. 
     128     * </p> 
     129     *  
     130     * @param task 
     131     *            task, which might contain the interaction pattern 
     132     * @return true, iff interaction pattern is contained 
     133     */ 
    80134    public boolean containedIn(ITask task) { 
    81135        checkTask(task); 
    82         return this.present;       
    83     } 
    84  
    85     private void applyAllVisitors(ITask concernedTask) { 
     136        return this.present; 
     137    } 
     138 
     139    /** 
     140     *  
     141     * <p> 
     142     * Method applys all {@link InteractionPatternVisitor}s, to check single interaction pattern 
     143     * conditions. 
     144     * </p> 
     145     *  
     146     * @param task 
     147     *            task, which might contain the interaction pattern 
     148     */ 
     149    private void applyAllVisitors(ITask task) { 
    86150        Optional<InteractionPatternVisitor> previousVisitor = Optional.absent(); 
    87         for(InteractionPatternVisitor visitor : patternVisitors) { 
    88                         if (appliedOnSelectionNode(previousVisitor)) { 
    89                                 for (ITask selection : previousVisitor.get().getRetainedSelectionNodes()) { 
    90                                         selection.accept(visitor); 
    91                                 } 
    92                         } else { 
    93                                 previousVisitor = Optional.of(visitor); 
    94                                 concernedTask.accept(visitor); 
    95                         } 
    96         } 
    97     } 
    98  
    99     private boolean appliedOnSelectionNode(Optional<InteractionPatternVisitor> previousVisitor) { 
    100         return previousVisitor.isPresent() && previousVisitor.get().hasExcludedSelectionNodes(); 
    101     } 
    102  
    103     /** 
    104      * <p> 
    105      * TODO: comment 
    106      * </p> 
    107      * 
    108      * @param taskTree 
    109      * @return 
     151        for (InteractionPatternVisitor visitor : patternVisitors) { 
     152            if (appliedOnSelectionNode(previousVisitor)) { 
     153                for (ITask selection : previousVisitor.get().getRetainedSelectionNodes()) { 
     154                    selection.accept(visitor); 
     155                } 
     156            } 
     157            else { 
     158                previousVisitor = Optional.of(visitor); 
     159                task.accept(visitor); 
     160            } 
     161        } 
     162    } 
     163 
     164    /** 
     165     *  
     166     * <p> 
     167     * Checks, if a {@link InteractionPatternVisitor} was applied on a {@link ISelection} task. 
     168     * </p> 
     169     *  
     170     * @param interactionPatternVisitor 
     171     *            {@link InteractionPatternVisitor} 
     172     * @return true, iff {@link InteractionPatternVisitor} was applied on {@link ISelection} task 
     173     */ 
     174    private boolean appliedOnSelectionNode(Optional<InteractionPatternVisitor> interactionPatternVisitor) 
     175    { 
     176        return interactionPatternVisitor.isPresent() && 
     177            interactionPatternVisitor.get().hasExcludedSelectionNodes(); 
     178    } 
     179 
     180    /** 
     181     * <p> 
     182     * Filters given task model after root task of interaction pattern. 
     183     * </p> 
     184     *  
     185     * @param taskModel 
     186     *            {@link ITaskModel} 
     187     * @return all tasks of task model, which matches root task of interaction pattern 
    110188     */ 
    111189    private List<ITask> filterAllConcernedTasksFrom(ITaskModel taskModel) { 
    112         return this.taskTreeFilter.filterByNodeType(this.concernedTask).from(taskModel).tasksMatchedFilter(); 
    113     } 
    114      
    115     /** 
    116      * <p> 
    117      * TODO: comment 
    118      * </p> 
    119      * 
    120      * @return 
     190        return this.taskTreeFilter.filterByNodeType(this.rootTask).from(taskModel) 
     191            .tasksMatchedFilter(); 
     192    } 
     193 
     194    /** 
     195     * <p> 
     196     * Checks, if all interaction pattern condition are evaluated to true. 
     197     * </p> 
     198     *  
     199     * @return true, iff all interaction pattern condition are true 
    121200     */ 
    122201    private boolean allVisitorsArePresent() { 
    123         Iterable<InteractionPatternVisitor> allPresent = Iterables.filter(this.patternVisitors, new Predicate<InteractionPatternVisitor>() { 
    124              
    125             public boolean apply(InteractionPatternVisitor visitor) { 
    126                 return visitor.isPresent(); 
    127             } 
    128              
    129         }); 
     202        Iterable<InteractionPatternVisitor> allPresent = 
     203            Iterables.filter(this.patternVisitors, new Predicate<InteractionPatternVisitor>() { 
     204 
     205                public boolean apply(InteractionPatternVisitor visitor) { 
     206                    return visitor.isPresent(); 
     207                } 
     208 
     209            }); 
    130210        return Iterables.size(allPresent) == this.patternVisitors.size(); 
    131211    } 
    132      
    133     /** 
    134      * <p> 
    135      * TODO: comment 
    136      * </p> 
    137      * 
     212 
     213    /** 
     214     * <p> 
     215     * Resets all interaction pattern condition. 
     216     * </p> 
     217     *  
    138218     */ 
    139219    private void resetAllVisitors() { 
    140         for(InteractionPatternVisitor visitor : this.patternVisitors) { 
     220        for (InteractionPatternVisitor visitor : this.patternVisitors) { 
    141221            visitor.reset(); 
    142222        } 
    143          
     223 
    144224    } 
    145225 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/InteractionPatternVisitor.java

    r1204 r1217  
    2525import de.ugoe.cs.autoquest.eventcore.StringEventType; 
    2626import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask; 
     27import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration; 
     28import de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional; 
    2729import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection; 
     30import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    2831import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2932import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskVisitor; 
    30 import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter; 
    31 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter; 
     33import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.EventTypeFilter; 
     34import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskTypeFilter; 
    3235 
    3336/** 
    … …  
    3942 */ 
    4043public abstract class InteractionPatternVisitor implements ITaskVisitor { 
    41      
    42         protected TaskTypeFilter taskType; 
    43          
     44 
     45    protected TaskTypeFilter taskType; 
     46 
    4447    protected EventTypeFilter eventType; 
    45      
     48 
    4649    protected InteractionPattern containedPattern; 
    47      
     50 
    4851    protected boolean present = false; 
    49      
     52 
    5053    protected List<ITask> retainedSelectionTasks = Lists.newArrayList(); 
    51      
    52     /* (non-Javadoc) 
    53      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask) 
     54 
     55    /* 
     56     * (non-Javadoc) 
     57     *  
     58     * @see 
     59     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     60     * .IEventTask) 
    5461     */ 
    5562    public void visit(IEventTask event) { 
    56         if(!this.present && isEventVisitor()) { 
     63        if (!this.present && isEventVisitor()) { 
    5764            IEventType eventType = event.getEventType(); 
    58             if(eventType instanceof StringEventType) { 
     65            if (eventType instanceof StringEventType) { 
    5966                this.present = eventType.toString().equals(nameOfEventType()); 
    60             } else { 
     67            } 
     68            else { 
    6169                this.present = eventType.getClass().equals(this.eventType.clazz()); 
    6270            } 
    6371        } 
    6472    } 
    65      
     73 
    6674    public boolean isEventVisitor() { 
    6775        return this.eventType != null && this.containedPattern == null; 
    6876    } 
    69      
     77 
    7078    protected String nameOfEventType() { 
    7179        String ret = StringUtils.EMPTY; 
    7280        Iterable<String> splitted = Splitter.on("_").split(this.eventType.name()); 
    73         for(String str : splitted) { 
     81        for (String str : splitted) { 
    7482            str = str.toLowerCase(); 
    7583            ret += Character.toString(str.charAt(0)).toUpperCase() + str.substring(1); 
    … …  
    7785        return ret; 
    7886    } 
    79      
    80     /* (non-Javadoc) 
    81      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#accept(de.ugoe.cs.autoquest.tasktrees.treeifc.ITask) 
     87 
     88    /* 
     89     * (non-Javadoc) 
     90     *  
     91     * @see 
     92     * de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#accept(de.ugoe.cs.autoquest.tasktrees. 
     93     * treeifc.ITask) 
    8294     */ 
    8395    @Override 
    8496    public void visit(ITask task) { 
    85         task.accept(this); 
    86          
     97        if (task instanceof ISequence) { 
     98            this.visit((ISequence) task); 
     99        } 
     100        else if (task instanceof IIteration) { 
     101            this.visit((IIteration) task); 
     102        } 
     103        else if (task instanceof ISelection) { 
     104            this.visit((ISelection) task); 
     105        } 
     106        else { 
     107            this.visit((IOptional) task); 
     108        } 
    87109    } 
    88      
    89     /* (non-Javadoc) 
    90      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection) 
     110 
     111    /* 
     112     * (non-Javadoc) 
     113     *  
     114     * @see 
     115     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     116     * .ISelection) 
    91117     */ 
    92118    public void visit(ISelection selection) { 
    93         if(isEventVisitor()) { 
     119        if (isEventVisitor()) { 
    94120            retainNodesWherePatternIsPresent(selection); 
    95121            this.present = patternIsPresent(); 
    96         } else { 
    97             this.present = containedPattern.containedIn(selection);   
     122        } 
     123        else { 
     124            this.present = containedPattern.containedIn(selection); 
    98125        } 
    99126    } 
    100127 
    101128    @SuppressWarnings("unchecked") 
    102         protected void retainNodesWherePatternIsPresent(ISelection selection) { 
    103         for(ITask task : selection.getChildren()) { 
     129    protected void retainNodesWherePatternIsPresent(ISelection selection) { 
     130        for (ITask task : selection.getChildren()) { 
    104131            this.present = false; 
    105132            task.accept(this); 
    106             if(this.present && this.taskType.filterPredicate().apply(selection)) { 
     133            if (this.present && this.taskType.filterPredicate().apply(selection)) { 
    107134                this.retainedSelectionTasks.add(selection); 
    108135            } 
    109             if(this.present) { 
    110                 break; 
     136            if (this.present) { 
     137                break; 
    111138            } 
    112139        } 
    113140    } 
    114      
     141 
    115142    private boolean patternIsPresent() { 
    116143        return !this.retainedSelectionTasks.isEmpty(); 
    117144    } 
    118      
     145 
    119146    /** 
    120147     * <p> 
    121148     * TODO: comment 
    122149     * </p> 
    123      * 
     150     *  
    124151     * @return 
    125152     */ 
    … …  
    132159     * TODO: comment 
    133160     * </p> 
    134      * 
     161     *  
    135162     */ 
    136163    public void reset() { 
    … …  
    143170     * TODO: comment 
    144171     * </p> 
    145      * 
     172     *  
    146173     * @return 
    147174     */ 
    … …  
    154181     * TODO: comment 
    155182     * </p> 
    156      * 
     183     *  
    157184     * @return 
    158185     */ 
    … …  
    160187        return this.retainedSelectionTasks; 
    161188    } 
    162      
     189 
    163190} 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/LongFormUsageProblem.java

    r1216 r1217  
    1515package de.ugoe.cs.autoquest.usability.rules.patterns; 
    1616 
    17 import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.MOUSE_CLICK; 
    18 import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.SCROLL; 
    19 import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.TEXT_INPUT; 
    20 import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter.ITERATION; 
    21 import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter.SEQUENCE; 
     17import static de.ugoe.cs.autoquest.usability.taskmodel.filter.types.EventTypeFilter.MOUSE_CLICK; 
     18import static de.ugoe.cs.autoquest.usability.taskmodel.filter.types.EventTypeFilter.SCROLL; 
     19import static de.ugoe.cs.autoquest.usability.taskmodel.filter.types.EventTypeFilter.TEXT_INPUT; 
     20import static de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskTypeFilter.ITERATION; 
     21import static de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskTypeFilter.SEQUENCE; 
    2222 
    2323import com.google.common.base.Optional; 
    … …  
    2525import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel; 
    2626import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller; 
    27 import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver; 
    28 import de.ugoe.cs.autoquest.usability.result.UsabilityDefect; 
     27import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescriptionResolver; 
     28import de.ugoe.cs.autoquest.usability.result.UsabilityProblemDescription; 
    2929import de.ugoe.cs.autoquest.usability.rules.UsabilityRule; 
    30 import de.ugoe.cs.autoquest.usability.rules.UsabilityUsageDefect; 
     30import de.ugoe.cs.autoquest.usability.rules.UsabilityUsageProblem; 
    3131 
    3232/** 
    … …  
    3737 * @author Alexander Deicke 
    3838 */ 
    39 public class LongFormUsageDefect extends UsabilityRule implements UsabilityUsageDefect { 
     39public class LongFormUsageProblem extends UsabilityRule implements UsabilityUsageProblem { 
    4040 
    4141    private InteractionPattern longFormUsagePattern; 
    42      
     42 
    4343    /** 
    4444     * <p> 
    4545     * TODO: comment 
    4646     * </p> 
    47      * 
     47     *  
    4848     * @param taskTree 
    4949     */ 
    50     public LongFormUsageDefect(ITaskModel taskModel) { 
     50    public LongFormUsageProblem(ITaskModel taskModel) { 
    5151        super(taskModel); 
    5252        this.name = "LongFormUsagePattern"; 
    53         this.defect = new DefectDescriptionResolver().descriptionFor(this.getClass().getSimpleName()); 
     53        this.defect = 
     54            new UsabilityProblemDescriptionResolver().descriptionFor(this.getClass() 
     55                .getSimpleName()); 
    5456        initUsagePattern(); 
    5557    } 
    … …  
    5961     * TODO: comment 
    6062     * </p> 
    61      * 
     63     *  
    6264     */ 
    6365    private void initUsagePattern() { 
    64         InteractionPatternBuilder builder = new InteractionPatternBuilder(); 
    65         InteractionPattern fillFormPattern = builder.concernedNode(ITERATION).startsWith(TEXT_INPUT).endsWith(SCROLL).build(); 
    66         this.longFormUsagePattern = builder.concernedNode(SEQUENCE).startsWith(MOUSE_CLICK).contains(fillFormPattern).endsWith(MOUSE_CLICK).build(); 
     66        InteractionPattern fillFormPattern = 
     67            InteractionPatternBuilder.newPattern().rootTask(ITERATION).startsWithEvent(TEXT_INPUT) 
     68                .endsWithEvent(SCROLL).patternFinished().build(); 
     69        this.longFormUsagePattern = 
     70            InteractionPatternBuilder.newPattern().rootTask(SEQUENCE).startsWithEvent(MOUSE_CLICK) 
     71                .containsPattern(fillFormPattern).endsWithEvent(MOUSE_CLICK).patternFinished() 
     72                .build(); 
    6773    } 
    6874 
    69     /* (non-Javadoc) 
     75    /* 
     76     * (non-Javadoc) 
     77     *  
    7078     * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#check() 
    7179     */ 
    7280    @Override 
    73     public Optional<UsabilityDefect> check() { 
    74         Optional<UsabilityDefect> present = Optional.absent(); 
    75         if(this.longFormUsagePattern.containedIn(taskModel)) { 
     81    public Optional<UsabilityProblemDescription> check() { 
     82        Optional<UsabilityProblemDescription> present = Optional.absent(); 
     83        if (this.longFormUsagePattern.containedIn(taskModel)) { 
    7684            present = Optional.of(this.defect); 
    7785        } 
    … …  
    7987    } 
    8088 
    81     /* (non-Javadoc) 
    82      * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller) 
     89    /* 
     90     * (non-Javadoc) 
     91     *  
     92     * @see 
     93     * de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest 
     94     * .usability.EvaluationMethodCaller) 
    8395     */ 
    8496    @Override 
    85     public Optional<UsabilityDefect> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller) 
     97    public Optional<UsabilityProblemDescription> callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller) 
    8698    { 
    8799        return evaluationMethodCaller.check(this); 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsEventVisitor.java

    r1213 r1217  
    2222import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask; 
    2323import de.ugoe.cs.autoquest.usability.rules.patterns.InteractionPatternVisitor; 
    24 import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter; 
    25 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter; 
     24import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.EventTypeFilter; 
     25import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskTypeFilter; 
    2626 
    2727/** 
    … …  
    3838     * TODO: comment 
    3939     * </p> 
    40      * 
     40     *  
    4141     * @param containsType 
    4242     */ 
    … …  
    4646    } 
    4747 
    48     /* (non-Javadoc) 
    49      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration) 
     48    /* 
     49     * (non-Javadoc) 
     50     *  
     51     * @see 
     52     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     53     * .IIteration) 
    5054     */ 
    5155    public void visit(IIteration iteration) { 
    … …  
    5357    } 
    5458 
    55     /* (non-Javadoc) 
    56      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional) 
     59    /* 
     60     * (non-Javadoc) 
     61     *  
     62     * @see 
     63     * de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     64     * .IOptional) 
    5765     */ 
    5866    public void visit(IOptional optional) { 
    … …  
    6068    } 
    6169 
    62     /* (non-Javadoc) 
    63      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence) 
     70    /* 
     71     * (non-Javadoc) 
     72     *  
     73     * @see 
     74     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     75     * .ISequence) 
    6476     */ 
    6577    public void visit(ISequence sequence) { 
    6678        checkAllChildrenAndReturnIfPatternIsPresent(sequence.getChildren()); 
    6779    } 
    68      
     80 
    6981    private void checkAllChildrenAndReturnIfPatternIsPresent(List<ITask> children) { 
    7082        for (ITask task : children) { 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsInteractionPatternVisitor.java

    r1213 r1217  
    2222import de.ugoe.cs.autoquest.usability.rules.patterns.InteractionPattern; 
    2323import de.ugoe.cs.autoquest.usability.rules.patterns.InteractionPatternVisitor; 
    24 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter; 
     24import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskTypeFilter; 
    2525 
    2626/** 
    … …  
    3737     * TODO: comment 
    3838     * </p> 
    39      * 
     39     *  
    4040     * @param containsPattern 
    4141     */ 
    42     public ContainsInteractionPatternVisitor(InteractionPattern containsPattern, TaskTypeFilter taskType) { 
     42    public ContainsInteractionPatternVisitor(InteractionPattern containsPattern, 
     43                                             TaskTypeFilter taskType) 
     44    { 
    4345        this.containedPattern = containsPattern; 
    4446        this.taskType = taskType; 
    4547    } 
    4648 
    47     /* (non-Javadoc) 
    48      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration) 
     49    /* 
     50     * (non-Javadoc) 
     51     *  
     52     * @see 
     53     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     54     * .IIteration) 
    4955     */ 
    5056    public void visit(IIteration iteration) { 
    … …  
    5258    } 
    5359 
    54     /* (non-Javadoc) 
    55      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional) 
     60    /* 
     61     * (non-Javadoc) 
     62     *  
     63     * @see 
     64     * de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     65     * .IOptional) 
    5666     */ 
    5767    public void visit(IOptional optional) { 
    … …  
    5969    } 
    6070 
    61     /* (non-Javadoc) 
    62      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence) 
     71    /* 
     72     * (non-Javadoc) 
     73     *  
     74     * @see 
     75     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     76     * .ISequence) 
    6377     */ 
    6478    public void visit(ISequence sequence) { 
    6579        checkAllChildrenAndReturnIfPatternIsPresent(sequence); 
    6680    } 
    67      
     81 
    6882    private void checkAllChildrenAndReturnIfPatternIsPresent(ISequence sequence) { 
    6983        for (ITask child : sequence.getChildren()) { 
    70             if(checkTaskAndReturnIfPatternIsPresent(child)) { 
     84            if (checkTaskAndReturnIfPatternIsPresent(child)) { 
    7185                this.present = true; 
    7286                break; 
    … …  
    7488        } 
    7589    } 
    76      
     90 
    7791    private boolean checkTaskAndReturnIfPatternIsPresent(ITask task) { 
    78         if(isEvent(task)) return false; 
     92        if (isEvent(task)) 
     93            return false; 
    7994        return this.containedPattern.containedIn(task); 
    8095    } 
    81      
     96 
    8297    private boolean isEvent(ITask task) { 
    8398        return task instanceof IEventTask; 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithEventVisitor.java

    r1213 r1217  
    1919import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    2020import de.ugoe.cs.autoquest.usability.rules.patterns.InteractionPatternVisitor; 
    21 import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter; 
    22 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter; 
     21import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.EventTypeFilter; 
     22import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskTypeFilter; 
    2323import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil; 
    2424 
    … …  
    3636     * TODO: comment 
    3737     * </p> 
    38      * 
     38     *  
    3939     * @param eventType 
    4040     */ 
    … …  
    4444    } 
    4545 
    46     /* (non-Javadoc) 
    47      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration) 
     46    /* 
     47     * (non-Javadoc) 
     48     *  
     49     * @see 
     50     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     51     * .IIteration) 
    4852     */ 
    4953    public void visit(IIteration iteration) { 
    … …  
    5155    } 
    5256 
    53     /* (non-Javadoc) 
    54      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional) 
     57    /* 
     58     * (non-Javadoc) 
     59     *  
     60     * @see 
     61     * de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     62     * .IOptional) 
    5563     */ 
    5664    public void visit(IOptional optional) { 
    … …  
    5866    } 
    5967 
    60     /* (non-Javadoc) 
    61      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence) 
     68    /* 
     69     * (non-Javadoc) 
     70     *  
     71     * @see 
     72     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     73     * .ISequence) 
    6274     */ 
    6375    public void visit(ISequence sequence) { 
    64         PatternsVisitorUtil.lastNodeOf(sequence.getChildren()).accept(this);    
     76        PatternsVisitorUtil.lastSubTaskOf(sequence.getChildren()).accept(this); 
    6577    } 
    66      
     78 
    6779} 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithInteractionPatternVisitor.java

    r1213 r1217  
    2222import de.ugoe.cs.autoquest.usability.rules.patterns.InteractionPattern; 
    2323import de.ugoe.cs.autoquest.usability.rules.patterns.InteractionPatternVisitor; 
    24 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter; 
     24import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskTypeFilter; 
    2525import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil; 
    2626 
    … …  
    3838     * TODO: comment 
    3939     * </p> 
    40      * 
     40     *  
    4141     * @param endsWithPattern 
    4242     */ 
    43     public EndsWithInteractionPatternVisitor(InteractionPattern endsWithPattern, TaskTypeFilter taskType) { 
     43    public EndsWithInteractionPatternVisitor(InteractionPattern endsWithPattern, 
     44                                             TaskTypeFilter taskType) 
     45    { 
    4446        this.containedPattern = endsWithPattern; 
    4547        this.taskType = taskType; 
    4648    } 
    4749 
    48     /* (non-Javadoc) 
    49      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration) 
     50    /* 
     51     * (non-Javadoc) 
     52     *  
     53     * @see 
     54     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     55     * .IIteration) 
    5056     */ 
    5157    public void visit(IIteration iteration) { 
    52         this.present = containedPattern.containedIn(iteration);  
     58        this.present = containedPattern.containedIn(iteration); 
    5359    } 
    5460 
    55     /* (non-Javadoc) 
    56      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional) 
     61    /* 
     62     * (non-Javadoc) 
     63     *  
     64     * @see 
     65     * de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     66     * .IOptional) 
    5767     */ 
    5868    public void visit(IOptional optional) { 
    59         this.present = containedPattern.containedIn(optional);  
     69        this.present = containedPattern.containedIn(optional); 
    6070    } 
    6171 
    62     /* (non-Javadoc) 
    63      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence) 
     72    /* 
     73     * (non-Javadoc) 
     74     *  
     75     * @see 
     76     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     77     * .ISequence) 
    6478     */ 
    6579    public void visit(ISequence sequence) { 
    66         ITask lastTask = PatternsVisitorUtil.lastNodeOf(sequence.getChildren()); 
    67         if(isEvent(lastTask)) { 
     80        ITask lastTask = PatternsVisitorUtil.lastSubTaskOf(sequence.getChildren()); 
     81        if (isEvent(lastTask)) { 
    6882            this.present = containedPattern.containedIn(sequence); 
    69         } else { 
     83        } 
     84        else { 
    7085            this.present = containedPattern.containedIn(lastTask); 
    71         }     
     86        } 
    7287    } 
    7388 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithEventVisitor.java

    r1213 r1217  
    1919import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence; 
    2020import de.ugoe.cs.autoquest.usability.rules.patterns.InteractionPatternVisitor; 
    21 import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter; 
    22 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter; 
     21import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.EventTypeFilter; 
     22import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskTypeFilter; 
    2323import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil; 
    2424 
    … …  
    3636     * TODO: comment 
    3737     * </p> 
    38      * 
     38     *  
    3939     * @param eventType 
    4040     */ 
    … …  
    4444    } 
    4545 
    46     /* (non-Javadoc) 
    47      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration) 
     46    /* 
     47     * (non-Javadoc) 
     48     *  
     49     * @see 
     50     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     51     * .IIteration) 
    4852     */ 
    4953    public void visit(IIteration iteration) { 
    5054        iteration.getMarkedTask().accept(this); 
    5155    } 
    52      
    53     /* (non-Javadoc) 
    54      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional) 
     56 
     57    /* 
     58     * (non-Javadoc) 
     59     *  
     60     * @see 
     61     * de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     62     * .IOptional) 
    5563     */ 
    5664    public void visit(IOptional optional) { 
    … …  
    5866    } 
    5967 
    60     /* (non-Javadoc) 
    61      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence) 
     68    /* 
     69     * (non-Javadoc) 
     70     *  
     71     * @see 
     72     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     73     * .ISequence) 
    6274     */ 
    6375    public void visit(ISequence sequence) { 
    64         PatternsVisitorUtil.firstNodeOf(sequence.getChildren()).accept(this);    
     76        PatternsVisitorUtil.firstSubtaskOf(sequence.getChildren()).accept(this); 
    6577    } 
    66      
     78 
    6779} 

  • trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithInteractionPatternVisitor.java

    r1213 r1217  
    2222import de.ugoe.cs.autoquest.usability.rules.patterns.InteractionPattern; 
    2323import de.ugoe.cs.autoquest.usability.rules.patterns.InteractionPatternVisitor; 
    24 import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTypeFilter; 
     24import de.ugoe.cs.autoquest.usability.taskmodel.filter.types.TaskTypeFilter; 
    2525import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil; 
    2626 
    … …  
    3838     * TODO: comment 
    3939     * </p> 
    40      * 
     40     *  
    4141     * @param startsWithPattern 
    4242     */ 
    43     public StartsWithInteractionPatternVisitor(InteractionPattern startsWithPattern, TaskTypeFilter taskType) { 
     43    public StartsWithInteractionPatternVisitor(InteractionPattern startsWithPattern, 
     44                                               TaskTypeFilter taskType) 
     45    { 
    4446        this.containedPattern = startsWithPattern; 
    4547        this.taskType = taskType; 
    4648    } 
    4749 
    48     /* (non-Javadoc) 
    49      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration) 
     50    /* 
     51     * (non-Javadoc) 
     52     *  
     53     * @see 
     54     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     55     * .IIteration) 
    5056     */ 
    5157    public void visit(IIteration iteration) { 
    52         this.present = containedPattern.containedIn(iteration);   
     58        this.present = containedPattern.containedIn(iteration); 
    5359    } 
    5460 
    55     /* (non-Javadoc) 
    56      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional) 
     61    /* 
     62     * (non-Javadoc) 
     63     *  
     64     * @see 
     65     * de.ugoe.cs.autoquest.tasktrees.treeifc.TaskVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     66     * .IOptional) 
    5767     */ 
    5868    public void visit(IOptional optional) { 
    59         this.present = containedPattern.containedIn(optional);   
     69        this.present = containedPattern.containedIn(optional); 
    6070    } 
    6171 
    62     /* (non-Javadoc) 
    63      * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence) 
     72    /* 
     73     * (non-Javadoc) 
     74     *  
     75     * @see 
     76     * de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc 
     77     * .ISequence) 
    6478     */ 
    6579    public void visit(ISequence sequence) { 
    66         ITask firstTask = PatternsVisitorUtil.firstNodeOf(sequence.getChildren()); 
    67         if(isEvent(firstTask)) { 
     80        ITask firstTask = PatternsVisitorUtil.firstSubtaskOf(sequence.getChildren()); 
     81        if (isEvent(firstTask)) { 
    6882            this.present = containedPattern.containedIn(sequence); 
    69         } else { 
     83        } 
     84        else { 
    7085            this.present = containedPattern.containedIn(firstTask); 
    71         }     
     86        } 
    7287    } 
    7388 
Note: See TracChangeset for help on using the changeset viewer.