|
1 /* |
|
2 * Copyright (c) 2003-2006 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0"" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Global PtiEngine definitions |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
|
28 |
|
29 |
|
30 |
|
31 #ifndef _PTI_DEFS_H |
|
32 #define _PTI_DEFS_H |
|
33 |
|
34 #include <e32keys.h> |
|
35 |
|
36 #ifdef RD_HINDI_PHONETIC_INPUT |
|
37 /* Indic Phonetic input */ |
|
38 |
|
39 /* |
|
40 * Defines the state of the syllable. This is used by FEP for either committing |
|
41 * the inline text or updating the inline text. |
|
42 */ |
|
43 |
|
44 enum TSyllableState |
|
45 { |
|
46 EIndicSyllableStateFirst, |
|
47 EIndicSyllableStateInsideSyllable, |
|
48 EIndicSyllableStateSyllableBroken, |
|
49 EIndicSyllableStateLast |
|
50 }; |
|
51 |
|
52 |
|
53 /* |
|
54 * This is a structure that abstracts the phonetic argument and the response |
|
55 * from the Indic phonetic core in a structure. |
|
56 */ |
|
57 |
|
58 typedef struct |
|
59 { |
|
60 TChar iChar; |
|
61 TDes *iDest; |
|
62 TSyllableState iState; |
|
63 }TPhoneticArg; |
|
64 |
|
65 #endif |
|
66 const TInt KMaxLanguageNameLength = 50; |
|
67 const TInt KMaxAutoSubstStringLength = 32; |
|
68 |
|
69 const TInt KErrPtiEngineBase = (-1000); //based on the value of leave in PtiEngine |
|
70 |
|
71 |
|
72 enum TPtiError |
|
73 { |
|
74 KErrNoActiveLanguage = KErrPtiEngineBase-1, |
|
75 KErrLanguageNotFound = KErrPtiEngineBase-2, |
|
76 KErrNoSuitableCore = KErrPtiEngineBase-3, |
|
77 KErrNotAllowed = KErrPtiEngineBase-4, |
|
78 KErrTooLongWord = KErrPtiEngineBase-5, |
|
79 KErrInvalidWord = KErrPtiEngineBase-6, |
|
80 KErrTooLongReading = KErrPtiEngineBase-7, |
|
81 KErrInvalidReading = KErrPtiEngineBase-8, |
|
82 KErrUserDic = KErrPtiEngineBase-9, |
|
83 KErrInternalCoreError = KErrPtiEngineBase-10, |
|
84 KErrLengthMismatch = KErrPtiEngineBase-11 |
|
85 }; |
|
86 |
|
87 |
|
88 /** |
|
89 * Enumerations for all the possible input modes supported by PtiEngine. |
|
90 * The modes actually available in the device depend on core object, resource |
|
91 * and keyboard configuration. |
|
92 * Here are short descriptions: |
|
93 * |
|
94 * EPtiEngineMultitapping |
|
95 * Traditional text input method for latin-like languages, where |
|
96 * a list of characters is associated to each keypad keys |
|
97 * and user cycles through associated characters by consecutive key presses. |
|
98 * |
|
99 * EPtiEnginePredictive |
|
100 * Predictive text input mode, where user presses only one key press per |
|
101 * character and the prediction engine provides a list of candidate words |
|
102 * associated top that key sequence. |
|
103 * |
|
104 * EPtiEngineWordCompletion |
|
105 * This is same as EPtiEnginePredictive, except that prediction engine |
|
106 * will include also complete words containing more characters than |
|
107 * the number of key presses in current key sequence. |
|
108 * |
|
109 * EPtiEngineNumeric |
|
110 * This is numeric input mode. All the languages suppor it, since it uses |
|
111 * static keymappings built directly into PtiEngine. It works in same way |
|
112 * as EPtiEngineMultitapping, except that keymapping data contains |
|
113 * only number mode characters. |
|
114 * |
|
115 * EPtiEngineQwerty |
|
116 * Standard qwerty-keyboard input mode for latin-like languages. |
|
117 * |
|
118 * EPtiEnginePinyin |
|
119 * Chinese PinYin input mode for ITU-T keypad. |
|
120 * |
|
121 * EPtiEngineStroke |
|
122 * Chinese Strokes input mode for ITU-T keypad. |
|
123 * |
|
124 * EPtiEngineStroke |
|
125 * Chinese ZhuYin input mode for ITU-T keypad. |
|
126 * |
|
127 * EPtiEngineHirakanaKanji |
|
128 * Japanese Hiragana/Kanji input mode. |
|
129 * |
|
130 * EPtiEngineHirakanaKanjiPredictive |
|
131 * Predictive Japanese Hiragana/Kanji input mode. |
|
132 * |
|
133 * EPtiEngineKatakana |
|
134 * Japanese Katakana input mode. |
|
135 * |
|
136 * EPtiEngineFullWitdthKatakana |
|
137 * Japanese full width Katakana input mode. |
|
138 * |
|
139 * EPtiEngineFullWitdthKatakana |
|
140 * Japanese full width numeric input mode. |
|
141 * |
|
142 * EPtiEngineFullWitdthAlphabet |
|
143 * Japanese full width alphabet input mode. |
|
144 * |
|
145 * EPtiEngineHiragana |
|
146 * Japanese Hiragana input mode. |
|
147 * |
|
148 * EPtiEnginePinyinByPhrase |
|
149 * Chinese Pinyin phrase input. This is same as EPtiEnginePinyin, execpt that |
|
150 * input string may contain pinyin words for several chinese characters. |
|
151 * |
|
152 * EPtiEngineZhuyinByPhrase |
|
153 * Chinese Zinyin phrase input. This is same as EPtiEngineZhuyin, execpt that |
|
154 * input string may contain zhuyin sequences for several chinese characters. |
|
155 * |
|
156 * EPtiEngineZhuyinQwerty |
|
157 * Chinese Zhuyin input for qwerty keyboard. |
|
158 * |
|
159 * EPtiEngineZhuyinPhraseQwerty |
|
160 * Chinese Zinyin phrase input for qwerty keyboard. This is same as EPtiEngineZhuyinQwerty, |
|
161 * execpt that input string may contain zhuyin sequences for several chinese characters. |
|
162 * |
|
163 * EPtiEnginePinyinQwerty |
|
164 * Chinese Pinyin input for qwerty keyboard. |
|
165 * |
|
166 * PtiEnginePinyinPhraseQwerty |
|
167 * Same as EPtiEnginePinyinByPhrase but for qwerty keyboard |
|
168 * |
|
169 * EPtiEngineStrokeQwerty |
|
170 * Same as EPtiEngineStroke but for qwerty keyboard |
|
171 * |
|
172 * EPtiEngineNormalCangjieQwerty |
|
173 * Normal Chinese CangJie input for qwerty keyboard |
|
174 * (CangJie is available only for qwerty). |
|
175 * |
|
176 * EPtiEngineEasyCangjieQwerty |
|
177 * Easy Chinese CangJie input for qwerty keyboard |
|
178 * (CangJie is available only for qwerty). |
|
179 * |
|
180 * EPtiEngineAdvCangjieQwerty |
|
181 * Advanced Chinese CangJie input for qwerty keyboard |
|
182 * (CangJie is available only for qwerty). |
|
183 * |
|
184 * EPtiEngineHiraganaKanjiQwerty |
|
185 * Japanese Hiragana/Kanji input for qwerty keyboard. |
|
186 * |
|
187 * EPtiEngineHiraganaKanjiPredictiveQwerty |
|
188 * Japanese predictive Hiragana/Kanji input for qwerty keyboard |
|
189 * |
|
190 * EPtiEngineKatakanaQwerty |
|
191 * Japanese Half-width Katakana input for qwerty keyboard. |
|
192 * |
|
193 * EPtiEngineFullWidthKatakanaQwerty |
|
194 * Japanese Full-width Katakana input for qwerty keyboard. |
|
195 * |
|
196 * EPtiEngineFullWidthNumericQwerty |
|
197 * Japanese Full-width Alphabet input for qwerty keyboard. |
|
198 * |
|
199 * EPtiEngineFullWidthAlphabetQwerty |
|
200 * Japanese Full-width Alphabet input for qwerty keyboard. |
|
201 * |
|
202 * EPtiEngineHiraganaQwerty |
|
203 * Japanese Hiragana input for qwerty keyboard. |
|
204 * |
|
205 * EPtiEngineStrokeByPhrase, // Stroke phrase input. |
|
206 * Chinese Stroke input for ITU-T keypad. Phrasal version. |
|
207 * |
|
208 * EPtiEngineStrokePhraseQwerty |
|
209 * Chinese Stroke input for qwerty keyboard. Phrasal version. |
|
210 * |
|
211 * EPtiEngineQwertyPredictive, // "Sloppy type" input for qwerty keyboard. |
|
212 * Intelligent qwerty input. Used for word completion and spell |
|
213 * correction features for qwerty keyboard. |
|
214 * |
|
215 * EPtiEngineHalfQwerty |
|
216 * Basic multitaping style text input for half-qwerty keyboard. The functionality |
|
217 * of half-qwerty keyboard is same as conventional itu-t phone keypad, except that |
|
218 * each key is associated with two basic characters (instead of three or four |
|
219 * as in itu-t keypad). Character mapping is also organized to follow qwerty |
|
220 * layout (instead of alphabetical order as in itu-t keypad). |
|
221 * |
|
222 * EPtiEngineHalfQwertyPredictive, |
|
223 * Predictive text input for half-qwerty keyboard. The functionality |
|
224 * of half-qwerty keyboard is same as conventional itu-t phone keypad, except that |
|
225 * each key is associated with two basic characters(instead of three or four |
|
226 * as in itu-t keypad). . Character mapping is also organized to follow qwerty |
|
227 * layout (instead of alphabetical order as in itu-t keypad). This input mode |
|
228 * is essentially same as EPtiEngineWordCompletion but uses half-qwerty keyboard. |
|
229 * |
|
230 * EPtiEngineInputModeIndicPhoneticMultitap |
|
231 * Hindi phonetic input for itu-t keypad. |
|
232 * |
|
233 * EPtiEngineInputModeIndicPhoneticQwerty |
|
234 * Hindi phonetic input for qwerty keyboard. |
|
235 * |
|
236 * EPtiEngineInputModeZhuyinMiniQwertyFind |
|
237 * Zhuyin multitap input method for mini qwerty symbol find. |
|
238 * |
|
239 */ |
|
240 enum TPtiEngineInputMode |
|
241 { |
|
242 EPtiEngineInputModeNone = 0, |
|
243 EPtiEngineMultitapping, // Basic multitapping input for latin languages. |
|
244 EPtiEnginePredictive, // Predictive input for latin languages. |
|
245 EPtiEngineWordCompletion, // Predictive input with word completion for latin languages. |
|
246 EPtiEngineNumeric, // Latin numeric input mode. |
|
247 EPtiEngineQwerty, // Basic qwerty input mode. |
|
248 EPtiEnginePinyin, // Chinese pinyin mode. |
|
249 EPtiEngineStroke, // Chinese stroke mode. |
|
250 EPtiEngineZhuyin, // Chinese zhuyin mode. |
|
251 EPtiEngineHiraganaKanji, // Hiragana/Kanji mode. |
|
252 EPtiEngineHiraganaKanjiPredictive, // Predictive Hiragana/Kanji mode. |
|
253 EPtiEngineKatakana, // Half-width Katakana mode. |
|
254 EPtiEngineFullWidthKatakana, // Full-width Katakana mode. |
|
255 EPtiEngineFullWidthNumeric, // Full-width Alphabet mode (for Japanese input). |
|
256 EPtiEngineFullWidthAlphabet, // Full-width Alphabet mode (for Japanese input). |
|
257 EPtiEngineHiragana, // Hiragana only mode. |
|
258 EPtiEnginePinyinByPhrase, // Pinyin phrase input. |
|
259 EPtiEngineZhuyinByPhrase, // Zhuyin phrase input. |
|
260 EPtiEngineZhuyinQwerty, // Zhuyin qwerty input. |
|
261 EPtiEngineZhuyinPhraseQwerty, // Zhuyin phrase qwerty input. |
|
262 EPtiEnginePinyinQwerty, // Pinyin qwerty input. |
|
263 EPtiEnginePinyinPhraseQwerty, // Pinyin phrase qwerty input. |
|
264 EPtiEngineStrokeQwerty, // Stroke qwerty input. |
|
265 EPtiEngineNormalCangjieQwerty, // Normal Cangjie qwerty input |
|
266 EPtiEngineEasyCangjieQwerty, // Easy Cangjie qwerty input |
|
267 EPtiEngineAdvCangjieQwerty, // Advanced Cangjie qwerty input |
|
268 EPtiEngineHiraganaKanjiQwerty, // Hiragana/Kanji qwerty input mode. |
|
269 EPtiEngineHiraganaKanjiPredictiveQwerty, // Predictive Hiragana/Kanji qwerty input mode. |
|
270 EPtiEngineKatakanaQwerty, // Half-width Katakana qwerty input mode. |
|
271 EPtiEngineFullWidthKatakanaQwerty, // Full-width Katakana qwerty input mode. |
|
272 EPtiEngineFullWidthNumericQwerty, // Full-width Alphabet qwerty input mode (for Japanese input). |
|
273 EPtiEngineFullWidthAlphabetQwerty, // Full-width Alphabet qwerty input mode (for Japanese input). |
|
274 EPtiEngineHiraganaQwerty, // Hiragana only qwerty input mode. |
|
275 EPtiEnginePinyinVkb, // Chinese pinyin mode. |
|
276 EPtiEngineStrokeVkb, // Chinese stroke mode. |
|
277 EPtiEngineZhuyinVkb, // Chinese zhuyin mode. |
|
278 EPtiEngineStrokeByPhrase, // Stroke phrase input. |
|
279 EPtiEngineStrokePhraseQwerty, // Stroke phrase qwerty input. |
|
280 EPtiEngineHiraganaKanjiVkb, // Hiragana/Kanji mode for VKB. |
|
281 EPtiEngineHiraganaKanjiPredictiveVkb, // Predictive Hiragana/Kanji mode for VKB. |
|
282 EPtiEngineHiraganaKanjiHwr, // Hiragana/Kanji mode for HWR. |
|
283 EPtiEngineHiraganaKanjiPredictiveHwr, // Predictive Hiragana/Kanji mode for HWR. |
|
284 EPtiEngineKatakanaVkb, // Half-width Katakana mode for VKB. |
|
285 EPtiEngineFullWidthKatakanaVkb, // Full-width Katakana mode for VKB. |
|
286 EPtiEngineHiraganaVkb, // Hiragana only qwerty input mode for VKB. |
|
287 EPtiEngineNormalCangjieVkb, |
|
288 EPtiEngineEasyCangjieVkb, |
|
289 EPtiEngineAdvCangjieVkb, |
|
290 EPtiEngineInputModeIndicPhoneticMultitap, |
|
291 EPtiEngineInputModeIndicPhoneticQwerty, |
|
292 EPtiEngineHiraganaKanjiVkbRomaji, // Hiragana/Kanji mode for VKB/FSQ Romaji input. |
|
293 EPtiEngineHiraganaKanjiPredictiveVkbRomaji, // Predictive Hiragana/Kanji mode for VKB/FSQ Romaji input. |
|
294 EPtiEngineQwertyPredictive, // "Sloppy type" input for qwerty keyboard. |
|
295 EPtiEngineHalfQwerty, |
|
296 EPtiEngineHalfQwertyPredictive, |
|
297 EPtiEngineInputModeQwertyPredictive , |
|
298 EPtiEngineInputModeZhuyinMiniQwertyFind, |
|
299 EPtiEnginePinyinPhraseHalfQwerty, |
|
300 EPtiEngineStrokePhraseHalfQwerty, |
|
301 EPtiEngineZhuyinPhraseHalfQwerty, |
|
302 EPtiEngineMultitappingKorean, // Basic multitapping input for korean language. |
|
303 EPtiEngineQwertyKorean, |
|
304 EPtiEngineMaxInputModes = EPtiEngineQwertyKorean |
|
305 }; |
|
306 |
|
307 |
|
308 /* |
|
309 * Predictive qwerty error correction levels. |
|
310 */ |
|
311 enum TPtiErrorCorrectionLevel |
|
312 { |
|
313 EPtiErrorCorrectionLevelOff = 0, |
|
314 EPtiErrorCorrectionLevelLow = 1, |
|
315 EPtiErrorCorrectionLevelHigh = 2 |
|
316 }; |
|
317 |
|
318 |
|
319 /** |
|
320 * Key enumerations for conventional (ITU-T) and qwerty keyboards. |
|
321 * Constant names for qwerty keypad keys are named after scan code |
|
322 * values of a device using English language keymappings. The |
|
323 * actual character that will be inserted into editor buffer depends on |
|
324 * keymappings of currently selected input language and may be something else |
|
325 * than what enum name suggests. For example |
|
326 * non-shifted EPtiKeyQwertyHash produces '#'-character if input language is |
|
327 * English, but will produce '+'-character if |
|
328 * input language is Danish, Norwegian, Swedish or Finnish. |
|
329 * The key coordinates on standard 4x12 qwerty keypad are given in |
|
330 * comments. |
|
331 */ |
|
332 enum TPtiKey |
|
333 { |
|
334 EPtiKeyNone = 0, |
|
335 |
|
336 EPtiKey1 = '1', |
|
337 EPtiKey2 = '2', |
|
338 EPtiKey3 = '3', |
|
339 EPtiKey4 = '4', |
|
340 EPtiKey5 = '5', |
|
341 EPtiKey6 = '6', |
|
342 EPtiKey7 = '7', |
|
343 EPtiKey8 = '8', |
|
344 EPtiKey9 = '9', |
|
345 EPtiKeyStar = '*', |
|
346 EPtiKey0 = '0', |
|
347 EPtiKeyHash = '#', |
|
348 |
|
349 // alternate names |
|
350 EPtiKeyPunct = EPtiKey1, |
|
351 EPtiKeyABC = EPtiKey2, |
|
352 EPtiKeyDEF = EPtiKey3, |
|
353 EPtiKeyGHI = EPtiKey4, |
|
354 EPtiKeyJKL = EPtiKey5, |
|
355 EPtiKeyMNO = EPtiKey6, |
|
356 EPtiKeyPQRS = EPtiKey7, |
|
357 EPtiKeyTUV = EPtiKey8, |
|
358 EPtiKeyWXYZ = EPtiKey9, |
|
359 |
|
360 // qwerty keys |
|
361 EPtiKeyQwerty1 = 0x31, |
|
362 EPtiKeyQwerty2 = 0x32, |
|
363 EPtiKeyQwerty3 = 0x33, |
|
364 EPtiKeyQwerty4 = 0x34, |
|
365 EPtiKeyQwerty5 = 0x35, |
|
366 EPtiKeyQwerty6 = 0x36, |
|
367 EPtiKeyQwerty7 = 0x37, |
|
368 EPtiKeyQwerty8 = 0x38, |
|
369 EPtiKeyQwerty9 = 0x39, |
|
370 EPtiKeyQwerty0 = 0x30, |
|
371 |
|
372 EPtiKeyQwertyPlus = 0x2b, |
|
373 EPtiKeyQwertyMinus = EStdKeyMinus, |
|
374 EPtiKeyQwertyComma = EStdKeyComma, |
|
375 EPtiKeyQwertySemicolon = EStdKeySemiColon, |
|
376 EPtiKeyQwertyFullstop = EStdKeyFullStop, |
|
377 EPtiKeyQwertyHash = EStdKeyHash, |
|
378 EPtiKeyQwertySlash = EStdKeyForwardSlash, |
|
379 EPtiKeyQwertyApostrophe = EStdKeySingleQuote, |
|
380 EPtiKeyQwertySpace = EStdKeySpace, |
|
381 EPtiKeyQwertyAtCharacter = EStdKeySquareBracketRight, |
|
382 EPtiKeyQwertyLeftShift = EStdKeyLeftShift, // Needed only for special cases. |
|
383 |
|
384 EPtiKeyQwertyA = 0x41, |
|
385 EPtiKeyQwertyB = 0x42, |
|
386 EPtiKeyQwertyC = 0x43, |
|
387 EPtiKeyQwertyD = 0x44, |
|
388 EPtiKeyQwertyE = 0x45, |
|
389 EPtiKeyQwertyF = 0x46, |
|
390 EPtiKeyQwertyG = 0x47, |
|
391 EPtiKeyQwertyH = 0x48, |
|
392 EPtiKeyQwertyI = 0x49, |
|
393 EPtiKeyQwertyJ = 0x4a, |
|
394 EPtiKeyQwertyK = 0x4b, |
|
395 EPtiKeyQwertyL = 0x4c, |
|
396 EPtiKeyQwertyM = 0x4d, |
|
397 EPtiKeyQwertyN = 0x4e, |
|
398 EPtiKeyQwertyO = 0x4f, |
|
399 EPtiKeyQwertyP = 0x50, |
|
400 EPtiKeyQwertyQ = 0x51, |
|
401 EPtiKeyQwertyR = 0x52, |
|
402 EPtiKeyQwertyS = 0x53, |
|
403 EPtiKeyQwertyT = 0x54, |
|
404 EPtiKeyQwertyU = 0x55, |
|
405 EPtiKeyQwertyV = 0x56, |
|
406 EPtiKeyQwertyW = 0x57, |
|
407 EPtiKeyQwertyX = 0x58, |
|
408 EPtiKeyQwertyY = 0x59, |
|
409 EPtiKeyQwertyZ = 0x5a |
|
410 |
|
411 // ----> Half Qwerty |
|
412 , EPtiKeyQwertyChr = EStdKeyLeftFunc // key (4, 4) |
|
413 // Half Qwerty <---- |
|
414 }; |
|
415 |
|
416 |
|
417 |
|
418 /** |
|
419 * Enumerations for PtiCore capabilities. These can be queries through |
|
420 * MPtiCoreInfo::CapsBits(). |
|
421 * Here are descriptions: |
|
422 * |
|
423 * EWordCompletion |
|
424 * The core object supports word completion -feature. |
|
425 * |
|
426 * EReordering |
|
427 * The core object supports user dictionary reordering. This feature means that |
|
428 * most commonly used words are moved up in prediction candidate |
|
429 * list. |
|
430 * |
|
431 * ENextWordPrediction |
|
432 * The core supports next word prediction feature. When this feature is |
|
433 * enabled, prediction engine tries to guess next word based on previous word(s). |
|
434 * |
|
435 * ESupportUserDictionaries |
|
436 * The core supports supports user dictionaries. |
|
437 * |
|
438 * ESupportSCTToneMarks |
|
439 * |
|
440 * ESupportCangjieInput |
|
441 * The core object supports Chinese CangJie input. |
|
442 * |
|
443 * ESupportDualLanguage |
|
444 * The core object supports dual language preditcion. |
|
445 * |
|
446 * ESupportAutoSubstitution |
|
447 * The core object supports auto-substitution feature. This feature |
|
448 * automatically expands predefined string to longer string. |
|
449 * ie. "l8r" -> "later" |
|
450 */ |
|
451 enum TPtiEngineCapsBits |
|
452 { |
|
453 EWordCompletion = 0x01, |
|
454 EReordering = 0x02, |
|
455 ENextWordPrediction = 0x04, |
|
456 ESupportUserDictionaries = 0x08, |
|
457 ESupportSCTToneMarks = 0x10, |
|
458 ESupportCangjieInput = 0x20, |
|
459 EPreferedSpelling = 0x40, |
|
460 ESupportDualLanguage = 0x80, |
|
461 ESupportAutoSubstitution = 0x100 |
|
462 }; |
|
463 |
|
464 |
|
465 /** |
|
466 * Text case defintions. |
|
467 */ |
|
468 enum TPtiTextCase |
|
469 { |
|
470 EPtiCaseLower = 0, // Normal lower case input |
|
471 EPtiCaseUpper, // Normal upper case input. |
|
472 EPtiCaseChrLower, // Qwerty chr-key lower case input. |
|
473 EPtiCaseChrUpper, // Qwerty chr-key upper case input. |
|
474 EPtiCaseFnLower, // Qwerty fn-key lower case input. |
|
475 EPtiCaseFnUpper, // Qwerty fn-key upper case input. |
|
476 EPtiCaseMax |
|
477 }; |
|
478 |
|
479 |
|
480 enum TPtiCharConversion |
|
481 { |
|
482 EPtiSimplifiedToComplex = 0x01, // Chinese simplified to Chinese complex |
|
483 EPtiUcs2ToUtf8 = 0x02, // Unicode to utf8 |
|
484 EPtiUcs2ToBig5 = 0x04, // Unicode to big5 |
|
485 EPtiUcs2ToGB = 0x08, // Unicode to Guo-Biao |
|
486 EPtiUtf8ToUcs2 = 0x10, // Utf8 to Unicode |
|
487 EPtiKo2ToWc = 0x20, // KSC5601 to Hangul Syllable |
|
488 EPtiWcToKo2 = 0x30, // Hangul Syllable to KSC5601 |
|
489 EPtiBig5ToUcs2 = 0x40, // Big5 to Unicode |
|
490 EPtiComplexToSimplified = 0x80 // Chinese complex to Chinese simplified |
|
491 }; |
|
492 |
|
493 /** |
|
494 * Enumerates supported spelling types for CPtiEngine::GetSpelling method. |
|
495 */ |
|
496 enum TPtiSpelling |
|
497 { |
|
498 EPtiStrokes = 0x01, |
|
499 EPtiPinyin = 0x02, |
|
500 EPtiBopomofo = 0x04, |
|
501 EPtiZhuyin = 0x08, |
|
502 EPtiCangJie = 0x16, |
|
503 EPtiEasyCangjie = 0x20, |
|
504 EPtiAdvCangjie = 0x40 |
|
505 }; |
|
506 |
|
507 /** |
|
508 * Enumerates different Chinese variants. |
|
509 */ |
|
510 enum TPtiChineseVariant |
|
511 { |
|
512 EPtiChineseVariantPrc = 0, |
|
513 EPtiChineseVariantHk, |
|
514 EPtiChineseVariantTw |
|
515 }; |
|
516 |
|
517 /** |
|
518 * Command definitions for CPtiEngine::HandleCommandL api methods. Many of these |
|
519 * are for internal communication between PtiEngine framework and a specific |
|
520 * core object and there for not documented. |
|
521 */ |
|
522 enum TPtiEngineCommand |
|
523 { |
|
524 EPtiCommandNone, |
|
525 EPtiCommandUserActionLeft, |
|
526 EPtiCommandUserActionRight, |
|
527 EPtiCommandUserActionConvert, |
|
528 EPtiCommandUserActionPrevious, |
|
529 EPtiCommandUserActionLengthen, |
|
530 EPtiCommandUserActionShorten, |
|
531 EPtiCommandUserActionCancel, |
|
532 EPtiCommandUserActionComplete, |
|
533 EPtiCommandUserActionAllComplete, |
|
534 EPtiCommandUserActionGetCurrentIndexOfCandidates, |
|
535 EPtiCommandUserActionCompleteCandidate, |
|
536 EPtiCommandUserActionCompleteFull0, |
|
537 EPtiCommandUserActionCompleteFull1, |
|
538 EPtiCommandUserActionCompleteFull2, |
|
539 EPtiCommandUserActionCompleteFull3, |
|
540 EPtiCommandUserActionCompleteFull4, |
|
541 EPtiCommandUserActionCompleteFull5, |
|
542 EPtiCommandUserActionCompleteFull6, |
|
543 EPtiCommandUserActionCompleteFull7, |
|
544 EPtiCommandUserActionCompleteFull8, |
|
545 EPtiCommandUserActionCompleteFull9, |
|
546 EPtiCommandUserActionCompleteHalf0, |
|
547 EPtiCommandUserActionCompleteHalf1, |
|
548 EPtiCommandUserActionCompleteHalf2, |
|
549 EPtiCommandUserActionCompleteHalf3, |
|
550 EPtiCommandUserActionCompleteHalf4, |
|
551 EPtiCommandUserActionCompleteHalf5, |
|
552 EPtiCommandUserActionCompleteHalf6, |
|
553 EPtiCommandUserActionCompleteHalf7, |
|
554 EPtiCommandUserActionCompleteHalf8, |
|
555 EPtiCommandUserActionCompleteHalf9, |
|
556 EPtiCommandEnableToneMarks, |
|
557 EPtiCommandDisableToneMarks, |
|
558 EPtiCommandResetToneMark, |
|
559 EPtiCommandIncrementToneMark, |
|
560 EPtiCommandIncrementToneMarkOverrideInvalid, |
|
561 EPtiCommandReloadLearningInfo, |
|
562 EPtiCommandUserDictionaryDelaySaving, |
|
563 EPtiCommandUserDictionarySaveNow, |
|
564 EPtiCommandUserActionSetCurrentIndexOfCandidates, |
|
565 EPtiCommandUseLatinDefaultKeyMap, |
|
566 EPtiCommandUseLatinCaseUpperOnlyKeyMap, |
|
567 EPtiCommandUseLatinCaseLowerOnlyKeyMap, |
|
568 EPtiCommandResetLearningInfo, |
|
569 EPtiCommandPollQwertyDeadKeyRootFlag, // Indicates that dead key root char was added to buffer. |
|
570 EPtiCommandGetAndClearDeadKeyRootChar, |
|
571 EPtiCommandDeadKeyWaiting, |
|
572 EPtiCommandQueryAndClearGetAllFlag, |
|
573 EPtiCommandGetAndClearVowelSequence, |
|
574 EPtiCommandSetMultitapTimer, // Set multitap timer for japanese varint only |
|
575 EPtiCommandVowelSeqFlag, |
|
576 EPtiCommandClearVowelSeq, |
|
577 EPtiCommandSetJapaneseQwertyFlags, // Set Japanese Qwerty flags for japanese varint only |
|
578 EPtiCommandGetAndClearLastVietnameseChar, |
|
579 EPtiCommandSetVietnameseLastChar, |
|
580 EPtiCommandQueryReplacePrevious, |
|
581 EPtiCommandSetLastKeyForVietnamese, |
|
582 EPtiCommandResetVietnameseVowelSeqAndToneMark, |
|
583 EPtiCommandGetVietnameseLastKey, |
|
584 EPtiCommandDoubleWideEntry, |
|
585 EPtiCommandSetClearFunction, // Set the behavior of clear key for japanese varint only |
|
586 EPtiCommandUserActionRetroActiveCandidateHalf, |
|
587 EPtiCommandUserActionRetroActiveCandidateFull, |
|
588 EPtiCommandUserActionRetroActiveClear, |
|
589 EPtiCommandUserActionRetroActiveCommit, |
|
590 EPtiCommandAppendCharacter, // Append a character for Japanese varint only |
|
591 EPtiCommandBackSpaceByForce, // BackSpace by force for Japanese varint only |
|
592 EPtiCommandGetPhoneticText, |
|
593 EPtiCommandClearPhoneticBuffer, |
|
594 EPtiCommandBreakSyllable, |
|
595 EPtiCommandAllowPictographCandidate, // Allow the candidates with pictograph cahracter for Japanese variant only |
|
596 EPtiCommandLoopback, // Loop back input character (Loop back: c->b->a) |
|
597 EPtiCommandSetAutoSubstitution, |
|
598 EPtiCommandAddAutoSubstEntry, // TPtiAutoSubstBinding passed in aParams. |
|
599 EPtiCommandDeleteAutoSubstEntry, // TPtiAutoSubstBinding passed in aParams. |
|
600 EPtiCommandNumberOfAutoSubstEntries, |
|
601 EPtiCommandGetAutoSubstEntry, // TPtiAutoSubstBinding passed in aParams. |
|
602 EPtiCommandFindAutoSubstEntry, // TPtiAutoSubstBinding* passed in aParams. |
|
603 EPtiCommandUncommitWord, |
|
604 EPtiCommandEnableAutoCompletion, |
|
605 EPtiCommandDisableAutoCompletion, |
|
606 EPtiCommandSetCorrectionLevel, // TErrorCorrectionLevel* passed in aParams. |
|
607 EPtiCommandGetAutoCompletionTailLength, // TInt* passed in aParams for output. |
|
608 EPtiCommandLockCurrentCandidate, |
|
609 EPtiCommandSetProactiveCorrection, // TBool passed in aParams |
|
610 EPtiCommandIsExactKnownWord, |
|
611 EPtiCommandSetAutoCompletion, |
|
612 EPtiCommandSetNumberCandidateStatus, // |
|
613 EPtiCommandSetAutoCompletionMaxLength, // Param is integer. Sets maximum lenght of ato completed word. Zero == no limit. |
|
614 EPtiCommandMarkAutoCapitalized, // No parameters. |
|
615 EPtiCommandUserActionGetIndexOfSecondaryCandidate, // index of secondary candidate, TInt* passed in param |
|
616 EPtiCommandAddPhrase, // Add new phrase for next word prediction. const TDesC* passed in param. |
|
617 EPtiCommandSetSecondaryInputLanguage, |
|
618 EPtiCommandSetFlagToUpdateCandidates, |
|
619 EPtiCommandSetCursorCrossedMaxLength, // sets when cursor crosses max words length in editor |
|
620 EPtiCommandResetCursorCrossedMaxLength, |
|
621 EPtiCommandUserActionSetIndexOfActiveCandidate, |
|
622 EPtiCommandAddWordToUDBWithoutPunctMark, |
|
623 EPtiCommandGetSecondaryCandidate, |
|
624 EPtiCommandAutoCompletionOnToOff //to signify that autocompletion is set from on to off in between typing |
|
625 }; |
|
626 |
|
627 /** |
|
628 * A convinience class for auto substitution related EPtiCommands. Needed |
|
629 * only in core object and framework code. |
|
630 */ |
|
631 class TPtiAutoSubstBinding |
|
632 { |
|
633 public: |
|
634 TInt iIndex; |
|
635 TBuf<KMaxAutoSubstStringLength> iShortcut; |
|
636 TBuf<KMaxAutoSubstStringLength> iSubstitution; |
|
637 }; |
|
638 |
|
639 |
|
640 /** |
|
641 * A structure for binding language name and language code. |
|
642 * only in core object and framework code. |
|
643 */ |
|
644 class TPtiLangName |
|
645 { |
|
646 public: |
|
647 TInt iLanguageCode; |
|
648 TBuf<KMaxLanguageNameLength> iName; |
|
649 }; |
|
650 |
|
651 |
|
652 /** |
|
653 * This is language code for 'numeric' language. |
|
654 * It is langugae object which is always available and |
|
655 * has only numeric input mode. |
|
656 */ |
|
657 #define ELangNumeric 0x5000 |
|
658 |
|
659 /** |
|
660 * An interface class for accessing core info attributes. |
|
661 */ |
|
662 class MPtiCoreInfo |
|
663 { |
|
664 public: |
|
665 /** |
|
666 * Returns a boolean value indicating whether the word completion |
|
667 * feature is supported by the core object in question |
|
668 * |
|
669 * @since S60 V2.6 |
|
670 * @return ETrue if core object supports word completion feature. |
|
671 * EFalse otherwise. |
|
672 */ |
|
673 virtual TBool WordCompletion() const = 0; |
|
674 |
|
675 /** |
|
676 * Returns a boolean value indicating whether the user dictionary |
|
677 * re-ordering feature is supported by the core object in question. |
|
678 * |
|
679 * @since S60 V2.6 |
|
680 * @return ETrue if core object supports re-ordering feature. |
|
681 * EFalse otherwise. |
|
682 */ |
|
683 virtual TBool Reordering() const = 0; |
|
684 |
|
685 /** |
|
686 * Returns maximum length of single word this core object is able to produce. |
|
687 * |
|
688 * @since S60 V2.6 |
|
689 * @return The maximum word length. |
|
690 */ |
|
691 virtual TInt MaximumWordLength() const = 0; |
|
692 |
|
693 /** |
|
694 * Returns the maximum number of prediction candidates the core object |
|
695 * is able to produce for any input sequence. Doesn't apply for |
|
696 * Chinese and Japanese modes. |
|
697 * |
|
698 * @since S60 V2.6 |
|
699 * @return The maximum number of candidates. |
|
700 */ |
|
701 virtual TInt MaximumNumberOfCandidates() const = 0; |
|
702 |
|
703 /** |
|
704 * Returns a boolean value indicating whether the next word prediction feature |
|
705 * supported by the core object in question. |
|
706 * |
|
707 * @since S60 V2.6 |
|
708 * @return ETrue if next wrod prediction is supported. |
|
709 * EFalse otherwise. |
|
710 */ |
|
711 virtual TBool NextWordPrediction() const = 0; |
|
712 |
|
713 /** |
|
714 * Returns core object vendor specific id string. |
|
715 * |
|
716 * @since S60 V2.6 |
|
717 * @return Vendor specific id string. |
|
718 */ |
|
719 virtual TPtrC VendorString() const = 0; |
|
720 |
|
721 /** |
|
722 * Returns a bit vector containing flags for various core object features. |
|
723 * See TPtiEngineCapsBits for list of specified bits. |
|
724 * |
|
725 * @since S60 V2.6 |
|
726 * @return A bit vector containing flags for various core object features. |
|
727 */ |
|
728 virtual TUint32 CapsBits() const = 0; |
|
729 |
|
730 /** |
|
731 * Returns uid value for core object. |
|
732 * |
|
733 * @since S60 V2.6 |
|
734 * @return Core object uid as an integer value. |
|
735 */ |
|
736 virtual TInt32 Uid() const = 0; |
|
737 |
|
738 /** |
|
739 * Returns a bitvector containing flags for available character conversion |
|
740 * methods. See TPtiCharConversion for list of specified bits. |
|
741 * |
|
742 * @since S60 V2.6 |
|
743 * @return A bit vector containing flags for available character conversions. |
|
744 */ |
|
745 virtual TUint32 CharConversions() const = 0; |
|
746 |
|
747 /** |
|
748 * Returns a bitvector containing flags for available spelling conversion |
|
749 * methods. See TPtiSpelling for list of specified bits. |
|
750 * |
|
751 * @since S60 V2.6 |
|
752 * @return A bit vector containing flags for available spelling conversions. |
|
753 */ |
|
754 virtual TUint32 Spellings() const = 0; |
|
755 }; |
|
756 |
|
757 |
|
758 class TPtiCoreInfo : public MPtiCoreInfo |
|
759 { |
|
760 public: |
|
761 inline TBool WordCompletion() const; |
|
762 inline TBool Reordering() const; |
|
763 inline TInt MaximumWordLength() const; |
|
764 inline TInt MaximumNumberOfCandidates() const; |
|
765 inline TBool NextWordPrediction() const; |
|
766 inline TPtrC VendorString() const; |
|
767 inline TInt32 Uid() const; |
|
768 inline TUint32 CharConversions() const; |
|
769 inline TUint32 Spellings() const; |
|
770 |
|
771 inline TUint32 CapsBits() const; |
|
772 inline void SetCapsBits(TUint32 aBits); |
|
773 inline void SetVendorString(const TDesC& aStr); |
|
774 inline void SetMaxWordLength(TInt aMaxLen); |
|
775 inline void SetUid(TInt32 aUid); |
|
776 inline void SetSpellings(TUint32 aSpellings); |
|
777 inline void SetMaxNumberOfCandidates(TInt aMax); |
|
778 inline void SetCharConversions(TUint32 aConvs); |
|
779 |
|
780 private: |
|
781 TUint32 iCapsBits; |
|
782 TPtrC iVendorIdStr; |
|
783 TInt iMaxWordLength; |
|
784 TInt iMaxNumberOfCandidates; |
|
785 TInt32 iUid; |
|
786 TUint32 iCharConversions; |
|
787 TUint32 iSpellings; |
|
788 }; |
|
789 |
|
790 |
|
791 #define KPtiEngineChineseSeparator 0x0027 |
|
792 |
|
793 // Tone marks for pinyin input |
|
794 enum |
|
795 { |
|
796 KPtiPinyinTone0 = 0x02C9, |
|
797 KPtiPinyinTone1 = 0x02CA, |
|
798 KPtiPinyinTone2 = 0x02C7, |
|
799 KPtiPinyinTone3 = 0x02CB, |
|
800 KPtiPinyinTone4 = 0x02D9 |
|
801 }; |
|
802 |
|
803 // Tone marks for zhuyin input |
|
804 enum |
|
805 { |
|
806 KPtiZhuyinTone0 = 0x0020, |
|
807 KPtiZhuyinTone1 = 0x02CA, |
|
808 KPtiZhuyinTone2 = 0x02C7, |
|
809 KPtiZhuyinTone3 = 0x02CB, |
|
810 KPtiZhuyinTone4 = 0x02D9 |
|
811 }; |
|
812 |
|
813 |
|
814 class TPtiNumericKeyBinding |
|
815 { |
|
816 public: |
|
817 TUint16 iChar; |
|
818 TPtiKey iKey; |
|
819 TPtiTextCase iCase; |
|
820 }; |
|
821 |
|
822 |
|
823 // type definition for HWR |
|
824 typedef struct TRecognitionRangeTag |
|
825 { |
|
826 TLanguage iLanguage; |
|
827 TUint iSubRange; |
|
828 } TRecognitionRange; |
|
829 |
|
830 |
|
831 enum TRecognitionSubRanges |
|
832 { |
|
833 EPtiRangePRCChinese, |
|
834 EPtiRangeHKChinese, |
|
835 EPtiRangeTWChinese, |
|
836 EPtiRangeLatin, |
|
837 EPtiRangeSymbol, |
|
838 EPtiRangeNumber, |
|
839 EPtiRangeNative, // native text of a language, EPtiRangeLatin also belong to it |
|
840 EPtiRangeHiraganaKanji, |
|
841 EPtiRangeKatakana, |
|
842 EPtiRangeFullWidthKatakana, |
|
843 EPtiRangeFullWidthEnglish, |
|
844 EPtiRangeFullWidthNumeric, |
|
845 EPtiRangeHiraganaOnly, |
|
846 EPtiRangeNativeNumber, |
|
847 EPtiRangeNone |
|
848 }; |
|
849 |
|
850 |
|
851 enum TLatinLetterOrder |
|
852 { |
|
853 EUpperFirst, |
|
854 ELowerFirst |
|
855 }; |
|
856 |
|
857 /* |
|
858 * List of supported keyboard types. Each of these keyboard types |
|
859 * may have own data block in keyboard data file. |
|
860 */ |
|
861 enum TPtiKeyboardType |
|
862 { |
|
863 EPtiKeyboardNone, |
|
864 |
|
865 /** |
|
866 * Conventional 12 phone keypad |
|
867 */ |
|
868 EPtiKeyboard12Key, |
|
869 |
|
870 /** |
|
871 * 4x12 Qwerty keyboard. |
|
872 */ |
|
873 EPtiKeyboardQwerty4x12, |
|
874 |
|
875 /** |
|
876 * 4x10 Qwerty keyboard. |
|
877 */ |
|
878 EPtiKeyboardQwerty4x10, |
|
879 |
|
880 /** |
|
881 * 3x11 Qwerty keyboard. |
|
882 */ |
|
883 EPtiKeyboardQwerty3x11, |
|
884 |
|
885 /** |
|
886 * Half qwerty. |
|
887 */ |
|
888 EPtiKeyboardHalfQwerty, |
|
889 |
|
890 /** |
|
891 * Custom qwerty keyboard. |
|
892 * Bound to [KEYBOARD BLOCK QWERTY CUSTOM] in keymapping |
|
893 * definition files. |
|
894 */ |
|
895 EPtiKeyboardCustomQwerty, |
|
896 |
|
897 EPtiKeyboardMaxLayout |
|
898 }; |
|
899 |
|
900 #include "PtiDefs.inl" |
|
901 |
|
902 #endif // _PTI_DEFS_H |
|
903 |
|
904 // End od file |