1 /*

     2  * This file is part of the DOM implementation for KDE.

     3  *

     4  * Copyright (C) 2006 Lars Knoll <lars@trolltech.com>

     5  * Copyright (C) 2007 Nokia Inc.

     6  *

     7  * This library is free software; you can redistribute it and/or

     8  * modify it under the terms of the GNU Library General Public

     9  * License as published by the Free Software Foundation; either

    10  * version 2 of the License, or (at your option) any later version.

    11  *

    12  * This library is distributed in the hope that it will be useful,

    13  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    15  * Library General Public License for more details.

    16  *

    17  * You should have received a copy of the GNU Library General Public License

    18  * along with this library; see the file COPYING.LIB.  If not, write to

    19  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    20  * Boston, MA 02111-1307, USA.

    21  *

    22  */

    23 

    24 #include "config.h"

    25 #include "TextBreakIterator.h"

    26 #include <e32cmn.h>

    27 #include <KJS/ustring.h>

    28 

    29 namespace WebCore {

    30 

    31     class TextBreakIterator

    32     {

    33     public:

    34         virtual int first() = 0;

    35         virtual int next() = 0;

    36         virtual int previous() = 0;

    37         inline int following(int pos) {

    38             currentPos = pos;

    39             return next();

    40         }

    41         inline int preceding(int pos) {

    42             currentPos = pos;

    43             return previous();

    44         }

    45         int currentPos;

    46         const UChar *string;

    47         int length;

    48     };

    49 

    50     class WordBreakIteratorSymbian : public TextBreakIterator

    51     {

    52     public:

    53         virtual int first();

    54         virtual int next();

    55         virtual int previous();

    56     };

    57 

    58     class CharBreakIteratorSymbian : public TextBreakIterator

    59     {

    60     public:

    61         virtual int first();

    62         virtual int next();

    63         virtual int previous();

    64     };

    65     

    66     class LineBreakIteratorSymbian : public TextBreakIterator

    67     {

    68     public:

    69         virtual int first();

    70         virtual int next();

    71         virtual int previous();

    72     };

    73 

    74     int WordBreakIteratorSymbian::first() {

    75         currentPos = 0;

    76         return currentPos;

    77     }

    78 

    79     int WordBreakIteratorSymbian::next() {

    80         if (currentPos == length) {

    81             currentPos = -1;

    82             return currentPos;

    83         }

    84         bool haveSpace = false;

    85         while (currentPos < length) {

    86             if (haveSpace && !TChar(string[currentPos]).IsSpace())

    87                 break;

    88             if (TChar(string[currentPos]).IsSpace())

    89                 haveSpace = true;

    90             ++currentPos;

    91         }

    92         return currentPos;

    93     }

    94 

    95     int WordBreakIteratorSymbian::previous() {

    96         if (currentPos == 0) {

    97             currentPos = -1;

    98             return currentPos;

    99         }

   100         bool haveSpace = false;

   101         while (currentPos > 0) {

   102             if (haveSpace && !TChar(string[currentPos]).IsSpace())

   103                 break;

   104             if (TChar(string[currentPos]).IsSpace())

   105                 haveSpace = true;

   106             --currentPos;

   107         }

   108         return currentPos;

   109     }

   110 

   111     int CharBreakIteratorSymbian::first() {

   112         currentPos = 0;

   113         return currentPos;

   114     }

   115 

   116     int CharBreakIteratorSymbian::next() {

   117         if (currentPos == length)

   118             return -1;

   119         

   120         // FIXME: symbian doesn't have Grapheme Cluster support

   121         // currentPos = layout.nextCursorPosition(currentPos);

   122 

   123         currentPos++;

   124         return currentPos;

   125     }

   126     int CharBreakIteratorSymbian::previous() {

   127         if (currentPos == 0)

   128             return -1;

   129 

   130         // FIXME: symbian doesn't have Grapheme Cluster support

   131         // currentPos = layout.nextCursorPosition(currentPos);

   132 

   133         currentPos--;

   134 

   135         //currentPos = layout.previousCursorPosition(currentPos);

   136         return currentPos;

   137     }

   138 

   139     int LineBreakIteratorSymbian::first() {

   140         currentPos = 0;

   141         return currentPos;

   142     }

   143 

   144    int LineBreakIteratorSymbian::next() 

   145    {

   146         if (currentPos == length)

   147             return -1;

   148         

   149       // Asian line breaking. Everywhere allowed except directly in front of a punctuation character.

   150         int iRet = -1;

   151         currentPos++;   

   152         unsigned char row = (KJS::UChar(string[currentPos])).high();

   153         

   154         if ( row > 0x2d && row < 0xfb || row == 0x11 )

   155             iRet = currentPos;

   156         else

   157            iRet = -1;

   158         

   159        return iRet;

   160  }

   161     

   162     int LineBreakIteratorSymbian::previous() 

   163     {

   164        //not implemented

   165        return -1;

   166     }

   167     

   168 

   169 TextBreakIterator* wordBreakIterator(const UChar* string, int length)

   170 {

   171     static WordBreakIteratorSymbian *iterator = 0;

   172     if (!iterator)

   173         iterator = new WordBreakIteratorSymbian;

   174 

   175     iterator->string = string;

   176     iterator->length = length;

   177     iterator->currentPos = 0;

   178 

   179     return iterator;

   180 }

   181 

   182 TextBreakIterator* characterBreakIterator(const UChar* string, int length)

   183 {

   184     static CharBreakIteratorSymbian *iterator = 0;

   185     if (!iterator)

   186         iterator = new CharBreakIteratorSymbian;

   187 

   188     iterator->string = string;

   189     iterator->length = length;

   190     iterator->currentPos = 0;

   191 

   192     return iterator;

   193 }

   194 

   195 TextBreakIterator* lineBreakIterator(const UChar* string, int length)

   196 {

   197    static LineBreakIteratorSymbian *iterator = 0;

   198     if (!iterator)

   199         iterator = new LineBreakIteratorSymbian;

   200 

   201     iterator->string = string;

   202     iterator->length = length;

   203     iterator->currentPos = 0;

   204 

   205     return iterator;

   206 }

   207 

   208 TextBreakIterator* sentenceBreakIterator(const UChar*, int)

   209 {

   210     // not yet implemented

   211     return 0;

   212 }

   213 

   214 

   215 int textBreakFirst(TextBreakIterator* bi)

   216 {

   217     return bi->first();

   218 }

   219 

   220 int textBreakNext(TextBreakIterator* bi)

   221 {

   222     return bi->next();

   223 }

   224 

   225 int textBreakPreceding(TextBreakIterator* bi, int pos)

   226 {

   227     return bi->preceding(pos);

   228 }

   229 

   230 int textBreakFollowing(TextBreakIterator* bi, int pos)

   231 {

   232     return bi->following(pos);

   233 }

   234 

   235 int textBreakCurrent(TextBreakIterator* bi)

   236 {

   237     return bi->currentPos;

   238 }

   239 

   240 bool isTextBreak(TextBreakIterator*, int)

   241 {

   242     return true;

   243 }

   244 

   245 }

   246