Ticket #2426: spellcheck_r0.patch

File spellcheck_r0.patch, 38.2 KB (added by boyanl, 15 years ago)

  • modules/org.sophie2.main.func.text/src/test/java/org/sophie2/main/func/text/spellcheck/SpellCheckDemoTest.java 

    ### Eclipse Workspace Patch 1.0
#P sophie
     
     1package org.sophie2.main.func.text.spellcheck; 
     2 
     3import java.awt.BorderLayout; 
     4import java.awt.Dimension; 
     5import java.awt.FlowLayout; 
     6import java.awt.event.ActionEvent; 
     7import java.awt.event.ActionListener; 
     8import java.awt.event.MouseAdapter; 
     9import java.awt.event.MouseEvent; 
     10import java.lang.reflect.InvocationTargetException; 
     11import java.util.HashMap; 
     12import java.util.LinkedList; 
     13import java.util.List; 
     14import java.util.Map; 
     15import java.util.Set; 
     16import java.util.TreeSet; 
     17 
     18import javax.swing.DefaultListModel; 
     19import javax.swing.JButton; 
     20import javax.swing.JFrame; 
     21import javax.swing.JList; 
     22import javax.swing.JPanel; 
     23import javax.swing.JScrollPane; 
     24import javax.swing.SwingUtilities; 
     25import javax.swing.WindowConstants; 
     26import javax.swing.event.ListSelectionEvent; 
     27import javax.swing.event.ListSelectionListener; 
     28 
     29import org.sophie2.base.bound.BoundModule; 
     30import org.sophie2.base.commons.util.position.ImmArea; 
     31import org.sophie2.base.commons.util.position.ImmRect; 
     32import org.sophie2.base.config.BaseConfigModule; 
     33import org.sophie2.base.dialogs.BaseDialogsModule; 
     34import org.sophie2.base.halos.BaseHalosModule; 
     35import org.sophie2.base.model.text.BaseModelTextModule; 
     36import org.sophie2.base.model.text.HotAttr; 
     37import org.sophie2.base.model.text.elements.CommonAttr; 
     38import org.sophie2.base.model.text.elements.CommonChar; 
     39import org.sophie2.base.model.text.model.ImmHotText; 
     40import org.sophie2.base.model.text.model.ImmText; 
     41import org.sophie2.base.model.text.model.ImmTextInterval; 
     42import org.sophie2.base.model.text.model.ImmTextUtils; 
     43import org.sophie2.base.model.text.mvc.swing.SimpleSwingTextView; 
     44import org.sophie2.base.model.text.mvc.swing.SwingTextModel; 
     45import org.sophie2.base.model.text.style.HotStyleDef; 
     46import org.sophie2.base.persistence.BasePersistenceModule; 
     47import org.sophie2.base.skins.BaseSkinsModule; 
     48import org.sophie2.base.visual.BaseVisualModule; 
     49import org.sophie2.core.logging.LogLevel; 
     50import org.sophie2.core.logging.Profiler; 
     51import org.sophie2.core.logging.SophieLog; 
     52import org.sophie2.core.modularity.FakeModuleRegistry; 
     53import org.sophie2.core.mvc.CoreMvcModule; 
     54import org.sophie2.core.testing.IntegrationTestBase; 
     55import org.sophie2.main.app.halos.MainAppHalosModule; 
     56import org.sophie2.main.func.links.LinksModule; 
     57import org.sophie2.main.func.text.TextFuncModule; 
     58import org.sophie2.main.func.text.search.SearchTextUtility; 
     59 
     60/** 
     61 * Spell-check demo 
     62 *  
     63 * @author boyanl 
     64 */ 
     65public class SpellCheckDemoTest extends IntegrationTestBase { 
     66 
     67        @SuppressWarnings("unused") 
     68        private static final String SAMPLE_TEXT =  
     69                "Lorem ipsum dolor sit amet, consectetur adipiscing elit. " + 
     70                "Vivamus sed eros sed lorem feugiat sodales id eget nibh. Ut cursus velit " + 
     71                "accumsan tellus condimentum eu facilisis velit rhoncus. Ut eros orci, blandit et " + 
     72                "aliquam nec, pretium nec erat. Phasellus ut massa vel sapien viverra pellentesque ut " + 
     73                "sit amet turpis. Phasellus pharetra rutrum nisl, a blandit nisi tincidunt nec. " + 
     74                "Vivamus dui est, imperdiet et dapibus in, interdum et lacus. Phasellus euismod " + 
     75                "sagittis dictum. Nullam placerat, nisi eu scelerisque iaculis, tortor libero aliquam " + 
     76                "leo, a volutpat purus libero eget ipsum. Morbi sem justo, pharetra nec laoreet " + 
     77                "sed, convallis at diam. Curabitur massa mauris, imperdiet at malesuada sed, " + 
     78                "placerat quis elit. Donec suscipit tincidunt tortor eu tristique. Nullam eu lectus " + 
     79                "enim. Sed pellentesque aliquam feugiat. Sed tempor, urna vitae semper blandit, libero " + 
     80                "lorem porttitor leo, sed mattis nulla turpis et neque. Quisque sit amet aliquet nisi. "; 
     81 
     82//      private static String getFullText() { 
     83//              StringBuilder res = new StringBuilder(); 
     84//              for (int i = 0; i < 15; ++i) { 
     85//                      for (char c = 'a'; c <= 'z'; ++c) { 
     86//                              res.append(c); 
     87//                      } 
     88//                      // if you have trouble with next characters, set your encoding to 
     89//                      // utf8! 
     90//                      for (char c = 'a'; c <= 'z'; ++c) { 
     91//                              res.append(c); 
     92//                      } 
     93//              } 
     94//              return res.toString(); 
     95//      } 
     96 
     97        private JFrame frame = new JFrame("Spellcheck testing"); 
     98        private SimpleSwingTextView swingView = null;  
     99        private SwingTextModel flow = new SwingTextModel(); 
     100        private static final int suggestionThreshold = 10; 
     101         
     102        /* 
     103         * Helper method which replaces occurrences of a given word in a text and returns the resultant text 
     104         * Ignores all words whose "index" of finding is contained in a list of indices, and searches for the wordIndex non-ignored encounter of the word 
     105         * (searches for any if wordIndex is -1) 
     106         */ 
     107        private ImmText findAndReplaceWord (ImmText text, String word, String replaceWord, boolean replaceAll, int wordIndex, Set<Integer> ignoreIndices) { 
     108                List<Integer> searchResults = new LinkedList<Integer> (); 
     109                SearchTextUtility.search(text, word, -1, -1, searchResults, false); 
     110                 
     111                ImmText result = text; 
     112                int index = 0, non_ignored = 0; 
     113                if (!searchResults.isEmpty()) { 
     114                        for (Integer pos : searchResults) { 
     115                                 
     116                                int start = pos, 
     117                                        end = start + word.length(); 
     118                                ImmTextInterval replaceInterval = new ImmTextInterval (start, end); 
     119                                 
     120                                boolean foundWord =  
     121                                                (start == 0 || CommonChar.getWordSeparators().contains(text.unitAt(start - 1).getChar())) 
     122                                                && 
     123                                                (end == text.getEnd() || CommonChar.getWordSeparators().contains(text.unitAt(end).getChar())); 
     124                                boolean isIgnored = (ignoreIndices != null && ignoreIndices.contains(index)); 
     125                                 
     126                                if (foundWord) { 
     127                                        if (!isIgnored &&  
     128                                                (wordIndex == -1 || wordIndex == non_ignored)) { 
     129                                                HotStyleDef oldStyle = text.unitAt(start).getStyle(); 
     130                                                result =    
     131                                                        result.replace(replaceInterval, new ImmHotText (replaceWord, oldStyle)); 
     132                                                 
     133                                                if (!replaceAll) 
     134                                                        return result; 
     135                                        } 
     136                                         
     137                                        ++index; 
     138                                        if (!isIgnored) 
     139                                                ++non_ignored; 
     140                                } 
     141                        } 
     142                } 
     143                 
     144                return result; 
     145        } 
     146         
     147        /* 
     148         * Accepts a "relative" index and a set of indices which are already taken and returns an index which is absolute relatively to them 
     149         */ 
     150        private int getAbsoluteIndex (int relIndex, Set<Integer> taken) { 
     151                 
     152                return getAbsoluteIndex (relIndex, taken, taken.size() + 1); 
     153        } 
     154         
     155        private int getAbsoluteIndex (int relIndex, Set<Integer> taken, int elemsCount) { 
     156                 
     157                if (taken == null) { 
     158                        return relIndex; 
     159                } 
     160                         
     161                int takenSoFar = 0; 
     162                for (int i = 0; i < elemsCount; ++i) { 
     163                        if (!taken.contains(i)) { 
     164                                 if (i - takenSoFar == relIndex) { 
     165                                         return i; 
     166                                 } 
     167                        } 
     168                        else { 
     169                                ++takenSoFar;                            
     170                        } 
     171                                 
     172                } 
     173                 
     174                return -1; 
     175        } 
     176         
     177         
     178        /* 
     179         * Gets a relative index of the string in a list model. I.e. if there are 5 such words, which one it is 
     180         */ 
     181        private int getRelativeIndexInListModel (String what, DefaultListModel model, int upto) { 
     182                int relativeIndex = 0; 
     183                for (int i = 0; i < upto; ++i) { 
     184                        if (model.get(i).equals(what)) { 
     185                                ++relativeIndex; 
     186                        } 
     187                } 
     188                return relativeIndex; 
     189        } 
     190         
     191         
     192        /** 
     193         * This is for experimental/demo purposes 
     194         */ 
     195        public void demo() { 
     196 
     197                Map<HotAttr<?>, Object> styleValues = new HashMap<HotAttr<?>, Object>(); 
     198                styleValues.put(CommonAttr.BOLD, true); 
     199                HotStyleDef style = HotStyleDef.getEmpty().derive(styleValues); 
     200                 
     201                // Test apply style 
     202                ImmText text = new ImmHotText("", style); 
     203 
     204                // Uncomment the following lines of code to test the text styling. 
     205                //              text = applyStyleToText(text, CommonAttr.BOLD, true, 3, 8); 
     206                //              text = applyStyleToText(text, CommonAttr.UNDERLINED, true, 16, 80); 
     207                //              text = applyStyleToText(text, CommonAttr.ITALIC, true, 39, 50); 
     208 
     209                // Test append of styled text 
     210//              Map<HotAttr<?>, Object> styleValues = new HashMap<HotAttr<?>, Object>(); 
     211//              styleValues.put(CommonAttr.BOLD, true); 
     212//              HotStyleDef style = HotStyleDef.getEmpty().derive(styleValues); 
     213//              ImmHotText styledText = ImmHotText.createStyled( 
     214//                              "\nApp", style); 
     215//              HotPos textEnd = text.getEnd(); 
     216//              HotPos textBegin = text.getBegin(); 
     217//              //              System.out.println("the index before: "+text.getIndex(textBegin)); 
     218//              HotInterval interval = new HotInterval(textBegin, textBegin); 
     219//              text = text.replace(interval, styledText); 
     220//              System.out.println("the bold style: "+text.getStyleValue 
     221//                              (CommonAttr.BOLD, new HotInterval(text.getBegin(), text.advance(text.getBegin(),  
     222//                                              styledText.getLength())))); 
     223//              System.out.println("the bold end style: "+text.getStyleValue 
     224//                              (CommonAttr.BOLD, text.advance(text.getBegin(),  
     225//                                              styledText.getLength()))); 
     226//              System.out.println("the bold style1: "+text.getStyleValue 
     227//                              (CommonAttr.BOLD, text.advance(text.getBegin(), styledText.getLength()+1))); 
     228//              ImmHotText subText = text.subText(new HotInterval(text.getBegin(), text.advance(text.getBegin(), 10))); 
     229//              text = text.replace(new HotInterval(text.getBegin(), text.advance(text.getBegin(), 3)), subText); 
     230                //              System.out.println("the index after: "+text.getIndex(textBegin)); 
     231                // Test insertion of styled text 
     232                //              styledText = ImmHotText.createStyled( 
     233                //                              "Inasdasdasdsad", style); 
     234                //              HotPos insertPos = text.advance(text.getBegin(), 8); 
     235                //              HotPos posD = text.advance(insertPos, 3); 
     236                //              HotInterval deleteInterval = new HotInterval(insertPos,text.advance(insertPos, 10)); 
     237                //              System.out.println("the pos before delete: "+text.getIndex(posD)); 
     238                //              text = text.replace(deleteInterval, ImmHotText.empty()); 
     239                //              System.out.println("the pos after delete: "+text.getIndex(posD)); 
     240                ////            text = text.replace(new HotInterval(insertPos, insertPos), styledText); 
     241                //              HotPos pos3 = text.advance(text.getBegin(), 3); 
     242                //              text = text.replace(new HotInterval(insertPos,insertPos), ImmHotText.createPlain("#######")); 
     243                //              text = text.replace(new HotInterval(pos3,pos3), ImmHotText.createPlain("WWWWWWW")); 
     244                //              // Set the area for flowing 
     245                //              System.out.println(text.getStyleValue(CommonAttr.BOLD, text.advance(insertPos, 1))); 
     246                 
     247//              Map<HotAttr<?>, Object> styleValues = new HashMap<HotAttr<?>, Object>(); 
     248//              styleValues.put(CommonAttr.ITALIC, true); 
     249//              HotStyleDef style = HotStyleDef.getEmpty().derive(styleValues); 
     250 
     251//              int insertBegin = NewImmHotTextUtils.advance(text, text.getBegin(), 15); 
     252//              int insertEnd = NewImmHotTextUtils.advance(text, text.getBegin(), 18); 
     253//              HotIndexInterval insertInterval = new HotIndexInterval(insertBegin, insertEnd); 
     254//              text = text.applyStyle(style, insertInterval); 
     255//              ImmText insertedText = NewImmHotTextUtils.subText(insertInterval, text); 
     256// 
     257//              ImmText newText = new NewImmHotText("Some plain text typed here.", null); 
     258//              Map<HotAttr<?>, Object> newTextStyleValues = new HashMap<HotAttr<?>, Object>(); 
     259//              newTextStyleValues.put(CommonAttr.UNDERLINED, true); 
     260//              HotStyleDef newTextStyleDef = HotStyleDef.getEmpty().derive(styleValues); 
     261//              newText =  newText.applyStyle(newTextStyleDef, new HotIndexInterval(newText.getBegin(),  
     262//                              NewImmHotTextUtils.advance(newText, newText.getBegin(), 15))); 
     263// 
     264// 
     265//              int replaceBegin = NewImmHotTextUtils.advance(newText, newText.getBegin(), 7); 
     266//              int replaceEnd = NewImmHotTextUtils.advance(newText, newText.getBegin(), 12); 
     267//              newText = newText.replace(new HotIndexInterval(replaceBegin,  
     268//                              replaceEnd), insertedText); 
     269                text = text.replace(new ImmTextInterval(text.getEnd(), text.getEnd()), 
     270                                new ImmHotText("some plain text here", null)); 
     271                 
     272                 
     273                /*text = text.applyStyle(style, 
     274                                                                new ImmTextInterval (text.getBegin(), text.getEnd()) );*/ 
     275                text = text.applyStyle(style, new ImmTextInterval (3, 8)); 
     276                 
     277                ImmArea area = new ImmArea(new ImmRect(0f, 0f, 480f, 410f)); 
     278        /*       
     279                ImmArea subArea1 = new ImmArea(new ImmRect(20f, 20f, 80f, 80f)); 
     280                ImmArea subArea2 = new ImmArea(new ImmRect(220f, 80f, 80f, 80f)) 
     281                .transform(ImmMatrix.IDENTITY.rotate(Math.PI / 6, 260, 120)); 
     282                area = area.subtract(subArea1).subtract(subArea2); 
     283        */ 
     284 
     285                this.flow.addArea(area); 
     286                this.flow.setText(text); 
     287                this.flow.setCaret(text.getEnd()); 
     288                this.flow.setMark(text.getEnd()); 
     289                this.swingView.textModel().set(this.flow); 
     290                int p1 = ImmTextUtils.advance(text, text.getEnd(), -3); 
     291                System.out.println("the posPlace: "+this.flow.getTextLayout().getCharPlace(p1).getPoint()); 
     292                this.frame.getContentPane().setLayout(new BorderLayout()); 
     293                this.frame.getContentPane().add (this.swingView.swingComponent().get(), BorderLayout.WEST); 
     294                 
     295                 
     296                //contains the list of misspelled words 
     297                final JList listMisspelled = new JList (new DefaultListModel()); 
     298                JScrollPane misspelledScrollPane = new JScrollPane (listMisspelled); 
     299                misspelledScrollPane.setPreferredSize(new Dimension(100, 200)); 
     300                 
     301                JPanel listsPanel = new JPanel (); 
     302                listsPanel.setLayout(new FlowLayout(FlowLayout.LEADING)); 
     303                 
     304                this.frame.getContentPane().add(listsPanel, BorderLayout.CENTER); 
     305                listsPanel.add(misspelledScrollPane); 
     306                 
     307                /* 
     308                 * This is for managing the ignored words. Currently we do this - for each word we keep a set of indices which are "ignored" -  
     309                 * i.e. whether we ignored the 2nd/3rd etc such word. We update the corresponding list when ignoring a word or when replacing an existing once 
     310                 * (because we need to shift the indices then). 
     311                 * Unfortunately it leads to some kind of messy logic at some points .. 
     312                 */ 
     313                 
     314                final Map<String, Set<Integer>> ignoreIndices = new HashMap<String, Set<Integer>> (); 
     315                 
     316                JPanel buttonsPanel = new JPanel (); 
     317                buttonsPanel.setLayout(new FlowLayout()); 
     318                buttonsPanel.setPreferredSize(new Dimension(200, 200)); 
     319                this.frame.getContentPane().add(buttonsPanel, BorderLayout.EAST); 
     320                 
     321                 
     322                JButton spellCheckButton = new JButton ("Spellcheck"); 
     323                spellCheckButton.addActionListener(new ActionListener () { 
     324 
     325                        @SuppressWarnings("synthetic-access") 
     326                        public void actionPerformed(ActionEvent e) { 
     327                                ImmText modelText = SpellCheckDemoTest.this.flow.getRawText(); 
     328                                String textStr = modelText.toString(); 
     329                                 
     330                                List<String> misspelled = new LinkedList<String> (); 
     331                                SpellCheckUtility.getMisspelledWords (misspelled, textStr); 
     332                                 
     333                                DefaultListModel model = (DefaultListModel) listMisspelled.getModel(); 
     334                                 
     335                                model.clear (); 
     336                                for (String str : misspelled) { 
     337                                        model.addElement(str); 
     338                                } 
     339                                listMisspelled.setModel(model); 
     340                                 
     341                                ignoreIndices.clear(); 
     342                        } 
     343                         
     344                }); 
     345                 
     346                final JList listSuggestions = new JList (new DefaultListModel()); 
     347                JScrollPane suggestionsScrollPane = new JScrollPane (listSuggestions); 
     348                suggestionsScrollPane.setPreferredSize(new Dimension(100, 200)); 
     349                listsPanel.add(suggestionsScrollPane); 
     350                 
     351                listMisspelled.addListSelectionListener(new ListSelectionListener () { 
     352                        public void valueChanged(ListSelectionEvent e) { 
     353                                String word = (String) listMisspelled.getSelectedValue(); 
     354                                if (word != null) {                                                                      
     355                                        List<String> suggestions = SpellCheckUtility.getSuggestions(word, suggestionThreshold); 
     356                                         
     357                                        DefaultListModel model = (DefaultListModel) listSuggestions.getModel(); 
     358                                        model.clear (); 
     359                                        for (String str : suggestions) { 
     360                                                model.addElement(str); 
     361                                        } 
     362                                         
     363                                        listSuggestions.setModel(model);                 
     364                                } 
     365                                else { 
     366                                        listSuggestions.setModel(new DefaultListModel()); 
     367                                } 
     368                        } 
     369                         
     370                }); 
     371                 
     372                JButton replaceButton = new JButton ("Replace"); 
     373                buttonsPanel.add (replaceButton); 
     374                 
     375                JButton replaceAllButton = new JButton ("Replace All"); 
     376                buttonsPanel.add (replaceAllButton); 
     377                 
     378                listSuggestions.addMouseListener(new MouseAdapter() { 
     379 
     380                        @SuppressWarnings("synthetic-access") 
     381                        @Override 
     382                        public void mouseClicked(MouseEvent e) { 
     383                                if (e.getClickCount() >= 2) { 
     384                                        //TODO: basically duplicates the logic of replace button .. (extract possibly) 
     385                                        String wordSel = (String) listMisspelled.getSelectedValue(), 
     386                                                   toReplace = (String) listSuggestions.getSelectedValue(); 
     387                                        int indexSel = listMisspelled.getSelectedIndex(); 
     388                                         
     389                                         
     390                                        if (wordSel != null && toReplace != null) { 
     391                                                SwingTextModel model = SpellCheckDemoTest.this.flow; 
     392                                                ImmText rawText = model.getRawText(); 
     393         
     394                                                DefaultListModel misspelledModel = (DefaultListModel) listMisspelled.getModel(); 
     395                                                 
     396                                                int relativeIndex = getRelativeIndexInListModel(wordSel, misspelledModel, indexSel); 
     397                                                 
     398                                                Set<Integer> wordIndices = ignoreIndices.get(wordSel); 
     399                                                model.setText (findAndReplaceWord(rawText, wordSel, toReplace, false, relativeIndex, wordIndices)); 
     400                                                 
     401                                                if (wordIndices != null) {                               
     402                                                        int absInd = getAbsoluteIndex (relativeIndex, wordIndices, relativeIndex + wordIndices.size() + 1); 
     403                                                        List<Integer> removeList = new LinkedList<Integer> (); 
     404                                                                                 
     405                                                        for (Integer ind : wordIndices) { 
     406                                                                if (ind > absInd) { 
     407                                                                        removeList.add(ind); 
     408                                                                } 
     409                                                        } 
     410                                                         
     411                                                        //update ignore list 
     412                                                        for (Integer ind : removeList) { 
     413                                                                wordIndices.remove(ind); 
     414                                                                wordIndices.add(ind - 1); 
     415                                                        } 
     416                                                } 
     417                                                misspelledModel.remove(indexSel); 
     418                                        } 
     419                                } 
     420                        } 
     421                }); 
     422                 
     423                replaceButton.addActionListener(new ActionListener () { 
     424                         
     425                        @SuppressWarnings("synthetic-access") 
     426                        public void actionPerformed(ActionEvent e) { 
     427                                String wordSel = (String) listMisspelled.getSelectedValue(), 
     428                                   toReplace = (String) listSuggestions.getSelectedValue(); 
     429                                int indexSel = listMisspelled.getSelectedIndex(); 
     430                                 
     431                         
     432                                if (wordSel != null && toReplace != null) { 
     433                                        SwingTextModel model = SpellCheckDemoTest.this.flow; 
     434                                        ImmText rawText = model.getRawText(); 
     435                                         
     436                                         
     437                                         
     438                                        DefaultListModel misspelledModel = (DefaultListModel) listMisspelled.getModel(); 
     439                                         
     440                                        int relativeIndex = getRelativeIndexInListModel(wordSel, misspelledModel, indexSel); 
     441                                         
     442                                        Set<Integer> wordIndices = ignoreIndices.get(wordSel); 
     443                                        model.setText (findAndReplaceWord(rawText, wordSel, toReplace, false, relativeIndex, wordIndices)); 
     444                                         
     445                                        if (wordIndices != null) { 
     446                                                int absInd = getAbsoluteIndex (relativeIndex, wordIndices, relativeIndex + wordIndices.size() + 1); 
     447                                                List<Integer> removeList = new LinkedList<Integer> (); 
     448                                                                         
     449                                                for (Integer ind : wordIndices) { 
     450                                                        if (ind > absInd) { 
     451                                                                removeList.add(ind); 
     452                                                        } 
     453                                                } 
     454                                                 
     455                                                //update ignore list 
     456                                                for (Integer ind : removeList) { 
     457                                                        wordIndices.remove(ind); 
     458                                                        wordIndices.add(ind - 1); 
     459                                                } 
     460                                        } 
     461                                        misspelledModel.remove(indexSel); 
     462                                } 
     463                        } 
     464                }); 
     465                 
     466                replaceAllButton.addActionListener (new ActionListener () { 
     467 
     468                        @SuppressWarnings("synthetic-access") 
     469                        public void actionPerformed(ActionEvent e) { 
     470                                String wordSel = (String) listMisspelled.getSelectedValue(), 
     471                                   toReplace = (String) listSuggestions.getSelectedValue(); 
     472                         
     473                                if (wordSel != null && toReplace != null) { 
     474                                        SwingTextModel model = SpellCheckDemoTest.this.flow; 
     475                                        ImmText rawText = model.getRawText(); 
     476                                         
     477                                        model.setText (findAndReplaceWord(rawText, wordSel, toReplace, true, -1, ignoreIndices.get(wordSel)));                                                                                           
     478                                        //remove all words equal to wordSel in the misspelled list 
     479                                        while (((DefaultListModel ) listMisspelled.getModel ()).removeElement(wordSel)) { 
     480                                                //nothing 
     481                                        } 
     482                                } 
     483                        } 
     484                }); 
     485                 
     486                JButton ignoreButton = new JButton ("Ignore"), 
     487                                ignoreAllButton = new JButton ("Ignore All"); 
     488                 
     489                buttonsPanel.add (ignoreButton); 
     490                buttonsPanel.add(ignoreAllButton); 
     491                         
     492                ignoreButton.addActionListener (new ActionListener () { 
     493 
     494                        @SuppressWarnings("synthetic-access") 
     495                        public void actionPerformed(ActionEvent e) { 
     496                                String wordSel = (String) listMisspelled.getSelectedValue (); 
     497                                int index = listMisspelled.getSelectedIndex(); 
     498                                 
     499                                DefaultListModel misspelledModel = (DefaultListModel) listMisspelled.getModel(); 
     500                                if (wordSel != null) { 
     501                                         
     502                                        int relativeIndex = 0; 
     503                                        for (int i = 0; i < index; ++i) { 
     504                                                if (misspelledModel.get(i).equals(wordSel)) { 
     505                                                        ++relativeIndex; 
     506                                                } 
     507                                        } 
     508                                         
     509                                        Set<Integer> wordIndices = ignoreIndices.get(wordSel); 
     510                                        if (wordIndices == null) { 
     511                                                wordIndices = new TreeSet<Integer> (); 
     512                                                ignoreIndices.put(wordSel, wordIndices); 
     513                                        } 
     514                                         
     515                                        /* 
     516                                         * Update ignore list 
     517                                         */ 
     518                                        wordIndices.add (getAbsoluteIndex (relativeIndex, wordIndices, relativeIndex + wordIndices.size() + 1)); 
     519                                        misspelledModel.remove (index); 
     520                                } 
     521                        } 
     522                }); 
     523                 
     524                ignoreAllButton.addActionListener(new ActionListener () { 
     525 
     526                        @SuppressWarnings("synthetic-access") 
     527                        public void actionPerformed(ActionEvent e) { 
     528                                String wordSel = (String) listMisspelled.getSelectedValue (); 
     529                                 
     530                                DefaultListModel misspelledModel = (DefaultListModel) listMisspelled.getModel(); 
     531                                if (wordSel != null) { 
     532                                                                 
     533                                        Set<Integer> wordIndices = ignoreIndices.get(wordSel); 
     534                                        if (wordIndices == null) { 
     535                                                wordIndices = new TreeSet<Integer> (); 
     536                                                ignoreIndices.put(wordSel, wordIndices); 
     537                                        } 
     538                                         
     539                                        for (int i = 0; i < misspelledModel.getSize(); ++i) { 
     540                                                if (misspelledModel.get(i).equals(wordSel)) { 
     541                                                        wordIndices.add(getAbsoluteIndex (0, wordIndices)); 
     542                                                        misspelledModel.remove(i--); 
     543                                                } 
     544                                        } 
     545                                         
     546                                        //no need to have an updated ignore list since we can't select that word again 
     547                                } 
     548                        } 
     549                         
     550                }); 
     551                 
     552                 
     553                JButton addToDictButton = new JButton ("Add to dictionary"); 
     554                buttonsPanel.add(addToDictButton); 
     555                 
     556                addToDictButton.addActionListener(new ActionListener () { 
     557 
     558                        public void actionPerformed(ActionEvent e) { 
     559                                String wordSel = (String) listMisspelled.getSelectedValue(); 
     560                                if (wordSel != null) { 
     561                                 
     562                                        DefaultListModel misspelledModel = (DefaultListModel) listMisspelled.getModel(); 
     563                                         
     564                                        //remove all such words in the list 
     565                                        while (misspelledModel.removeElement(wordSel)) { 
     566                                                //nothing 
     567                                        } 
     568                                         
     569                                        SpellCheckUtility.addToDictionary(wordSel); 
     570                                } 
     571                        } 
     572                         
     573                }); 
     574                 
     575                buttonsPanel.add(spellCheckButton); 
     576                 
     577                this.frame.pack(); 
     578                this.frame.setVisible(true); 
     579                this.frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); 
     580 
     581                this.swingView.swingComponent().get().requestFocusInWindow(); 
     582        } 
     583 
     584//      private static ImmHotText applyStyleToText(ImmHotText text, 
     585//                      HotAttr<?> attr, Object value, int begin, int end) { 
     586//              Map<HotAttr<?>, Object> styleValues = new HashMap<HotAttr<?>, Object>(); 
     587//              styleValues.put(attr, value); 
     588//              HotStyleDef style = HotStyleDef.getEmpty().derive(styleValues); 
     589//              return text.applyStyle(new HotInterval(text.advance( 
     590//                              text.getBegin(), begin), text.advance(text.getBegin(),  
     591//                                              end)), style); 
     592//      } 
     593 
     594        private void go(boolean interactive) throws Exception { 
     595                // We need assertions!! 
     596                checkAssertions(); 
     597                 
     598                setUp(); 
     599                 
     600                long startTime = System.currentTimeMillis(); 
     601                SwingUtilities.invokeAndWait(new Runnable() { 
     602                         
     603                        @SuppressWarnings("synthetic-access") 
     604                        public void run() { 
     605                                SpellCheckDemoTest.this.swingView = new SimpleSwingTextView(); 
     606                                demo(); 
     607                        } 
     608                }); 
     609 
     610                if (!interactive) { 
     611                        Runnable type = new Runnable() { 
     612 
     613                                int count = 0; 
     614 
     615                                @SuppressWarnings("synthetic-access") 
     616                                public void run() { 
     617                                        ImmText oldText = SpellCheckDemoTest.this.flow.getRawText(); 
     618                                        int pos = oldText.getBegin(); 
     619                                        // ImmHotText newText = oldText.addChar(pos, c); 
     620                                        String text = this.count % 60 == 0 ? "bla\n" : "xyzz "; 
     621                                        //String text = count % 2 == 0 ? SAMPLE_TEXT : FULL_TEXT; 
     622                                        ImmText newText = oldText.replace(new ImmTextInterval(pos, 
     623                                                        pos), new ImmHotText(text, null)); 
     624                                        SpellCheckDemoTest.this.flow.setText(newText); 
     625                                        this.count++; 
     626                                } 
     627                        }; 
     628                        for (int i = 0; i < 150; ++i) { 
     629                                SwingUtilities.invokeAndWait(type); 
     630                        } 
     631 
     632                        SwingUtilities.invokeAndWait(new Runnable() { 
     633                                @SuppressWarnings("synthetic-access") 
     634                                public void run() { 
     635                                        SpellCheckDemoTest.this.frame.dispose(); 
     636                                } 
     637                        }); 
     638                } 
     639                long endTime = System.currentTimeMillis(); 
     640                SophieLog.info("Total time: " + (endTime - startTime)); 
     641 
     642        } 
     643 
     644        /** 
     645         * Main method 
     646         *  
     647         * @param args 
     648         *            ignored 
     649         * @throws InvocationTargetException 
     650         * @throws InterruptedException 
     651         */ 
     652        @SuppressWarnings("unchecked") 
     653        public static void main(String[] args) throws Exception { 
     654                SophieLog.info("Starting"); 
     655                SophieLog.setMinLevel("", LogLevel.INFO); 
     656                SophieLog.setMinLevel("org.sophie2.base.model.text", LogLevel.DEBUG); 
     657                Profiler.start(); 
     658 
     659                FakeModuleRegistry.start( 
     660                                BoundModule.class, 
     661                                BaseHalosModule.class, 
     662                                BaseDialogsModule.class, 
     663                                MainAppHalosModule.class, 
     664                                LinksModule.class, 
     665                                BaseConfigModule.class,  
     666                                BasePersistenceModule.class,  
     667                                BaseVisualModule.class, BaseSkinsModule.class, 
     668                                CoreMvcModule.class, BaseModelTextModule.class, 
     669                                TextFuncModule.class); 
     670 
     671                new SpellCheckDemoTest().go(true); 
     672                Profiler.dump(); 
     673        } 
     674 
     675} 

  • modules/org.sophie2.main.func.text/src/main/java/org/sophie2/main/func/text/spellcheck/SpellCheckUtility.java

     
     1package org.sophie2.main.func.text.spellcheck; 
     2 
     3import java.io.File; 
     4import java.io.IOException; 
     5import java.util.LinkedList; 
     6import java.util.List; 
     7 
     8import org.sophie2.base.model.text.model.ImmText; 
     9import org.sophie2.base.model.text.mvc.TextModel; 
     10import org.sophie2.base.model.text.mvc.TextView; 
     11import org.sophie2.core.modularity.FileEntryManager; 
     12import org.sophie2.main.func.text.view.TextFrameView; 
     13 
     14import com.swabunga.spell.engine.SpellDictionaryHashMap; 
     15import com.swabunga.spell.engine.Word; 
     16import com.swabunga.spell.event.SpellCheckEvent; 
     17import com.swabunga.spell.event.SpellCheckListener; 
     18import com.swabunga.spell.event.SpellChecker; 
     19import com.swabunga.spell.event.StringWordTokenizer; 
     20 
     21/** 
     22 * @author boyanl 
     23 * 
     24 */ 
     25public class SpellCheckUtility { 
     26        private static SpellDictionaryHashMap dict; 
     27         
     28        private static SpellDictionaryHashMap getDefaultDictionary () { 
     29                SpellDictionaryHashMap result = null; 
     30                try {    
     31                        File eng_dic = FileEntryManager.get().getWritableFileEntry("dictionaries/eng_com.dic"); 
     32                        File center = FileEntryManager.get().getWritableFileEntry("dictionaries/center.dic"); 
     33                        File color = FileEntryManager.get().getWritableFileEntry("dictionaries/color.dic"); 
     34                        File ise = FileEntryManager.get().getWritableFileEntry("dictionaries/ise.dic"); 
     35                        File labeled = FileEntryManager.get().getWritableFileEntry("dictionaries/labeled.dic"); 
     36                        File yse = FileEntryManager.get().getWritableFileEntry("dictionaries/yse.dic"); 
     37                         
     38                        result = new SpellDictionaryHashMap (eng_dic); 
     39                        result.addDictionary(center); 
     40                        result.addDictionary(color); 
     41                        result.addDictionary(ise); 
     42                        result.addDictionary(labeled); 
     43                        result.addDictionary(yse); 
     44                } 
     45                catch(IOException e) { 
     46                        // nothing 
     47                } 
     48                 
     49                return result; 
     50        } 
     51         
     52        private static SpellDictionaryHashMap getDictionary () { 
     53                if (dict == null) { 
     54                        dict = getDefaultDictionary (); 
     55                } 
     56                return dict; 
     57        } 
     58         
     59        private static class AccumulatingSpellCheckListener implements SpellCheckListener { 
     60                private List<String> misspelledWords; 
     61                 
     62                public AccumulatingSpellCheckListener (List<String> toFill) { 
     63                        this.misspelledWords = toFill; 
     64                } 
     65                public void spellingError(SpellCheckEvent event) { 
     66                        this.misspelledWords.add(event.getInvalidWord()); 
     67                } 
     68        } 
     69         
     70        /** 
     71         * Adds all the misspelled words in a given area 
     72         * @param result 
     73         *                      The list where to add the results 
     74        * @param indexArea 
     75         *         The index of the area in the given text that should be searched in. 
     76         * @param view 
     77         *        The text view.    
     78         * @param frameView 
     79         *        The tail or head text frame view of the text. 
     80         */ 
     81        public static void getMisspelledWords (List<String> result, int indexArea, TextView view, 
     82                                                        TextFrameView frameView) { 
     83                 
     84                TextModel model = view.getTextModel(); 
     85                ImmText text = model.getTextLayout().getAreaContent (indexArea); 
     86                String textStr = text.toString(); 
     87                 
     88                getMisspelledWords (result, textStr); 
     89        } 
     90         
     91        /** 
     92         * Adds all the misspelled words in a given text. 
     93         * @param result 
     94     *                  The list where to add the results. 
     95         * @param text 
     96         *                      The text to search in. 
     97         */ 
     98        public static void getMisspelledWords (List<String> result, String text) { 
     99                if (dict == null) { 
     100                        dict = getDefaultDictionary (); 
     101                } 
     102                SpellChecker checker = new SpellChecker (dict); 
     103                 
     104                AccumulatingSpellCheckListener listener = new AccumulatingSpellCheckListener(result); 
     105                checker.addSpellCheckListener(listener); 
     106                checker.checkSpelling(new StringWordTokenizer (text)); 
     107        } 
     108         
     109        /** 
     110         * Returns a list of suggestions for the passed word. 
     111         * @param word 
     112         *                The word to get suggestions for. 
     113         * @param threshold 
     114         *                The maximum edit distance over which suggestions are be thrown away. 
     115         * @return 
     116         *                List of words whose edit distance to the passed word is at less than or equal to the threshold. 
     117         */ 
     118        @SuppressWarnings("unchecked") 
     119        public static List<String> getSuggestions (String word, int threshold) { 
     120                List<Word> words = getDictionary ().getSuggestions(word, threshold); 
     121                List<String> res = new LinkedList<String> (); 
     122                for (Word suggestion  : words) 
     123                        res.add(suggestion.getWord()); 
     124                return res; 
     125        } 
     126         
     127        /** 
     128         * Adds a given word to the dictionary. 
     129         * @param word 
     130         *                The word to add. 
     131         */ 
     132        public static void addToDictionary (String word) { 
     133                getDictionary().addWord(word); 
     134        } 
     135 
     136} 

  • pom.xml

     
    287287                        <name>Nexus Public Mirror</name> 
    288288                        <url>http://sophie2.org:8081/nexus/content/groups/public</url> 
    289289                </repository> 
     290        <repository> 
     291            <id>squale</id> 
     292            <name>some</name> 
     293            <url>http://archiva.squale.org/repos/repository/releases/</url> 
     294        </repository>            
    290295        </repositories> 
    291296        <profiles> 
    292297                <profile> 

  • modules/org.sophie2.base.model.text/src/test/java/org/sophie2/base/model/text/HotTextDemoTest.java

     
    1212import org.sophie2.base.commons.util.position.ImmArea; 
    1313import org.sophie2.base.commons.util.position.ImmMatrix; 
    1414import org.sophie2.base.commons.util.position.ImmRect; 
     15import org.sophie2.base.config.BaseConfigModule; 
    1516import org.sophie2.base.model.text.elements.CommonAttr; 
    16 import org.sophie2.base.model.text.model.ImmTextInterval; 
    1717import org.sophie2.base.model.text.model.ImmHotText; 
    1818import org.sophie2.base.model.text.model.ImmText; 
     19import org.sophie2.base.model.text.model.ImmTextInterval; 
    1920import org.sophie2.base.model.text.model.ImmTextUtils; 
    2021import org.sophie2.base.model.text.mvc.swing.SimpleSwingTextView; 
    2122import org.sophie2.base.model.text.mvc.swing.SwingTextModel; 
    2223import org.sophie2.base.model.text.style.HotStyleDef; 
     24import org.sophie2.base.persistence.BasePersistenceModule; 
    2325import org.sophie2.base.skins.BaseSkinsModule; 
    2426import org.sophie2.base.visual.BaseVisualModule; 
    2527import org.sophie2.core.logging.LogLevel; 
    … …  
    2729import org.sophie2.core.logging.SophieLog; 
    2830import org.sophie2.core.modularity.FakeModuleRegistry; 
    2931import org.sophie2.core.mvc.CoreMvcModule; 
    30 import org.sophie2.core.testing.TestBase; 
     32import org.sophie2.core.testing.IntegrationTestBase; 
    3133 
    3234/** 
    3335 * Experimental things about the swing text support. 
    3436 *  
    3537 * @author milo 
    3638 */ 
    37 public class HotTextDemoTest extends TestBase { 
     39public class HotTextDemoTest extends IntegrationTestBase { 
    3840 
    3941        @SuppressWarnings("unused") 
    4042        private static final String SAMPLE_TEXT =  
    … …  
    6769//      } 
    6870 
    6971        private JFrame frame = new JFrame("ImmHotText testing"); 
    70         private SimpleSwingTextView swingView = new SimpleSwingTextView(); 
     72        private SimpleSwingTextView swingView = null;  
    7173        private SwingTextModel flow = new SwingTextModel(); 
    7274 
    7375        /** 
    … …  
    149151//                              replaceEnd), insertedText); 
    150152                text = text.replace(new ImmTextInterval(text.getEnd(), text.getEnd()), 
    151153                                new ImmHotText("some plain text here", null)); 
     154                 
     155                 
     156                /*text = text.applyStyle(style, 
     157                                                                new ImmTextInterval (text.getBegin(), text.getEnd()) );*/ 
    152158                System.out.println("the text: "+text); 
    153159                ImmArea area = new ImmArea(new ImmRect(0f, 0f, 480f, 410f)); 
    154                 ImmArea subArea1 = new ImmArea(new ImmRect(20f, 20f, 80f, 80f)); 
     160                 
     161                ImmArea subArea1 = new ImmArea(new ImmRect(20f, 20f, 80f, 80f)); 
    155162                ImmArea subArea2 = new ImmArea(new ImmRect(220f, 80f, 80f, 80f)) 
    156163                .transform(ImmMatrix.IDENTITY.rotate(Math.PI / 6, 260, 120)); 
    157164                area = area.subtract(subArea1).subtract(subArea2); 
     165         
    158166 
    159167                this.flow.addArea(area); 
    160168                this.flow.setText(text); 
    … …  
    163171                this.swingView.textModel().set(this.flow); 
    164172                int p1 = ImmTextUtils.advance(text, text.getEnd(), -3); 
    165173                System.out.println("the posPlace: "+this.flow.getTextLayout().getCharPlace(p1).getPoint()); 
    166                 this.frame.getContentPane().setLayout(new FlowLayout()); 
    167                 this.frame.getContentPane().add(this.swingView.swingComponent().get()); 
    168  
     174                this.frame.getContentPane().setLayout(new FlowLayout(FlowLayout.LEADING)); 
     175                this.frame.getContentPane().add (this.swingView.swingComponent().get()); 
    169176                this.frame.pack(); 
    170177                this.frame.setVisible(true); 
    171178                this.frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); 
    … …  
    183190//                                              end)), style); 
    184191//      } 
    185192 
    186         private void go(boolean interactive) throws InterruptedException, InvocationTargetException { 
     193        private void go(boolean interactive) throws Exception { 
    187194                // We need assertions!! 
    188195                checkAssertions(); 
    189196                 
     197                setUp(); 
     198                 
    190199                long startTime = System.currentTimeMillis(); 
    191200                SwingUtilities.invokeAndWait(new Runnable() { 
     201                         
     202                        @SuppressWarnings("synthetic-access") 
    192203                        public void run() { 
     204                                HotTextDemoTest.this.swingView = new SimpleSwingTextView(); 
    193205                                demo(); 
    194206                        } 
    195207                }); 
    … …  
    237249         * @throws InterruptedException 
    238250         */ 
    239251        @SuppressWarnings("unchecked") 
    240         public static void main(String[] args) throws InterruptedException, InvocationTargetException { 
     252        public static void main(String[] args) throws Exception { 
    241253                SophieLog.info("Starting"); 
    242254                SophieLog.setMinLevel("", LogLevel.INFO); 
    243255                SophieLog.setMinLevel("org.sophie2.base.model.text", LogLevel.DEBUG); 
    244256                Profiler.start(); 
    245257 
    246                 FakeModuleRegistry.start(BaseVisualModule.class, BaseSkinsModule.class, 
     258                FakeModuleRegistry.start(BaseConfigModule.class,  
     259                                BasePersistenceModule.class,  
     260                                BaseVisualModule.class, BaseSkinsModule.class, 
    247261                                CoreMvcModule.class, BaseModelTextModule.class); 
    248262 
    249263                new HotTextDemoTest().go(true); 

  • modules/org.sophie2.base.model.text/src/main/java/org/sophie2/base/model/text/mvc/swing/SimpleTextLogic.java

     
    2222 
    2323                public void defineFilter(EventFilterBuilder filter) { 
    2424                        filter.setSourceClass(SwingTextView.class); 
    25                         filter.setEventId(TextView.EventIds.CHANGE_TEXT_FORCED); 
     25                        filter.setEventId(TextView.EventIds.CHANGE_TEXT); 
    2626                } 
    2727 
    2828                public boolean handle(EventR3 event) { 

  • modules/org.sophie2.base.model.text/src/main/java/org/sophie2/base/model/text/mvc/swing/SimpleSwingTextView.java

     
    33import java.awt.Color; 
    44import java.awt.Graphics; 
    55import java.awt.Graphics2D; 
     6import java.awt.event.MouseAdapter; 
     7import java.awt.event.MouseEvent; 
    68import java.util.HashMap; 
    79import java.util.Map; 
    810 
    … …  
    5355                        } 
    5456 
    5557                        @Override 
    56                         protected void setup(JComponent res) { 
     58                        protected void setup(final JComponent res) { 
    5759//                              res.setBackground(Color.CYAN); 
    5860                                res.setFocusable(true); 
    5961                                res.requestFocusInWindow(); 
     62                                 
     63                                res.addMouseListener(new MouseAdapter() { 
    6064 
     65                                        @Override 
     66                                        public void mouseClicked(MouseEvent e) { 
     67                                                res.requestFocusInWindow(); 
     68                                        }                                
     69                                }); 
     70                                 
    6171                                ImmList<ImmArea> areas = textModel().get().getAreas(); 
    6272                                if (areas.size() != 0) { 
    6373                                        ImmRect bounds = areas.get(getIndex()).getBounds(); 

  • modules/org.sophie2.main.func.text/src/main/java/org/sophie2/main/func/text/search/SearchTextUtility.java

     
    6363         * @param res 
    6464         *            The list where to add the results. 
    6565         */ 
    66         static void search(ImmText longText, String string, List<Integer> res) { 
     66        public static void search(ImmText longText, String string, List<Integer> res) { 
    6767                search(longText, string, - 1, -1, res,true); 
    6868        } 
    6969         

  • modules/org.sophie2.main.func.text/pom.xml

     
    124124                        <artifactId>org.sophie2.main.dnd</artifactId> 
    125125                        <version>2.0.6</version> 
    126126                </dependency> 
     127        <dependency> 
     128            <groupId>jazzy</groupId> 
     129            <artifactId>jazzy-core</artifactId> 
     130            <version>0.5.2</version> 
     131        </dependency> 
    127132        </dependencies> 
    128133        <build> 
    129134                <plugins>