Debian Codegraph @

src/reading.cpp

raw
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * Copyright (C) 2005 Takuro Ashie
4 * Copyright (C) 2012 CSSlayer
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2, or (at your option)
9 * any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
19 */
20
21 #include "reading.h"
22 #include "factory.h"
23 #include "imengine.h"
24 #include "utils.h"
25
26 ReadingSegment::ReadingSegment ()
27 {
28 }
29
30 ReadingSegment::~ReadingSegment ()
31 {
32 }
33
34 static const char *
35 find_romaji (std::string c)
36 {
37 ConvRule *table = fcitx_anthy_romaji_typing_rule;
38
39 for (unsigned int i = 0; table[i].string; i++) {
40 std::string kana = table[i].result;
41 if (c == kana)
42 return table[i].string;
43 }
44
45 return "";
46 }
47
48 static void
49 to_half (std::string &dest, std::string &src)
50 {
51 WideRule *table = fcitx_anthy_wide_table;
52
53 for (unsigned int i = 0; i < util_utf8_string_length(src); i++) {
54 bool found = false;
55 std::string kana1 = util_utf8_string_substr(src, i, 1);
56 for (unsigned int i = 0; table[i].code; i++) {
57 std::string kana2 = table[i].wide;
58 if (kana1 == kana2) {
59 dest += table[i].code;
60 found = true;
61 break;
62 }
63 }
64 if (!found)
65 dest += kana1;
66 }
67 }
68
69 // Only a romaji string can be splited with raw key string.
70 // Other typing method aren't supported splitting raw key string.
71 void
72 ReadingSegment::split (ReadingSegments &segments)
73 {
74 if (util_utf8_string_length(kana) <= 1)
75 segments.push_back (*this);
76
77 std::string half;
78 to_half (half, kana);
79 bool same_with_raw = half == raw;
80
81 std::string::iterator it;
82 for (unsigned int i = 0; i < util_utf8_string_length(kana); i++) {
83 std::string c = util_utf8_string_substr(kana, i, 1);
84 ReadingSegment seg;
85 seg.kana = c;
86 if (same_with_raw)
87 to_half (seg.raw, c);
88 else
89 seg.raw = find_romaji (c);
90 segments.push_back (seg);
91 }
92 }
93
94
95
96 Reading::Reading (AnthyInstance &anthy)
97 : m_anthy (anthy),
98 //m_key2kana_tables (tables),
99 m_key2kana_normal (anthy, m_key2kana_tables),
100 m_kana (anthy),
101 m_nicola (anthy, m_nicola_tables),
102 m_key2kana (&m_key2kana_normal),
103 m_segment_pos (0),
104 m_caret_offset (0)
105 {
106 m_nicola_tables.set_typing_method (FCITX_ANTHY_TYPING_METHOD_NICOLA);
107 }
108
109 Reading::~Reading ()
110 {
111 }
112
113 bool
114 Reading::can_process_key_event (const KeyEvent & key)
115 {
116 if (m_kana.can_append (key))
117 return true;
118
119 return m_key2kana->can_append (key);
120 }
121
122 bool
123 Reading::process_key_event (const KeyEvent & key)
124 {
125 if (!can_process_key_event (key))
126 return false;
127
128 if (m_caret_offset != 0) {
129 split_segment (m_segment_pos);
130 reset_pending ();
131 }
132
133 bool was_pending;
134 if (m_kana.can_append (key))
135 was_pending = m_kana.is_pending ();
136 else
137 was_pending = m_key2kana->is_pending ();
138
139 std::string raw;
140 std::string result, pending;
141 bool need_commiting;
142 if (m_kana.can_append (key))
143 need_commiting = m_kana.append (key, result, pending, raw);
144 else
145 need_commiting = m_key2kana->append (key, result, pending, raw);
146
147 ReadingSegments::iterator begin = m_segments.begin ();
148
149 // fix previous segment and prepare next segment if needed
150 if (!result.empty () || !pending.empty ()) {
151 if (!was_pending || // previous segment was already fixed
152 need_commiting) // previous segment has been fixed
153 {
154 ReadingSegment c;
155 m_segments.insert (begin + m_segment_pos, c);
156 m_segment_pos++;
157 }
158 }
159
160 // fill segment
161 if (result.length() > 0 && pending.length () > 0) {
162 m_segments[m_segment_pos - 1].kana = result;
163
164 ReadingSegment c;
165 c.raw += raw;
166 c.kana = pending;
167 m_segments.insert (begin + m_segment_pos, c);
168 m_segment_pos++;
169
170 } else if (result.length () > 0) {
171 m_segments[m_segment_pos - 1].raw += raw;
172 m_segments[m_segment_pos - 1].kana = result;
173
174 } else if (pending.length () > 0) {
175 m_segments[m_segment_pos - 1].raw += raw;
176 m_segments[m_segment_pos - 1].kana = pending;
177
178 } else {
179
180 }
181
182 return false;
183 }
184
185 void
186 Reading::finish (void)
187 {
188 if (!m_key2kana->is_pending ()) return;
189
190 std::string result;
191 result = m_key2kana->flush_pending ();
192 if (result.length () > 0)
193 m_segments[m_segment_pos - 1].kana = result;
194 }
195
196 void
197 Reading::clear (void)
198 {
199 m_key2kana_normal.clear ();
200 m_kana.clear ();
201 m_nicola.clear ();
202 m_segments.clear ();
203 m_segment_pos = 0;
204 m_caret_offset = 0;
205 }
206
207 std::string
208 Reading::get_by_char (unsigned int start, int len, StringType type)
209 {
210 std::string str;
211 unsigned int pos = 0, end = len > 0 ? start + len : get_length_by_char () - start;
212 std::string kana;
213 std::string raw;
214
215 if (start >= end)
216 return str;
217 if (start >= get_length_by_char ())
218 return str;
219
220 switch (type) {
221 case FCITX_ANTHY_STRING_LATIN:
222 raw = get_raw_by_char (start, len);
223 str = raw;
224 return str;
225
226 case FCITX_ANTHY_STRING_WIDE_LATIN:
227 raw = get_raw_by_char (start, len);
228 util_convert_to_wide (str, raw);
229 return str;
230
231 default:
232 break;
233 }
234
235 for (unsigned int i = 0; i < m_segments.size (); i++) {
236 if (pos >= start || pos + util_utf8_string_length(m_segments[i].kana) > start) {
237 unsigned int startstart = 0, len;
238
239 if (pos >= start)
240 startstart = 0;
241 else
242 startstart = pos - start;
243
244 if (pos + util_utf8_string_length(m_segments[i].kana) > end)
245 len = end - start;
246 else
247 len = util_utf8_string_length(m_segments[i].kana);
248
249 kana += util_utf8_string_substr(m_segments[i].kana, startstart, len);
250 }
251
252 pos += util_utf8_string_length(m_segments[i].kana);
253 if (pos >= end)
254 break;
255 }
256
257 switch (type) {
258 case FCITX_ANTHY_STRING_HIRAGANA:
259 str = kana;
260 break;
261
262 case FCITX_ANTHY_STRING_KATAKANA:
263 util_convert_to_katakana (str, kana);
264 break;
265
266 case FCITX_ANTHY_STRING_HALF_KATAKANA:
267 util_convert_to_katakana (str, kana, true);
268 break;
269
270 default:
271 break;
272 }
273
274 return str;
275 }
276
277 std::string
278 Reading::get_raw_by_char (unsigned int start, int len)
279 {
280 std::string str;
281 unsigned int pos = 0, end = len > 0 ? start + len : get_length_by_char () - start;
282
283 if (start >= end)
284 return str;
285
286 for (unsigned int i = 0; i < m_segments.size (); i++) {
287 if (pos >= start || pos + util_utf8_string_length(m_segments[i].kana) > start) {
288 // FIXME!
289 str += m_segments[i].raw;
290 }
291
292 pos += util_utf8_string_length(m_segments[i].kana);
293
294 if (pos >= end)
295 break;
296 }
297
298 return str;
299 }
300
301 void
302 Reading::split_segment (unsigned int seg_id)
303 {
304 if (seg_id >= m_segments.size ())
305 return;
306
307 unsigned int pos = 0;
308 for (unsigned int i = 0; i < seg_id && i < m_segments.size (); i++)
309 pos += m_segments[i].kana.length ();
310
311 unsigned int caret = get_caret_pos ();
312 unsigned int seg_len = m_segments[seg_id].kana.length ();
313 bool caret_was_in_the_segment = false;
314 if (caret > pos && caret < pos + seg_len)
315 caret_was_in_the_segment = true;
316
317 ReadingSegments segments;
318 m_segments[seg_id].split (segments);
319 m_segments.erase (m_segments.begin () + seg_id);
320 for (int j = segments.size () - 1; j >= 0; j--) {
321 m_segments.insert (m_segments.begin () + seg_id, segments[j]);
322 if (m_segment_pos > seg_id)
323 m_segment_pos++;
324 }
325
326 if (caret_was_in_the_segment) {
327 m_segment_pos += m_caret_offset;
328 m_caret_offset = 0;
329 }
330 }
331
332 bool
333 Reading::append (const KeyEvent & key,
334 const std::string & string)
335 {
336 bool was_pending;
337 std::string result, pending;
338 bool need_commiting;
339
340 if (!m_kana.can_append (key, true) &&
341 !m_key2kana->can_append (key, true))
342 return false;
343
344 if (m_caret_offset != 0) {
345 split_segment (m_segment_pos);
346 reset_pending ();
347 }
348
349 if (m_kana.can_append (key))
350 was_pending = m_kana.is_pending ();
351 else
352 was_pending = m_key2kana->is_pending ();
353
354 if (m_kana.can_append (key))
355 need_commiting = m_kana.append (string, result, pending);
356 else
357 need_commiting = m_key2kana->append (string, result, pending);
358
359 ReadingSegments::iterator begin = m_segments.begin ();
360
361 // fix previous segment and prepare next segment if needed
362 if (!result.empty () || !pending.empty ()) {
363 if (!was_pending || // previous segment was already fixed
364 need_commiting) // previous segment has been fixed
365 {
366 ReadingSegment c;
367 m_segments.insert (begin + m_segment_pos, c);
368 m_segment_pos++;
369 }
370 }
371
372 // fill segment
373 if (result.length() > 0 && pending.length () > 0) {
374 m_segments[m_segment_pos - 1].kana = result;
375
376 ReadingSegment c;
377 c.raw += string;
378 c.kana = pending;
379 m_segments.insert (begin + m_segment_pos, c);
380 m_segment_pos++;
381
382 } else if (result.length () > 0) {
383 m_segments[m_segment_pos - 1].raw += string;
384 m_segments[m_segment_pos - 1].kana = result;
385
386 } else if (pending.length () > 0) {
387 m_segments[m_segment_pos - 1].raw += string;
388 m_segments[m_segment_pos - 1].kana = pending;
389
390 } else {
391
392 }
393
394 return false;
395 }
396
397 void
398 Reading::erase (unsigned int start, int len, bool allow_split)
399 {
400 if (m_segments.size () <= 0)
401 return;
402
403 if (get_length_by_char () < start)
404 return;
405
406 if (len < 0)
407 len = get_length_by_char () - start;
408
409 // erase
410 unsigned int pos = 0;
411 for (int i = 0; i <= (int) m_segments.size (); i++) {
412 if (pos < start) {
413 // we have not yet reached start position.
414
415 if (i == (int) m_segments.size ())
416 break;
417
418 pos += util_utf8_string_length(m_segments[i].kana);
419
420 } else if (pos == start) {
421 // we have reached start position.
422
423 if (i == (int) m_segments.size ())
424 break;
425
426 if (allow_split &&
427 pos + util_utf8_string_length(m_segments[i].kana) > start + len)
428 {
429 // we have overshooted the end position!
430 // we have to split this segment
431 split_segment (i);
432
433 } else {
434 // This segment is completely in the rage, erase it!
435 len -= util_utf8_string_length(m_segments[i].kana);
436 m_segments.erase (m_segments.begin () + i);
437 if ((int) m_segment_pos > i)
438 m_segment_pos--;
439 }
440
441 // retry from the same position
442 i--;
443
444 } else {
445 // we have overshooted the start position!
446
447 if (allow_split) {
448 pos -= util_utf8_string_length(m_segments[i - 1].kana);
449 split_segment (i - 1);
450
451 // retry from the previous position
452 i -= 2;
453
454 } else {
455 // we have overshooted the start position, but have not been
456 // allowed to split the segment.
457 // So remove all string of previous segment.
458 len -= pos - start;
459 pos -= util_utf8_string_length(m_segments[i - 1].kana);
460 m_segments.erase (m_segments.begin () + i - 1);
461 if ((int) m_segment_pos > i - 1)
462 m_segment_pos--;
463
464 // retry from the previous position
465 i -= 2;
466 }
467 }
468
469 // Now all letters in the range are removed.
470 // Exit the loop.
471 if (len <= 0)
472 break;
473 }
474
475 // reset values
476 if (m_segments.size () <= 0) {
477 clear ();
478 } else {
479 reset_pending ();
480 }
481 }
482
483 void
484 Reading::reset_pending (void)
485 {
486 if (m_key2kana->is_pending ())
487 m_key2kana->clear ();
488 if (m_kana.is_pending ())
489 m_kana.clear ();
490
491 if (m_segment_pos <= 0)
492 return;
493
494 m_key2kana->reset_pending (m_segments[m_segment_pos - 1].kana,
495 m_segments[m_segment_pos - 1].raw);
496 m_kana.reset_pending (m_segments[m_segment_pos - 1].kana,
497 m_segments[m_segment_pos - 1].raw);
498
499 // FIXME! this code breaks pending state on normal input mode.
500 m_key2kana->reset_pseudo_ascii_mode();
501 for (unsigned int i = 0; i < m_segment_pos; i++)
502 m_key2kana->process_pseudo_ascii_mode(m_segments[i].kana);
503 }
504
505 unsigned int
506 Reading::get_length (void)
507 {
508 unsigned int len = 0;
509 for (unsigned int i = 0; i < m_segments.size (); i++)
510 len += m_segments[i].kana.length();
511 return len;
512 }
513
514 unsigned int
515 Reading::get_length_by_char (void)
516 {
517 unsigned int len = 0;
518 for (unsigned int i = 0; i < m_segments.size (); i++)
519 len += util_utf8_string_length(m_segments[i].kana);
520 return len;
521 }
522
523 unsigned int
524 Reading::get_caret_pos_by_char (void)
525 {
526 unsigned int pos = 0;
527
528 unsigned int i;
529 for (i = 0;
530 i < m_segment_pos && i < m_segments.size ();
531 i++)
532 {
533 pos += util_utf8_string_length(m_segments[i].kana);
534 }
535
536 pos += m_caret_offset;
537
538 return pos;
539 }
540
541 unsigned int
542 Reading::get_caret_pos (void)
543 {
544 unsigned int pos = 0;
545
546 unsigned int i;
547 for (i = 0;
548 i < m_segment_pos && i < m_segments.size ();
549 i++)
550 {
551 pos += m_segments[i].kana.length();
552 }
553
554 if (i < m_segments.size() && m_caret_offset) {
555 char* temp = strdup(m_segments[i].kana.c_str());
556 char* nth = fcitx_utf8_get_nth_char(temp, m_caret_offset);
557 pos += (nth - temp);
558 free(temp);
559 }
560
561 return pos;
562 }
563
564 // FIXME! add "allow_split" argument.
565 void
566 Reading::set_caret_pos_by_char (unsigned int pos)
567 {
568 if (pos == get_caret_pos_by_char ())
569 return;
570
571 m_key2kana->clear ();
572 m_kana.clear ();
573
574 if (pos >= get_length_by_char ()) {
575 m_segment_pos = m_segments.size ();
576
577 } else if (pos == 0 || m_segments.size () <= 0) {
578 m_segment_pos = 0;
579
580 } else {
581 unsigned int i, tmp_pos = 0;
582
583 for (i = 0; tmp_pos <= pos; i++)
584 tmp_pos += util_utf8_string_length(m_segments[i].kana);
585
586 if (tmp_pos == pos) {
587 m_segment_pos = i + 1;
588 } else if (tmp_pos < get_caret_pos_by_char ()) {
589 m_segment_pos = i;
590 } else if (tmp_pos > get_caret_pos_by_char ()) {
591 m_segment_pos = i + 1;
592 }
593 }
594
595 reset_pending ();
596 }
597
598 void
599 Reading::move_caret (int step, bool allow_split)
600 {
601 if (step == 0)
602 return;
603
604 m_key2kana->clear ();
605 m_kana.clear ();
606
607 if (allow_split) {
608 unsigned int pos = get_caret_pos_by_char ();
609 if (step < 0 && pos < (int) abs (step)) {
610 // lower limit
611 m_segment_pos = 0;
612
613 } else if (step > 0 && pos + step > get_length_by_char ()) {
614 // upper limit
615 m_segment_pos = m_segments.size ();
616
617 } else {
618 unsigned int new_pos = pos + step;
619 ReadingSegments::iterator it;
620 pos = 0;
621 m_segment_pos = 0;
622 m_caret_offset = 0;
623 for (it = m_segments.begin (); pos < new_pos; it++) {
624 if (pos + util_utf8_string_length(it->kana) > new_pos) {
625 m_caret_offset = new_pos - pos;
626 break;
627 } else {
628 m_segment_pos++;
629 pos += util_utf8_string_length(it->kana);
630 }
631 }
632 }
633
634 } else {
635 if (step < 0 && m_segment_pos < (int) abs (step)) {
636 // lower limit
637 m_segment_pos = 0;
638
639 } else if (step > 0 && m_segment_pos + step > m_segments.size ()) {
640 // upper limit
641 m_segment_pos = m_segments.size ();
642
643 } else {
644 // other
645 m_segment_pos += step;
646 }
647 }
648
649 reset_pending ();
650 }
651
652 void
653 Reading::set_typing_method (TypingMethod method)
654 {
655 Key2KanaTable *fundamental_table = NULL;
656
657 if (method == FCITX_ANTHY_TYPING_METHOD_NICOLA) {
658 fundamental_table = m_anthy.get_config()->m_custom_nicola_table;
659 m_key2kana = &m_nicola;
660 m_nicola_tables.set_typing_method (method, fundamental_table);
661 m_nicola.set_case_sensitive (true);
662 } else if (method == FCITX_ANTHY_TYPING_METHOD_KANA) {
663 fundamental_table = m_anthy.get_config()->m_custom_kana_table;
664 m_key2kana = &m_key2kana_normal;
665 m_key2kana_tables.set_typing_method (method, fundamental_table);
666 m_key2kana_normal.set_case_sensitive (true);
667 } else {
668 fundamental_table = m_anthy.get_config()->m_custom_romaji_table;
669 m_key2kana = &m_key2kana_normal;
670 m_key2kana_tables.set_typing_method (method, fundamental_table);
671 m_key2kana_normal.set_case_sensitive (false);
672 }
673 }
674
675 TypingMethod
676 Reading::get_typing_method (void)
677 {
678 if (m_key2kana == &m_nicola)
679 return FCITX_ANTHY_TYPING_METHOD_NICOLA;
680 else
681 return m_key2kana_tables.get_typing_method ();
682 }
683
684 void
685 Reading::set_period_style (PeriodStyle style)
686 {
687 m_key2kana_tables.set_period_style (style);
688 }
689
690 PeriodStyle
691 Reading::get_period_style (void)
692 {
693 return m_key2kana_tables.get_period_style ();
694 }
695
696 void
697 Reading::set_comma_style (CommaStyle style)
698 {
699 m_key2kana_tables.set_comma_style (style);
700 }
701
702 CommaStyle
703 Reading::get_comma_style (void)
704 {
705 return m_key2kana_tables.get_comma_style ();
706 }
707
708 void
709 Reading::set_bracket_style (BracketStyle style)
710 {
711 m_key2kana_tables.set_bracket_style (style);
712 }
713
714 BracketStyle
715 Reading::get_bracket_style (void)
716 {
717 return m_key2kana_tables.get_bracket_style ();
718 }
719
720 void
721 Reading::set_slash_style (SlashStyle style)
722 {
723 m_key2kana_tables.set_slash_style (style);
724 }
725
726 SlashStyle
727 Reading::get_slash_style (void)
728 {
729 return m_key2kana_tables.get_slash_style ();
730 }
731
732 void
733 Reading::set_symbol_width (bool half)
734 {
735 m_key2kana_tables.set_symbol_width (half);
736 }
737
738 bool
739 Reading::get_symbol_width (void)
740 {
741 return m_key2kana_tables.symbol_is_half ();
742 }
743
744 void
745 Reading::set_number_width (bool half)
746 {
747 m_key2kana_tables.set_number_width (half);
748 }
749
750 bool
751 Reading::get_number_width (void)
752 {
753 return m_key2kana_tables.number_is_half ();
754 }
755
756 void
757 Reading::set_pseudo_ascii_mode (int mode)
758 {
759 m_key2kana_normal.set_pseudo_ascii_mode (mode);
760 }
761
762 bool
763 Reading::is_pseudo_ascii_mode (void)
764 {
765 return m_key2kana_normal.is_pseudo_ascii_mode ();
766 }
767
768 void
769 Reading::reset_pseudo_ascii_mode (void)
770 {
771 if (m_key2kana_normal.is_pseudo_ascii_mode () &&
772 m_key2kana_normal.is_pending ())
773 {
774 ReadingSegment c;
775 ReadingSegments::iterator it = m_segments.begin ();
776
777 /* separate to another segment */
778 m_key2kana_normal.reset_pseudo_ascii_mode ();
779 m_segments.insert (it + m_segment_pos, c);
780 m_segment_pos++;
781 }
782 }