Ignore:
Timestamp:
08/17/12 09:26:21 (12 years ago)
Author:
pharms
Message:
  • adapted to new coding style in quest
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/quest-core-usability/src/main/java/de/ugoe/cs/quest/usability/TextInputStatisticsRule.java

    r496 r561  
    1 //------------------------------------------------------------------------------------------------- 
    21// Module    : $RCSfile: TextInputStatisticsRule.java,v $ 
    32// Version   : $Revision: 0.0 $  $Author: pharms $  $Date: 16.07.2012 $ 
    … …  
    54// Creation  : 2012 by pharms 
    65// Copyright : Patrick Harms, 2012 
    7 //------------------------------------------------------------------------------------------------- 
     6 
     7 
    88package de.ugoe.cs.quest.usability; 
    99 
    … …  
    1414import java.util.Map; 
    1515 
    16 import de.ugoe.cs.quest.eventcore.guimodel.TextArea; 
    17 import de.ugoe.cs.quest.eventcore.guimodel.TextField; 
    18 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTree; 
    19 import de.ugoe.cs.quest.tasktrees.treeifc.TaskTreeNode; 
    20 import de.ugoe.cs.quest.tasktrees.treeifc.TextInputInteractionTask; 
    21  
    22 //------------------------------------------------------------------------------------------------- 
     16import de.ugoe.cs.quest.eventcore.guimodel.ITextArea; 
     17import de.ugoe.cs.quest.eventcore.guimodel.ITextField; 
     18import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTree; 
     19import de.ugoe.cs.quest.tasktrees.treeifc.ITaskTreeNode; 
     20import de.ugoe.cs.quest.tasktrees.treeifc.ITextInputEventTask; 
     21 
    2322/** 
    2423 * TODO comment 
    … …  
    2726 * @author 2012, last modified by $Author: pharms$ 
    2827 */ 
    29 //------------------------------------------------------------------------------------------------- 
    30 public class TextInputStatisticsRule implements de.ugoe.cs.quest.usability.UsabilityEvaluationRule 
    31 { 
    32  
    33   //----------------------------------------------------------------------------------------------- 
    34   /* (non-Javadoc) 
    35    * @see de.ugoe.cs.usability.UsabilityEvaluationRule#evaluate(TaskTree) 
    36    */ 
    37   //----------------------------------------------------------------------------------------------- 
    38   @Override 
    39   public UsabilityEvaluationResult evaluate(TaskTree taskTree) 
    40   { 
    41     TextInputStatistics statistics = new TextInputStatistics(); 
    42     calculateStatistics(taskTree.getRoot(), statistics); 
    43      
    44     UsabilityEvaluationResult results = new UsabilityEvaluationResult(); 
    45     analyzeStatistics(statistics, results); 
    46      
    47     return results; 
    48   } 
    49  
    50   //----------------------------------------------------------------------------------------------- 
    51   /** 
    52    * TODO: comment 
    53    * 
    54    * @param statistics 
    55    * @param results 
    56    */ 
    57   //----------------------------------------------------------------------------------------------- 
    58   private void analyzeStatistics(TextInputStatistics statistics, UsabilityEvaluationResult results) 
    59   { 
    60     checkTextInputRatio(statistics, results); 
    61     checkTextFieldEntryRepetitions(statistics, results); 
    62     checkTextFieldNoLetterOrDigitInputs(statistics, results); 
    63   } 
    64  
    65   //----------------------------------------------------------------------------------------------- 
    66   /** 
    67    * TODO: comment 
    68    * 
    69    * @param statistics 
    70    * @param results  
    71    */ 
    72   //----------------------------------------------------------------------------------------------- 
    73   private void checkTextInputRatio(TextInputStatistics       statistics, 
     28public class TextInputStatisticsRule implements de.ugoe.cs.quest.usability.UsabilityEvaluationRule { 
     29 
     30    /* 
     31     * (non-Javadoc) 
     32     *  
     33     * @see de.ugoe.cs.usability.UsabilityEvaluationRule#evaluate(TaskTree) 
     34     */ 
     35    @Override 
     36    public UsabilityEvaluationResult evaluate(ITaskTree taskTree) { 
     37        TextInputStatistics statistics = new TextInputStatistics(); 
     38        calculateStatistics(taskTree.getRoot(), statistics); 
     39 
     40        UsabilityEvaluationResult results = new UsabilityEvaluationResult(); 
     41        analyzeStatistics(statistics, results); 
     42 
     43        return results; 
     44    } 
     45 
     46    /** 
     47     * TODO: comment 
     48     *  
     49     * @param statistics 
     50     * @param results 
     51     */ 
     52    private void analyzeStatistics(TextInputStatistics       statistics, 
    7453                                   UsabilityEvaluationResult results) 
    75   { 
    76     float allTextFieldInputs = 
    77       statistics.getNoOfTextFieldInputs() + statistics.getNoOfTextAreaInputs(); 
    78      
    79     float ratio = allTextFieldInputs / (float) statistics.getNoOfAllInteractions(); 
    80      
    81     UsabilityDefectSeverity severity = null; 
    82     if (ratio > 0.9) 
    8354    { 
    84       severity = UsabilityDefectSeverity.HIGH; 
    85     } 
    86     else if (ratio > 0.7) 
     55        checkTextInputRatio(statistics, results); 
     56        checkTextFieldEntryRepetitions(statistics, results); 
     57        checkTextFieldNoLetterOrDigitInputs(statistics, results); 
     58    } 
     59 
     60    /** 
     61     * TODO: comment 
     62     *  
     63     * @param statistics 
     64     * @param results 
     65     */ 
     66    private void checkTextInputRatio(TextInputStatistics       statistics, 
     67                                     UsabilityEvaluationResult results) 
    8768    { 
    88       severity = UsabilityDefectSeverity.MEDIUM; 
    89     } 
    90     else if (ratio > 0.5) 
     69        float allTextFieldInputs = 
     70            statistics.getNoOfTextFieldInputs() + statistics.getNoOfTextAreaInputs(); 
     71 
     72        float ratio = allTextFieldInputs / (float) statistics.getNoOfAllEvents(); 
     73 
     74        UsabilityDefectSeverity severity = null; 
     75        if (ratio > 0.9) { 
     76            severity = UsabilityDefectSeverity.HIGH; 
     77        } 
     78        else if (ratio > 0.7) { 
     79            severity = UsabilityDefectSeverity.MEDIUM; 
     80        } 
     81        else if (ratio > 0.5) { 
     82            severity = UsabilityDefectSeverity.LOW; 
     83        } 
     84        else if (ratio > 0.3) { 
     85            severity = UsabilityDefectSeverity.INFO; 
     86        } 
     87 
     88        if (severity != null) { 
     89            Map<String, String> parameters = new HashMap<String, String>(); 
     90            parameters.put("textInputRatio", DecimalFormat.getInstance().format(ratio * 100) + "%"); 
     91 
     92            results.addDefect 
     93                (new UsabilityDefect(severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO, 
     94                                     parameters)); 
     95        } 
     96    } 
     97 
     98    /** 
     99     * TODO: comment 
     100     *  
     101     * @param statistics 
     102     * @param results 
     103     */ 
     104    private void checkTextFieldEntryRepetitions(TextInputStatistics       statistics, 
     105                                                UsabilityEvaluationResult results) 
    91106    { 
    92       severity = UsabilityDefectSeverity.LOW; 
    93     } 
    94     else if (ratio > 0.3) 
     107        Map<String, Integer> words = new HashMap<String, Integer>(); 
     108        int numberOfRepeatedWords = 0; 
     109        int maxRepetitions = 0; 
     110 
     111        for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) { 
     112            String[] fragments = statistics.getTextFieldInputFragments(i); 
     113            for (String fragment : fragments) { 
     114                if (!"".equals(fragment.trim())) { 
     115                    Integer count = words.get(fragment); 
     116                    if (count == null) { 
     117                        words.put(fragment, 1); 
     118                    } 
     119                    else { 
     120                        count++; 
     121                        words.put(fragment, count); 
     122                        maxRepetitions = Math.max(count, maxRepetitions); 
     123 
     124                        if (count == 2) { 
     125                            // do not calculate repeated words several times 
     126                            numberOfRepeatedWords++; 
     127                        } 
     128                    } 
     129                } 
     130            } 
     131        } 
     132 
     133        UsabilityDefectSeverity severity = null; 
     134        if ((numberOfRepeatedWords > 10) || (maxRepetitions > 10)) { 
     135            severity = UsabilityDefectSeverity.HIGH; 
     136        } 
     137        else if ((numberOfRepeatedWords > 4) || (maxRepetitions > 4)) { 
     138            severity = UsabilityDefectSeverity.MEDIUM; 
     139        } 
     140        else if ((numberOfRepeatedWords > 2) || (maxRepetitions > 2)) { 
     141            severity = UsabilityDefectSeverity.LOW; 
     142        } 
     143        else if ((numberOfRepeatedWords > 1) || (maxRepetitions > 1)) { 
     144            severity = UsabilityDefectSeverity.INFO; 
     145        } 
     146 
     147        if (severity != null) { 
     148            Map<String, String> parameters = new HashMap<String, String>(); 
     149            parameters.put("textRepetitionRatio", numberOfRepeatedWords + 
     150                           " repeated tokens, up to " + maxRepetitions + " repetitions per token"); 
     151 
     152            results.addDefect 
     153                (new UsabilityDefect(severity, 
     154                                     UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS, 
     155                                     parameters)); 
     156        } 
     157    } 
     158 
     159    /** 
     160     * TODO: comment 
     161     *  
     162     * @param statistics 
     163     * @param results 
     164     */ 
     165    private void checkTextFieldNoLetterOrDigitInputs(TextInputStatistics       statistics, 
     166                                                     UsabilityEvaluationResult results) 
    95167    { 
    96       severity = UsabilityDefectSeverity.INFO; 
    97     } 
    98      
    99     if (severity != null) 
    100     { 
    101       Map<String, String> parameters = new HashMap<String, String>(); 
    102       parameters.put("textInputRatio", DecimalFormat.getInstance().format(ratio * 100) + "%"); 
    103        
    104       results.addDefect 
    105         (new UsabilityDefect 
    106            (severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_RATIO, parameters)); 
    107     } 
    108   } 
    109  
    110   //----------------------------------------------------------------------------------------------- 
    111   /** 
    112    * TODO: comment 
    113    * 
    114    * @param statistics 
    115    * @param results 
    116    */ 
    117   //----------------------------------------------------------------------------------------------- 
    118   private void checkTextFieldEntryRepetitions(TextInputStatistics       statistics, 
    119                                               UsabilityEvaluationResult results) 
    120   { 
    121     Map<String, Integer> words = new HashMap<String, Integer>(); 
    122     int numberOfRepeatedWords = 0; 
    123     int maxRepetitions = 0; 
    124  
    125     for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) 
    126     { 
    127       String[] fragments = statistics.getTextFieldInputFragments(i); 
    128       for (String fragment : fragments) 
    129       { 
    130         if (!"".equals(fragment.trim())) 
     168        int allCharactersCount = 0; 
     169        int noLetterOrDigitCount = 0; 
     170 
     171        for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) { 
     172            String[] fragments = statistics.getTextFieldInputFragments(i); 
     173            for (String fragment : fragments) { 
     174                String effectiveFragment = fragment.trim(); 
     175                for (int j = 0; j < effectiveFragment.length(); j++) { 
     176                    if (!Character.isWhitespace(effectiveFragment.charAt(j))) { 
     177                        if (!Character.isLetterOrDigit(effectiveFragment.charAt(j))) { 
     178                            noLetterOrDigitCount++; 
     179                        } 
     180                        allCharactersCount++; 
     181                    } 
     182                } 
     183            } 
     184        } 
     185 
     186        float ratio = (float) noLetterOrDigitCount / (float) allCharactersCount; 
     187 
     188        UsabilityDefectSeverity severity = null; 
     189        if (ratio > 0.1) // every 10th sign 
    131190        { 
    132           Integer count = words.get(fragment); 
    133           if (count == null) 
    134           { 
    135             words.put(fragment, 1); 
    136           } 
    137           else 
    138           { 
    139             count++; 
    140             words.put(fragment, count); 
    141             maxRepetitions = Math.max(count, maxRepetitions); 
    142  
    143             if (count == 2) 
    144             { 
    145               // do not calculate repeated words several times 
    146               numberOfRepeatedWords++; 
     191            severity = UsabilityDefectSeverity.HIGH; 
     192        } 
     193        else if (ratio > 0.05) // every 20th sign 
     194        { 
     195            severity = UsabilityDefectSeverity.MEDIUM; 
     196        } 
     197        else if (ratio > 0.02) // every 50th sign 
     198        { 
     199            severity = UsabilityDefectSeverity.LOW; 
     200        } 
     201        else if (ratio > 0.01) // every 100th sign 
     202        { 
     203            severity = UsabilityDefectSeverity.INFO; 
     204        } 
     205 
     206        if (severity != null) { 
     207            Map<String, String> parameters = new HashMap<String, String>(); 
     208            parameters.put("noLetterOrDigitRatio", allCharactersCount + " entered characters of " + 
     209                           "which " + noLetterOrDigitCount + " were no letter or digit"); 
     210 
     211            results.addDefect 
     212                (new UsabilityDefect(severity, 
     213                                     UsabilityDefectDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO, 
     214                                     parameters)); 
     215        } 
     216    } 
     217 
     218    /** 
     219     * TODO: comment 
     220     *  
     221     * @param taskTree 
     222     * @param statistics 
     223     */ 
     224    private void calculateStatistics(ITaskTreeNode node, TextInputStatistics statistics) { 
     225        if (node instanceof ITextInputEventTask) { 
     226            calculateStatistics((ITextInputEventTask) node, statistics); 
     227        } 
     228        else { 
     229            if ((node.getChildren() == null) || (node.getChildren().size() == 0)) { 
     230                statistics.incrementNoOfOtherEventTasks(); 
    147231            } 
    148           } 
    149         } 
    150       } 
    151     } 
    152      
    153     UsabilityDefectSeverity severity = null; 
    154     if ((numberOfRepeatedWords > 10) || (maxRepetitions > 10)) 
    155     { 
    156       severity = UsabilityDefectSeverity.HIGH; 
    157     } 
    158     else if ((numberOfRepeatedWords > 4) || (maxRepetitions > 4)) 
    159     { 
    160       severity = UsabilityDefectSeverity.MEDIUM; 
    161     } 
    162     else if ((numberOfRepeatedWords > 2) || (maxRepetitions > 2)) 
    163     { 
    164       severity = UsabilityDefectSeverity.LOW; 
    165     } 
    166     else if ((numberOfRepeatedWords > 1) || (maxRepetitions > 1)) 
    167     { 
    168       severity = UsabilityDefectSeverity.INFO; 
    169     } 
    170      
    171     if (severity != null) 
    172     { 
    173       Map<String, String> parameters = new HashMap<String, String>(); 
    174       parameters.put("textRepetitionRatio", numberOfRepeatedWords + " repeated tokens, up to " + 
    175                      maxRepetitions + " repetitions per token"); 
    176  
    177       results.addDefect 
    178         (new UsabilityDefect 
    179            (severity, UsabilityDefectDescription.TEXT_FIELD_INPUT_REPETITIONS, parameters)); 
    180     } 
    181   } 
    182  
    183   //----------------------------------------------------------------------------------------------- 
    184   /** 
    185    * TODO: comment 
    186    * 
    187    * @param statistics 
    188    * @param results 
    189    */ 
    190   //----------------------------------------------------------------------------------------------- 
    191   private void checkTextFieldNoLetterOrDigitInputs(TextInputStatistics       statistics, 
    192                                                    UsabilityEvaluationResult results) 
    193   { 
    194     int allCharactersCount = 0; 
    195     int noLetterOrDigitCount = 0; 
    196  
    197     for (int i = 0; i < statistics.getNoOfTextFieldInputs(); i++) 
    198     { 
    199       String[] fragments = statistics.getTextFieldInputFragments(i); 
    200       for (String fragment : fragments) 
    201       { 
    202         String effectiveFragment = fragment.trim(); 
    203         for (int j = 0; j < effectiveFragment.length(); j++) 
    204         { 
    205           if (!Character.isWhitespace(effectiveFragment.charAt(j))) 
    206           { 
    207             if (!Character.isLetterOrDigit(effectiveFragment.charAt(j))) 
    208             { 
    209               noLetterOrDigitCount++; 
     232            else { 
     233                for (ITaskTreeNode child : node.getChildren()) { 
     234                    calculateStatistics(child, statistics); 
     235                } 
    210236            } 
    211             allCharactersCount++; 
    212           } 
    213         } 
    214       } 
    215     } 
    216      
    217     float ratio = (float) noLetterOrDigitCount / (float) allCharactersCount; 
    218      
    219     UsabilityDefectSeverity severity = null; 
    220     if (ratio > 0.1) // every 10th sign 
    221     { 
    222       severity = UsabilityDefectSeverity.HIGH; 
    223     } 
    224     else if (ratio > 0.05) // every 20th sign 
    225     { 
    226       severity = UsabilityDefectSeverity.MEDIUM; 
    227     } 
    228     else if (ratio > 0.02) // every 50th sign 
    229     { 
    230       severity = UsabilityDefectSeverity.LOW; 
    231     } 
    232     else if (ratio > 0.01) // every 100th sign 
    233     { 
    234       severity = UsabilityDefectSeverity.INFO; 
    235     } 
    236      
    237     if (severity != null) 
    238     { 
    239       Map<String, String> parameters = new HashMap<String, String>(); 
    240       parameters.put("noLetterOrDigitRatio", allCharactersCount + " entered characters of " + 
    241                      "which " + noLetterOrDigitCount + " were no letter or digit"); 
    242  
    243       results.addDefect 
    244         (new UsabilityDefect 
    245            (severity, UsabilityDefectDescription.TEXT_FIELD_NO_LETTER_OR_DIGIT_RATIO, parameters)); 
    246     } 
    247   } 
    248  
    249   //----------------------------------------------------------------------------------------------- 
    250   /** 
    251    * TODO: comment 
    252    * 
    253    * @param taskTree 
    254    * @param statistics 
    255    */ 
    256   //----------------------------------------------------------------------------------------------- 
    257   private void calculateStatistics(TaskTreeNode node, TextInputStatistics statistics) 
    258   { 
    259     if (node instanceof TextInputInteractionTask) 
    260     { 
    261       calculateStatistics((TextInputInteractionTask) node, statistics); 
    262     } 
    263     else 
    264     { 
    265       if ((node.getChildren() == null) || 
    266           (node.getChildren().size() == 0)) 
    267       { 
    268         statistics.incrementNoOfOtherInteractionTasks(); 
    269       } 
    270       else 
    271       { 
    272         for (TaskTreeNode child : node.getChildren()) 
    273         { 
    274           calculateStatistics(child, statistics); 
    275         } 
    276       } 
    277     } 
    278   } 
    279  
    280   //----------------------------------------------------------------------------------------------- 
    281   /** 
    282    * TODO: comment 
    283    * 
    284    * @param taskTree 
    285    * @param statistics 
    286    */ 
    287   //----------------------------------------------------------------------------------------------- 
    288   private void calculateStatistics(TextInputInteractionTask node, TextInputStatistics statistics) 
    289   { 
    290     String[] fragments = determineTextFragments(node.getEnteredText()); 
    291      
    292     if (node.getGUIElement() instanceof TextField) 
    293     { 
    294       statistics.addTextFieldInput(node, fragments); 
    295     } 
    296     else if (node.getGUIElement() instanceof TextArea) 
    297     { 
    298       statistics.addTextAreaInput(node, fragments); 
    299     } 
    300   } 
    301    
    302   //----------------------------------------------------------------------------------------------- 
    303   /** 
    304    * TODO: comment 
    305    * 
    306    * @param enteredText 
    307    * @return 
    308    */ 
    309   //----------------------------------------------------------------------------------------------- 
    310   private String[] determineTextFragments(String enteredText) 
    311   { 
    312     List<String> fragments = new ArrayList<String>(); 
    313      
    314     StringBuffer fragment = new StringBuffer(); 
    315     char lastChar = 0; 
    316      
    317     for (int i = 0; i < enteredText.length(); i++) 
    318     { 
    319       char currentChar = enteredText.charAt(i); 
    320        
    321       if (!isEqualCharacterType(lastChar, currentChar)) 
    322       { 
    323         // the previous fragment ended. so finalize it and start a new one 
    324         if ((fragment != null) && (fragment.length() > 0)) 
    325         { 
    326           fragments.add(fragment.toString()); 
    327           fragment = new StringBuffer(); 
    328         } 
    329       } 
    330  
    331       fragment.append(currentChar); 
    332       lastChar = currentChar; 
    333     } 
    334      
    335     if ((fragment != null) && (fragment.length() > 0)) 
    336     { 
    337       fragments.add(fragment.toString()); 
    338     } 
    339      
    340     return fragments.toArray(new String[fragments.size()]); 
    341   } 
    342  
    343   //----------------------------------------------------------------------------------------------- 
    344   /** 
    345    * TODO: comment 
    346    * 
    347    * @param lastChar 
    348    * @param currentChar 
    349    * @return 
    350    */ 
    351   //----------------------------------------------------------------------------------------------- 
    352   private boolean isEqualCharacterType(char char1, char char2) 
    353   { 
    354     return 
    355       ((char1 == char2) || 
    356        (Character.isWhitespace(char1) && Character.isWhitespace(char2)) || 
    357        (Character.isDigit(char1) && Character.isDigit(char2)) || 
    358        (Character.isLetter(char1) && Character.isLetter(char2)) || 
    359        (Character.isJavaIdentifierPart(char1) && Character.isJavaIdentifierPart(char2))); 
    360   } 
    361  
    362   //------------------------------------------------------------------------------------------------- 
    363   /** 
    364    * TODO comment 
    365    *  
    366    * @version $Revision: $ $Date: 16.07.2012$ 
    367    * @author 2012, last modified by $Author: pharms$ 
    368    */ 
    369   //------------------------------------------------------------------------------------------------- 
    370   public static class TextInputStatistics 
    371   { 
    372     /** */ 
    373     private List<Object[]> mTextFieldInputs = new ArrayList<Object[]>(); 
    374      
    375     /** */ 
    376     private List<Object[]> mTextAreaInputs = new ArrayList<Object[]>(); 
    377      
    378     /** */ 
    379     private int mOtherInteractionsCount; 
    380      
    381     //----------------------------------------------------------------------------------------------- 
    382     /** 
    383      * TODO: comment 
    384      * @param node  
    385      * @param fragments  
    386      * 
    387      */ 
    388     //----------------------------------------------------------------------------------------------- 
    389     public void addTextFieldInput(TextInputInteractionTask node, String[] fragments) 
    390     { 
    391       mTextFieldInputs.add(new Object[] { node, fragments }); 
    392     } 
    393  
    394     //----------------------------------------------------------------------------------------------- 
    395     /** 
    396      * TODO: comment 
    397      * @param node  
    398      * @param fragments  
    399      * 
    400      */ 
    401     //----------------------------------------------------------------------------------------------- 
    402     public void addTextAreaInput(TextInputInteractionTask node, String[] fragments) 
    403     { 
    404       mTextAreaInputs.add(new Object[] { node, fragments }); 
    405     } 
    406  
    407     //----------------------------------------------------------------------------------------------- 
    408     /** 
    409      * TODO: comment 
    410      * 
     237        } 
     238    } 
     239 
     240    /** 
     241     * TODO: comment 
     242     *  
     243     * @param taskTree 
     244     * @param statistics 
     245     */ 
     246    private void calculateStatistics(ITextInputEventTask node, TextInputStatistics statistics) { 
     247        String[] fragments = determineTextFragments(node.getEnteredText()); 
     248 
     249        if (node.getEventTarget() instanceof ITextField) { 
     250            statistics.addTextFieldInput(node, fragments); 
     251        } 
     252        else if (node.getEventTarget() instanceof ITextArea) { 
     253            statistics.addTextAreaInput(node, fragments); 
     254        } 
     255    } 
     256 
     257    /** 
     258     * TODO: comment 
     259     *  
     260     * @param enteredText 
    411261     * @return 
    412262     */ 
    413     //----------------------------------------------------------------------------------------------- 
    414     public int getNoOfAllInteractions() 
    415     { 
    416       return mTextFieldInputs.size() + mTextAreaInputs.size() + mOtherInteractionsCount; 
    417     } 
    418  
    419     //----------------------------------------------------------------------------------------------- 
    420     /** 
    421      * TODO: comment 
    422      * 
     263    private String[] determineTextFragments(String enteredText) { 
     264        List<String> fragments = new ArrayList<String>(); 
     265 
     266        StringBuffer fragment = new StringBuffer(); 
     267        char lastChar = 0; 
     268 
     269        for (int i = 0; i < enteredText.length(); i++) { 
     270            char currentChar = enteredText.charAt(i); 
     271 
     272            if (!isEqualCharacterType(lastChar, currentChar)) { 
     273                // the previous fragment ended. so finalize it and start a new one 
     274                if ((fragment != null) && (fragment.length() > 0)) { 
     275                    fragments.add(fragment.toString()); 
     276                    fragment = new StringBuffer(); 
     277                } 
     278            } 
     279 
     280            fragment.append(currentChar); 
     281            lastChar = currentChar; 
     282        } 
     283 
     284        if ((fragment != null) && (fragment.length() > 0)) { 
     285            fragments.add(fragment.toString()); 
     286        } 
     287 
     288        return fragments.toArray(new String[fragments.size()]); 
     289    } 
     290 
     291    /** 
     292     * TODO: comment 
     293     *  
     294     * @param lastChar 
     295     * @param currentChar 
    423296     * @return 
    424297     */ 
    425     //----------------------------------------------------------------------------------------------- 
    426     public int getNoOfTextFieldInputs() 
    427     { 
    428       return mTextFieldInputs.size(); 
    429     } 
    430  
    431     //----------------------------------------------------------------------------------------------- 
    432     /** 
    433      * TODO: comment 
    434      * 
    435      * @param i 
    436      * @return 
    437      */ 
    438     //----------------------------------------------------------------------------------------------- 
    439     public String[] getTextFieldInputFragments(int index) 
    440     { 
    441       return (String[]) mTextFieldInputs.get(index)[1]; 
    442     } 
    443  
    444     //----------------------------------------------------------------------------------------------- 
    445     /** 
    446      * TODO: comment 
    447      * 
    448      * @return 
    449      */ 
    450     //----------------------------------------------------------------------------------------------- 
    451     public int getNoOfTextAreaInputs() 
    452     { 
    453       return mTextAreaInputs.size(); 
    454     } 
    455  
    456     //----------------------------------------------------------------------------------------------- 
    457     /** 
    458      * TODO: comment 
    459      * 
    460      * @param i 
    461      * @return 
    462      */ 
    463     //----------------------------------------------------------------------------------------------- 
    464     public String[] getTextAreaInputFragments(int index) 
    465     { 
    466       return (String[]) mTextAreaInputs.get(index)[1]; 
    467     } 
    468  
    469     //----------------------------------------------------------------------------------------------- 
    470     /** 
    471      * TODO: comment 
    472      * 
    473      */ 
    474     //----------------------------------------------------------------------------------------------- 
    475     public void incrementNoOfOtherInteractionTasks() 
    476     { 
    477       mOtherInteractionsCount++; 
    478     } 
    479  
    480      
    481   } 
     298    private boolean isEqualCharacterType(char char1, char char2) { 
     299        return 
     300            ((char1 == char2) || 
     301            (Character.isWhitespace(char1) && Character.isWhitespace(char2)) || 
     302            (Character.isDigit(char1) && Character.isDigit(char2)) || 
     303            (Character.isLetter(char1) && Character.isLetter(char2)) || 
     304            (Character.isJavaIdentifierPart(char1) && Character.isJavaIdentifierPart(char2))); 
     305    } 
     306 
     307    /** 
     308     * TODO comment 
     309     *  
     310     * @version $Revision: $ $Date: 16.07.2012$ 
     311     * @author 2012, last modified by $Author: pharms$ 
     312     */ 
     313    public static class TextInputStatistics { 
     314         
     315        /** */ 
     316        private List<Object[]> textFieldInputs = new ArrayList<Object[]>(); 
     317 
     318        /** */ 
     319        private List<Object[]> textAreaInputs = new ArrayList<Object[]>(); 
     320 
     321        /** */ 
     322        private int otherEventsCount; 
     323 
     324        /** 
     325         * TODO: comment 
     326         *  
     327         * @param node 
     328         * @param fragments 
     329         *  
     330         */ 
     331        public void addTextFieldInput(ITextInputEventTask node, String[] fragments) { 
     332            textFieldInputs.add(new Object[] { node, fragments }); 
     333        } 
     334 
     335        /** 
     336         * TODO: comment 
     337         *  
     338         * @param node 
     339         * @param fragments 
     340         *  
     341         */ 
     342        public void addTextAreaInput(ITextInputEventTask node, String[] fragments) { 
     343            textAreaInputs.add(new Object[] { node, fragments }); 
     344        } 
     345 
     346        /** 
     347         * TODO: comment 
     348         *  
     349         * @return 
     350         */ 
     351        public int getNoOfAllEvents() { 
     352            return textFieldInputs.size() + textAreaInputs.size() + otherEventsCount; 
     353        } 
     354 
     355        /** 
     356         * TODO: comment 
     357         *  
     358         * @return 
     359         */ 
     360        public int getNoOfTextFieldInputs() { 
     361            return textFieldInputs.size(); 
     362        } 
     363 
     364        /** 
     365         * TODO: comment 
     366         *  
     367         * @param i 
     368         * @return 
     369         */ 
     370        public String[] getTextFieldInputFragments(int index) { 
     371            return (String[]) textFieldInputs.get(index)[1]; 
     372        } 
     373 
     374        /** 
     375         * TODO: comment 
     376         *  
     377         * @return 
     378         */ 
     379        public int getNoOfTextAreaInputs() { 
     380            return textAreaInputs.size(); 
     381        } 
     382 
     383        /** 
     384         * TODO: comment 
     385         *  
     386         * @param i 
     387         * @return 
     388         */ 
     389        public String[] getTextAreaInputFragments(int index) { 
     390            return (String[]) textAreaInputs.get(index)[1]; 
     391        } 
     392 
     393        /** 
     394         * TODO: comment 
     395         *  
     396         */ 
     397        public void incrementNoOfOtherEventTasks() { 
     398            otherEventsCount++; 
     399        } 
     400 
     401    } 
    482402 
    483403} 
Note: See TracChangeset for help on using the changeset viewer.