Home | History | Annotate | Download | only in openwnn
      1 /*
      2  * Copyright (C) 2008-2012  OMRON SOFTWARE Co., Ltd.
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package jp.co.omronsoft.openwnn;
     18 
     19 import java.util.Iterator;
     20 import java.util.ArrayList;
     21 
     22 import android.util.Log;
     23 
     24 /**
     25  * The container class of composing string.
     26  *
     27  * This interface is for the class includes information about the
     28  * input string, the converted string and its decoration.
     29  * {@link LetterConverter} and {@link WnnEngine} get the input string from it, and
     30  * store the converted string into it.
     31  *
     32  * @author Copyright (C) 2009 OMRON SOFTWARE CO., LTD.  All Rights Reserved.
     33  */
     34 public class ComposingText {
     35     /**
     36      * Text layer 0.
     37      * <br>
     38      * This text layer holds key strokes.<br>
     39      * (ex) Romaji in Japanese.  Parts of Hangul in Korean.
     40      */
     41     public static final int LAYER0  = 0;
     42     /**
     43      * Text layer 1.
     44      * <br>
     45      * This text layer holds the result of the letter converter.<br>
     46      * (ex) Hiragana in Japanese. Pinyin in Chinese. Hangul in Korean.
     47      */
     48     public static final int LAYER1  = 1;
     49     /**
     50      * Text layer 2.
     51      * <br>
     52      * This text layer holds the result of the consecutive clause converter.<br>
     53      * (ex) the result of Kana-to-Kanji conversion in Japanese,
     54      *      Pinyin-to-Kanji conversion in Chinese, Hangul-to-Hanja conversion in Korean language.
     55      */
     56     public static final int LAYER2  = 2;
     57     /** Maximum number of layers */
     58     public static final int MAX_LAYER = 3;
     59 
     60     /** Composing text's layer data */
     61     protected ArrayList<StrSegment>[] mStringLayer;
     62     /** Cursor position */
     63     protected int[] mCursor;
     64 
     65     /**
     66      * Constructor
     67      */
     68     public ComposingText() {
     69         mStringLayer = new ArrayList[MAX_LAYER];
     70         mCursor = new int[MAX_LAYER];
     71         for (int i = 0; i < MAX_LAYER; i++) {
     72             mStringLayer[i] = new ArrayList<StrSegment>();
     73             mCursor[i] = 0;
     74         }
     75     }
     76 
     77     /**
     78      * Output internal information to the log.
     79      */
     80     public void debugout() {
     81         for (int i = 0; i < MAX_LAYER; i++) {
     82             Log.d("OpenWnn", "ComposingText["+i+"]");
     83             Log.d("OpenWnn", "  cur = " + mCursor[i]);
     84             String tmp = "";
     85             for (Iterator<StrSegment> it = mStringLayer[i].iterator(); it.hasNext();) {
     86                 StrSegment ss = it.next();
     87                 tmp += "(" + ss.string + "," + ss.from + "," + ss.to + ")";
     88             }
     89             Log.d("OpenWnn", "  str = "+tmp);
     90         }
     91     }
     92 
     93     /**
     94      * Get a {@link StrSegment} at the position specified.
     95      *
     96      * @param layer     Layer
     97      * @param pos       Position (<0 : the tail segment)
     98      *
     99      * @return          The segment; {@code null} if error occurs.
    100      */
    101     public StrSegment getStrSegment(int layer, int pos) {
    102         try {
    103             ArrayList<StrSegment> strLayer = mStringLayer[layer];
    104             if (pos < 0) {
    105                 pos = strLayer.size() - 1;
    106             }
    107             if (pos >= strLayer.size() || pos < 0) {
    108                 return null;
    109             }
    110             return strLayer.get(pos);
    111         } catch (Exception ex) {
    112             return null;
    113         }
    114     }
    115 
    116     /**
    117      * Convert the range of segments to a string.
    118      *
    119      * @param layer     Layer
    120      * @param from      Convert range from
    121      * @param to        Convert range to
    122      * @return          The string converted; {@code null} if error occurs.
    123      */
    124     public String toString(int layer, int from, int to) {
    125         try {
    126             StringBuffer buf = new StringBuffer();
    127             ArrayList<StrSegment> strLayer = mStringLayer[layer];
    128 
    129             for (int i = from; i <= to; i++) {
    130                 StrSegment ss = strLayer.get(i);
    131                 buf.append(ss.string);
    132             }
    133             return buf.toString();
    134         } catch (Exception ex) {
    135             return null;
    136         }
    137     }
    138 
    139     /**
    140      * Convert segments of the layer to a string.
    141      *
    142      * @param layer     Layer
    143      * @return          The string converted; {@code null} if error occurs.
    144      */
    145     public String toString(int layer) {
    146         return this.toString(layer, 0, mStringLayer[layer].size() - 1);
    147     }
    148 
    149     /**
    150      * Update the upper layer's data.
    151      *
    152      * @param layer         The base layer
    153      * @param mod_from      Modified from
    154      * @param mod_len       Length after modified (# of StrSegments from {@code mod_from})
    155      * @param org_len       Length before modified (# of StrSegments from {@code mod_from})
    156      */
    157     private void modifyUpper(int layer, int mod_from, int mod_len, int org_len) {
    158         if (layer >= MAX_LAYER - 1) {
    159             /* no layer above */
    160             return;
    161         }
    162 
    163         int uplayer = layer + 1;
    164         ArrayList<StrSegment> strUplayer = mStringLayer[uplayer];
    165         if (strUplayer.size() <= 0) {
    166             /*
    167              * if there is no element on above layer,
    168              * add a element includes whole elements of the lower layer.
    169              */
    170             strUplayer.add(new StrSegment(toString(layer), 0, mStringLayer[layer].size() - 1));
    171             modifyUpper(uplayer, 0, 1, 0);
    172             return;
    173         }
    174 
    175         int mod_to = mod_from + ((mod_len == 0)? 0 : (mod_len - 1));
    176         int org_to = mod_from + ((org_len == 0)? 0 : (org_len - 1));
    177         StrSegment last = strUplayer.get(strUplayer.size() - 1);
    178         if (last.to < mod_from) {
    179             /* add at the tail */
    180             last.to = mod_to;
    181             last.string = toString(layer, last.from, last.to);
    182             modifyUpper(uplayer, strUplayer.size()-1, 1, 1);
    183             return;
    184         }
    185 
    186         int uplayer_mod_from = -1;
    187         int uplayer_org_to = -1;
    188         for (int i = 0; i < strUplayer.size(); i++) {
    189             StrSegment ss = strUplayer.get(i);
    190             if (ss.from > mod_from) {
    191                 if (ss.to <= org_to) {
    192                     /* the segment is included */
    193                     if (uplayer_mod_from < 0) {
    194                         uplayer_mod_from = i;
    195                     }
    196                     uplayer_org_to = i;
    197                 } else {
    198                     /* included in this segment */
    199                     uplayer_org_to = i;
    200                     break;
    201                 }
    202             } else {
    203                 if (org_len == 0 && ss.from == mod_from) {
    204                     /* when an element is added */
    205                     uplayer_mod_from = i - 1;
    206                     uplayer_org_to   = i - 1;
    207                     break;
    208                 } else {
    209                     /* start from this segment */
    210                     uplayer_mod_from = i;
    211                     uplayer_org_to = i;
    212                     if (ss.to >= org_to) {
    213                         break;
    214                     }
    215                 }
    216             }
    217         }
    218 
    219         int diff = mod_len - org_len;
    220         if (uplayer_mod_from >= 0) {
    221             /* update an element */
    222             StrSegment ss = strUplayer.get(uplayer_mod_from);
    223             int last_to = ss.to;
    224             int next = uplayer_mod_from + 1;
    225             for (int i = next; i <= uplayer_org_to; i++) {
    226                 ss = strUplayer.get(next);
    227                 if (last_to > ss.to) {
    228                     last_to = ss.to;
    229                 }
    230                 strUplayer.remove(next);
    231             }
    232             ss.to = (last_to < mod_to)? mod_to : (last_to + diff);
    233 
    234             ss.string = toString(layer, ss.from, ss.to);
    235 
    236             for (int i = next; i < strUplayer.size(); i++) {
    237                 ss = strUplayer.get(i);
    238                 ss.from += diff;
    239                 ss.to   += diff;
    240             }
    241 
    242             modifyUpper(uplayer, uplayer_mod_from, 1, uplayer_org_to - uplayer_mod_from + 1);
    243         } else {
    244             /* add an element at the head */
    245             StrSegment ss = new StrSegment(toString(layer, mod_from, mod_to),
    246                                            mod_from, mod_to);
    247             strUplayer.add(0, ss);
    248             for (int i = 1; i < strUplayer.size(); i++) {
    249                 ss = strUplayer.get(i);
    250                 ss.from += diff;
    251                 ss.to   += diff;
    252             }
    253             modifyUpper(uplayer, 0, 1, 0);
    254         }
    255 
    256         return;
    257     }
    258 
    259     /**
    260      * Insert a {@link StrSegment} at the cursor position.
    261      *
    262      * @param layer Layer to insert
    263      * @param str   String
    264      **/
    265     public void insertStrSegment(int layer, StrSegment str) {
    266         int cursor = mCursor[layer];
    267         mStringLayer[layer].add(cursor, str);
    268         modifyUpper(layer, cursor, 1, 0);
    269         setCursor(layer, cursor + 1);
    270     }
    271 
    272     /**
    273      * Insert a {@link StrSegment} at the cursor position(without merging to the previous segment).
    274      * <p>
    275      * @param layer1        Layer to insert
    276      * @param layer2        Never merge to the previous segment from {@code layer1} to {@code layer2}.
    277      * @param str           String
    278      **/
    279     public void insertStrSegment(int layer1, int layer2, StrSegment str) {
    280         mStringLayer[layer1].add(mCursor[layer1], str);
    281         mCursor[layer1]++;
    282 
    283         for (int i = layer1 + 1; i <= layer2; i++) {
    284             int pos = mCursor[i-1] - 1;
    285             StrSegment tmp = new StrSegment(str.string, pos, pos);
    286             ArrayList<StrSegment> strLayer = mStringLayer[i];
    287             strLayer.add(mCursor[i], tmp);
    288             mCursor[i]++;
    289             for (int j = mCursor[i]; j < strLayer.size(); j++) {
    290                 StrSegment ss = strLayer.get(j);
    291                 ss.from++;
    292                 ss.to++;
    293             }
    294         }
    295         int cursor = mCursor[layer2];
    296         modifyUpper(layer2, cursor - 1, 1, 0);
    297         setCursor(layer2, cursor);
    298     }
    299 
    300     /**
    301      * Replace segments at the range specified.
    302      *
    303      * @param layer     Layer
    304      * @param str       String segment array to replace
    305      * @param from      Replace from
    306      * @param to        Replace to
    307      **/
    308     protected void replaceStrSegment0(int layer, StrSegment[] str, int from, int to) {
    309         ArrayList<StrSegment> strLayer = mStringLayer[layer];
    310 
    311         if (from < 0 || from > strLayer.size()) {
    312             from = strLayer.size();
    313         }
    314         if (to < 0 || to > strLayer.size()) {
    315             to = strLayer.size();
    316         }
    317         for (int i = from; i <= to; i++) {
    318             strLayer.remove(from);
    319         }
    320         for (int i = str.length - 1; i >= 0; i--) {
    321             strLayer.add(from, str[i]);
    322         }
    323 
    324         modifyUpper(layer, from, str.length, to - from + 1);
    325     }
    326 
    327     /**
    328      * Replace segments at the range specified.
    329      *
    330      * @param layer     Layer
    331      * @param str       String segment array to replace
    332      * @param num       Size of string segment array
    333      **/
    334     public void replaceStrSegment(int layer, StrSegment[] str, int num) {
    335         int cursor = mCursor[layer];
    336         replaceStrSegment0(layer, str, cursor - num, cursor - 1);
    337         setCursor(layer, cursor + str.length - num);
    338     }
    339 
    340     /**
    341      * Replace the segment at the cursor.
    342      *
    343      * @param layer     Layer
    344      * @param str       String segment to replace
    345      **/
    346     public void replaceStrSegment(int layer, StrSegment[] str) {
    347         int cursor = mCursor[layer];
    348         replaceStrSegment0(layer, str, cursor - 1, cursor - 1);
    349         setCursor(layer, cursor + str.length - 1);
    350     }
    351 
    352     /**
    353      * Delete segments.
    354      *
    355      * @param layer Layer
    356      * @param from  Delete from
    357      * @param to    Delete to
    358      **/
    359     public void deleteStrSegment(int layer, int from, int to) {
    360         int[] fromL = new int[] {-1, -1, -1};
    361         int[] toL   = new int[] {-1, -1, -1};
    362 
    363         ArrayList<StrSegment> strLayer2 = mStringLayer[2];
    364         ArrayList<StrSegment> strLayer1 = mStringLayer[1];
    365 
    366         if (layer == 2) {
    367             fromL[2] = from;
    368             toL[2]   = to;
    369             fromL[1] = strLayer2.get(from).from;
    370             toL[1]   = strLayer2.get(to).to;
    371             fromL[0] = strLayer1.get(fromL[1]).from;
    372             toL[0]   = strLayer1.get(toL[1]).to;
    373         } else if (layer == 1) {
    374             fromL[1] = from;
    375             toL[1]   = to;
    376             fromL[0] = strLayer1.get(from).from;
    377             toL[0]   = strLayer1.get(to).to;
    378         } else {
    379             fromL[0] = from;
    380             toL[0]   = to;
    381         }
    382 
    383         int diff = to - from + 1;
    384         for (int lv = 0; lv < MAX_LAYER; lv++) {
    385             if (fromL[lv] >= 0) {
    386                 deleteStrSegment0(lv, fromL[lv], toL[lv], diff);
    387             } else {
    388                 int boundary_from = -1;
    389                 int boundary_to   = -1;
    390                 ArrayList<StrSegment> strLayer = mStringLayer[lv];
    391                 for (int i = 0; i < strLayer.size(); i++) {
    392                     StrSegment ss = (StrSegment)strLayer.get(i);
    393                     if ((ss.from >= fromL[lv-1] && ss.from <= toL[lv-1]) ||
    394                         (ss.to >= fromL[lv-1] && ss.to <= toL[lv-1]) ) {
    395                         if (fromL[lv] < 0) {
    396                             fromL[lv] = i;
    397                             boundary_from = ss.from;
    398                         }
    399                         toL[lv] = i;
    400                         boundary_to = ss.to;
    401                     } else if (ss.from <= fromL[lv-1] && ss.to >= toL[lv-1]) {
    402                         boundary_from = ss.from;
    403                         boundary_to   = ss.to;
    404                         fromL[lv] = i;
    405                         toL[lv] = i;
    406                         break;
    407                     } else if (ss.from > toL[lv-1]) {
    408                         break;
    409                     }
    410                 }
    411                 if (boundary_from != fromL[lv-1] || boundary_to != toL[lv-1]) {
    412                     deleteStrSegment0(lv, fromL[lv] + 1, toL[lv], diff);
    413                     boundary_to -= diff;
    414                     StrSegment[] tmp = new StrSegment[] {
    415                         (new StrSegment(toString(lv-1), boundary_from, boundary_to))
    416                     };
    417                     replaceStrSegment0(lv, tmp, fromL[lv], fromL[lv]);
    418                     return;
    419                 } else {
    420                     deleteStrSegment0(lv, fromL[lv], toL[lv], diff);
    421                 }
    422             }
    423             diff = toL[lv] - fromL[lv] + 1;
    424         }
    425     }
    426 
    427     /**
    428      * Delete segments (internal method).
    429      *
    430      * @param layer     Layer
    431      * @param from      Delete from
    432      * @param to        Delete to
    433      * @param diff      Differential
    434      **/
    435     private void deleteStrSegment0(int layer, int from, int to, int diff) {
    436         ArrayList<StrSegment> strLayer = mStringLayer[layer];
    437         if (diff != 0) {
    438             for (int i = to + 1; i < strLayer.size(); i++) {
    439                 StrSegment ss = strLayer.get(i);
    440                 ss.from -= diff;
    441                 ss.to   -= diff;
    442             }
    443         }
    444         for (int i = from; i <= to; i++) {
    445             strLayer.remove(from);
    446         }
    447     }
    448 
    449     /**
    450      * Delete a segment at the cursor.
    451      *
    452      * @param layer         Layer
    453      * @param rightside     {@code true} if direction is rightward at the cursor, {@code false} if direction is leftward at the cursor
    454      * @return              The number of string segments in the specified layer
    455      **/
    456     public int delete(int layer, boolean rightside) {
    457         int cursor = mCursor[layer];
    458         ArrayList<StrSegment> strLayer = mStringLayer[layer];
    459 
    460         if (!rightside && cursor > 0) {
    461             deleteStrSegment(layer, cursor-1, cursor-1);
    462             setCursor(layer, cursor - 1);
    463         } else if (rightside && cursor < strLayer.size()) {
    464             deleteStrSegment(layer, cursor, cursor);
    465             setCursor(layer, cursor);
    466         }
    467         return strLayer.size();
    468     }
    469 
    470     /**
    471      * Get the string layer.
    472      *
    473      * @param layer     Layer
    474      * @return          {@link ArrayList} of {@link StrSegment}; {@code null} if error.
    475      **/
    476     public ArrayList<StrSegment> getStringLayer(int layer) {
    477         try {
    478             return mStringLayer[layer];
    479         } catch (Exception ex) {
    480             return null;
    481         }
    482     }
    483 
    484     /**
    485      * Get upper the segment which includes the position.
    486      *
    487      * @param layer     Layer
    488      * @param pos       Position
    489      * @return      Index of upper segment
    490      */
    491     private int included(int layer, int pos) {
    492         if (pos == 0) {
    493             return 0;
    494         }
    495         int uplayer = layer + 1;
    496         int i;
    497         ArrayList<StrSegment> strLayer = mStringLayer[uplayer];
    498         for (i = 0; i < strLayer.size(); i++) {
    499             StrSegment ss = strLayer.get(i);
    500             if (ss.from <= pos && pos <= ss.to) {
    501                 break;
    502             }
    503         }
    504         return i;
    505     }
    506 
    507     /**
    508      * Set the cursor.
    509      *
    510      * @param layer     Layer
    511      * @param pos       Position of cursor
    512      * @return      New position of cursor
    513      */
    514     public int setCursor(int layer, int pos) {
    515         if (pos > mStringLayer[layer].size()) {
    516             pos = mStringLayer[layer].size();
    517         }
    518         if (pos < 0) {
    519             pos = 0;
    520         }
    521         if (layer == 0) {
    522             mCursor[0] = pos;
    523             mCursor[1] = included(0, pos);
    524             mCursor[2] = included(1, mCursor[1]);
    525         } else if (layer == 1) {
    526             mCursor[2] = included(1, pos);
    527             mCursor[1] = pos;
    528             mCursor[0] = (pos > 0)? mStringLayer[1].get(pos - 1).to+1 : 0;
    529         } else {
    530             mCursor[2] = pos;
    531             mCursor[1] = (pos > 0)? mStringLayer[2].get(pos - 1).to+1 : 0;
    532             mCursor[0] = (mCursor[1] > 0)? mStringLayer[1].get(mCursor[1] - 1).to+1 : 0;
    533         }
    534         return pos;
    535     }
    536 
    537     /**
    538      * Move the cursor.
    539      *
    540      * @param layer     Layer
    541      * @param diff      Relative position from current cursor position
    542      * @return      New position of cursor
    543      **/
    544     public int moveCursor(int layer, int diff) {
    545         int c = mCursor[layer] + diff;
    546 
    547         return setCursor(layer, c);
    548     }
    549 
    550     /**
    551      * Get the cursor position.
    552      *
    553      * @param layer     Layer
    554      * @return cursor   Current position of cursor
    555      **/
    556     public int getCursor(int layer) {
    557         return mCursor[layer];
    558     }
    559 
    560     /**
    561      * Get the number of segments.
    562      *
    563      * @param layer     Layer
    564      * @return          Number of segments
    565      **/
    566     public int size(int layer) {
    567         return mStringLayer[layer].size();
    568     }
    569 
    570     /**
    571      * Clear all information.
    572      */
    573     public void clear() {
    574         for (int i = 0; i < MAX_LAYER; i++) {
    575             mStringLayer[i].clear();
    576             mCursor[i] = 0;
    577         }
    578     }
    579 }
    580