1 /* |
|
2 * Copyright (c) 2002-2004 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: |
|
15 * Provides the MAknFepManagerUIInterface definition. |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
|
28 |
|
29 |
|
30 #ifndef __AKN_FEP_MANAGER_UI_INTERFACE_H__ |
|
31 #define __AKN_FEP_MANAGER_UI_INTERFACE_H__ |
|
32 |
|
33 // INCLUDES |
|
34 #include <e32std.h> |
|
35 |
|
36 #include <avkon.hrh> |
|
37 #include <frmtlay.h> // TCursorSelection |
|
38 #include <aknextendedinputcapabilities.h> |
|
39 #ifdef RD_INTELLIGENT_TEXT_INPUT |
|
40 #include <PtiDefs.h> |
|
41 #endif |
|
42 #include "AknFepGlobalEnums.h" |
|
43 #include "AknFepUiIndicEnums.h" |
|
44 |
|
45 #ifdef RD_INTELLIGENT_TEXT_INPUT |
|
46 #include "AknFepFnKeyManager.h" |
|
47 #endif |
|
48 // CLASS DECLARATION |
|
49 class CPtiEngine; |
|
50 class CAknFepUIInterface; |
|
51 class CAknFepPluginManager; |
|
52 // the follow 2 class for phrase creation |
|
53 class MZhuyinKeyHandler; |
|
54 class CAknFepZhuyinAnalyser; |
|
55 |
|
56 /** |
|
57 * This interface describes the FEP Manager functionality that is required by western |
|
58 * Input States only. It could potentially be conditionally compiled out if western |
|
59 * predictive text is not required in a product |
|
60 */ |
|
61 class MAknFepManagerUIInterfaceWestern |
|
62 { |
|
63 public: |
|
64 /* |
|
65 *flags, all held in the FEP Manager |
|
66 */ |
|
67 virtual TBool IsFlagSet(TInt aFlag) const = 0; |
|
68 virtual void SetFlag(TInt aFlag) = 0; |
|
69 virtual void ClearFlag(TInt aFlag) = 0; |
|
70 |
|
71 virtual void SetCcpuFlag(TInt aFlag) = 0; |
|
72 virtual void ClearCcpuFlag(TInt aFlag) = 0; |
|
73 |
|
74 /* |
|
75 * Update the current inline edit |
|
76 * @param aUncommitedTextChange, the change to the length of the inline edit |
|
77 * i.e. 1 is a character added, 0 is no change, -1 is a character deleted |
|
78 */ |
|
79 virtual void UpdateInlineEditL(const TDesC& aText, TInt aUncommitedTextChange) = 0; |
|
80 |
|
81 /* |
|
82 * Starts an inline edit |
|
83 */ |
|
84 virtual void StartInlineEditL() = 0; |
|
85 |
|
86 /* |
|
87 * Starts an inline edit with a text string to uncommit |
|
88 */ |
|
89 virtual void StartInlineEditL(const TDesC& aText) = 0; |
|
90 |
|
91 /* |
|
92 */ |
|
93 virtual void StartInlineEditL(TCursorSelection aCursorSelection, |
|
94 const TDesC& aInitialInlineText, |
|
95 TInt aPositionOfInsertionPointInInlineText, |
|
96 TBool aCursorVisibility) = 0; |
|
97 |
|
98 /* |
|
99 * Closes the UI backspace event have completely deleted a word |
|
100 */ |
|
101 virtual TBool CloseUiIfWordDeletedL() = 0; |
|
102 |
|
103 /* |
|
104 * gets the text to uncommit in the engine when moving onto a word |
|
105 * |
|
106 * @param aText the descriptor to fill with the text that should be uncommitted |
|
107 * @param aCode the keycode, must be backspace or left or right arrow |
|
108 * @param aComsumeKey ETrue if the key should be consumed |
|
109 * @return True if we have successfully found text which can be uncommited |
|
110 */ |
|
111 virtual TBool TryGetTextToUncommitL(TDes& aText, TInt aCode, TBool& aComsumeKey) = 0; |
|
112 |
|
113 /* |
|
114 * Update the CBA with a new resource |
|
115 */ |
|
116 virtual void UpdateCbaL(TInt aResourceId) = 0; |
|
117 |
|
118 /* |
|
119 * Remove the character that is used to show to the user that the |
|
120 * predictive text engine cannot match a word to the keys entered |
|
121 * @return ETrue if the No Matches Indicator has been removed, EFalse |
|
122 * if it was not there. |
|
123 */ |
|
124 virtual TBool TryRemoveNoMatchesIndicatorL() = 0; |
|
125 |
|
126 /* |
|
127 * @return ETrue if the new word length is one character longer than |
|
128 * the current uncommited text |
|
129 */ |
|
130 virtual TBool IsMoreGoodWordsComing(TInt aNewWordLength) const = 0; |
|
131 |
|
132 //the following 8 functions for creation |
|
133 /** |
|
134 * Set the state to Pinyin phrase creation |
|
135 */ |
|
136 virtual void PinyinPhraseCreation(TBool aPinyinPhraseCreation) = 0; |
|
137 |
|
138 /** |
|
139 * Is the state is in pinyin phrase creation |
|
140 * |
|
141 * @return if not enabled, return EFalse |
|
142 */ |
|
143 virtual TBool IsPinyinPhraseCreation() const = 0; |
|
144 |
|
145 /** |
|
146 * Set the state to phrase creation |
|
147 */ |
|
148 virtual void PhraseCreation(TBool aPhraseCreation) = 0; |
|
149 |
|
150 /** |
|
151 * Is the state is in phrase creation |
|
152 * |
|
153 * @return if not enabled, return EFalse |
|
154 */ |
|
155 virtual TBool IsPhraseCreation() const = 0; |
|
156 |
|
157 /** |
|
158 * Set the state to input phrase |
|
159 */ |
|
160 virtual void EntryPhrase(TBool aEntryPhrase) = 0; |
|
161 |
|
162 /** |
|
163 * Is the state is in input phrase |
|
164 * |
|
165 * @return if not enabled, return EFalse |
|
166 */ |
|
167 virtual TBool IsEntryPhrase() const = 0; |
|
168 |
|
169 /** |
|
170 * Set the state to enable star key |
|
171 */ |
|
172 virtual void EnableKeyStar(TBool aEnable) = 0; |
|
173 |
|
174 /** |
|
175 * Is the state is enable star key |
|
176 * |
|
177 * @return if not enabled, return EFalse |
|
178 */ |
|
179 virtual TBool IsEnableKeyStar() const = 0; |
|
180 #ifndef RD_INTELLIGENT_TEXT_INPUT |
|
181 /* |
|
182 * @return ETrue if inputmode is word completion and new word length is not equal to |
|
183 * the current inputsequence length |
|
184 */ |
|
185 virtual TBool IsMoreGoodAutoCompleteWordsComing(TInt aInputMode, TInt aPreviousWordLengh, |
|
186 TInt aNewWordLength) const =0; |
|
187 #endif // RD_INTELLIGENT_TEXT_INPUT |
|
188 |
|
189 /* |
|
190 * When starting a new word, checks the adjacent editor positions for |
|
191 * valid inline editing characters. If these are present, we are starting a |
|
192 * compound word and the flag EFlagCompoundWord is set |
|
193 */ |
|
194 virtual void TryStartCompoundWord() = 0; |
|
195 |
|
196 /* |
|
197 * Calculates the span of the compound word that is made up of the |
|
198 * current uncommitted text and the adjacent word. |
|
199 * Adds this word to the User Database |
|
200 */ |
|
201 virtual void AddCompoundWordToUdbL() = 0; |
|
202 |
|
203 /** |
|
204 * Sets delayed commit on (predicitve word will be commited in |
|
205 * next call to TryCloseUiL. This is needed because of Japanese ReadingTextL). |
|
206 * |
|
207 * @since 3.1 |
|
208 */ |
|
209 virtual void SetDelayedCommit() = 0; |
|
210 |
|
211 /** |
|
212 * Returns a boolean value indicating whether the curesor is at the end of a word. |
|
213 */ |
|
214 virtual TBool IsCursorAtEndOfWord() = 0; |
|
215 }; |
|
216 |
|
217 class MAknFepManagerUIInterface : public MAknFepManagerUIInterfaceWestern |
|
218 { |
|
219 public: |
|
220 #ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ |
|
221 #ifdef RD_INTELLIGENT_TEXT_INPUT |
|
222 virtual TBool KeyMapsDifferentCharacterWithFn( TPtiKey aKey ) const = 0; |
|
223 #endif |
|
224 #endif |
|
225 /** |
|
226 * Check western predictive mode. |
|
227 * @param aMode input mode. |
|
228 * @return ETrue if western predictive mode. |
|
229 */ |
|
230 virtual TBool WesternPredictive(TInt aMode = 0) const=0; |
|
231 /** |
|
232 * Check Qwerty keypad |
|
233 * |
|
234 * @since 3.0 |
|
235 * @return ETrue is Qwerty |
|
236 */ |
|
237 virtual TBool IsQwerty() const=0; |
|
238 #ifdef RD_INTELLIGENT_TEXT_INPUT |
|
239 /** |
|
240 * Launches the compact match candidate list which follows the inline editor. |
|
241 * @param aFocusedIndex The index of the word focused by default. |
|
242 * If KErrNotFound is given, the currently active |
|
243 * word will be focused. |
|
244 */ |
|
245 virtual void LaunchCandidatePopupListL( TInt aFocusedIndex = KErrNotFound )=0; |
|
246 /** |
|
247 Returns the Fn key state |
|
248 */ |
|
249 virtual CAknFepFnKeyManager::TFnKeyState FnKeyState() = 0; |
|
250 virtual void SetFnKeyState(CAknFepFnKeyManager::TFnKeyState aState) = 0; |
|
251 /** |
|
252 Returns the current keyboard layout in use. |
|
253 */ |
|
254 virtual TPtiKeyboardType KeyboardLayout() const = 0; |
|
255 #ifdef __REVERSE_FN_KEY_SUPPORTED |
|
256 /** |
|
257 Returns if the input is in reverse Fn key input mode. |
|
258 */ |
|
259 virtual TBool IsReverseFnkeyInput() = 0; |
|
260 |
|
261 /** |
|
262 * Returns true if the aChar is allowed in the numeric editor |
|
263 */ |
|
264 virtual TBool IsValidCharInNumericEditorL( TChar aChar ) const = 0; |
|
265 |
|
266 /** |
|
267 * Filter the char for Fn reverse mode in case of |
|
268 * numeric editor. This function should call |
|
269 * in case of numeric editor reverse mapping. |
|
270 */ |
|
271 virtual TBool IsValidCharForNumericInFnReverseL(TInt aKey, TPtiTextCase aCase)=0; |
|
272 |
|
273 #endif //__REVERSE_FN_KEY_SUPPORTED |
|
274 virtual void AddOneSpaceOrMoveCursorL() = 0; |
|
275 |
|
276 #endif |
|
277 virtual TBool IsHybridAplhaEditor() const = 0 ; |
|
278 virtual TBool IsHybridAlphaModeChangedtoAplhanumeric() const = 0; |
|
279 /** |
|
280 * Tells if the current editor is phone number editor |
|
281 * @return ETrue if the current editor is phone number editor |
|
282 */ |
|
283 virtual TBool IsPhoneNumberEditor() const = 0; |
|
284 |
|
285 /** |
|
286 * A request to close the UI. If the UI was not active (initial state) |
|
287 * multitap characters are commited by calling ExpireMultitapTimer() |
|
288 * on the ptiengine. |
|
289 * @return ETrue if the UI was active, EFalse otherwise |
|
290 */ |
|
291 virtual TBool TryCloseUiL() = 0; |
|
292 |
|
293 /** |
|
294 * A request to send a char to the editing window |
|
295 */ |
|
296 virtual void NewCharacterL(const TDesC& aChar) = 0; |
|
297 |
|
298 /** |
|
299 * A request to send text to the editing window |
|
300 */ |
|
301 virtual void NewTextL(const TDesC& aChar) = 0; |
|
302 |
|
303 /** |
|
304 * A request to commit the current char |
|
305 */ |
|
306 virtual void CommitInlineEditL() = 0; |
|
307 |
|
308 /** |
|
309 * Commits given string in the editing window. This function checks that |
|
310 * the editor has enough space to insert given string. If it not, |
|
311 * given string is cut, then it is committed. |
|
312 */ |
|
313 virtual void CommitInlineEditL(const TDesC& aText, TInt aUncommitedTextChange) = 0; |
|
314 |
|
315 /** |
|
316 * A request to cancel inline input to wditing window. |
|
317 */ |
|
318 virtual void CancelInlineEdit() =0; |
|
319 |
|
320 /** |
|
321 * Called by Fep Manager when editing window draws inline input characters. |
|
322 */ |
|
323 virtual void GetScreenCoordinatesL(TPoint& aLeftSideOfBaseLine,TInt& aHeight, |
|
324 TInt& aAscent,TInt aDocumentOffset) = 0; |
|
325 |
|
326 /** |
|
327 * Called by Fep Manager when Chinese UI ask cursor baseline position. |
|
328 */ |
|
329 virtual void GetScreenCoordinatesL(TPoint& aLeftSideOfBaseLine, |
|
330 TInt& aHeight,TInt& aAscent) = 0; |
|
331 |
|
332 /** |
|
333 * A notification to the Fep Manager that the UI has been activated.. |
|
334 * Should always be called by an Initial State Object when initiating |
|
335 * a change to an Entry State |
|
336 */ |
|
337 virtual void SendUIActivatedNotification() = 0; |
|
338 |
|
339 /** |
|
340 * A notification to the Fep Manager that the UI has not been activated. |
|
341 */ |
|
342 virtual void SendUIDeActivatedNotification() = 0; |
|
343 |
|
344 /** |
|
345 * calulates if an SCT can be launched in the current editor at the present |
|
346 * cursor position |
|
347 * @return ETrue if an SCT can be launched, EFalse if not |
|
348 */ |
|
349 virtual TBool IsAbleToLaunchSCT() const = 0; |
|
350 |
|
351 /** |
|
352 * Launch the Special Character Table |
|
353 */ |
|
354 virtual void LaunchSpecialCharacterTableL(TInt aResourceId=0, |
|
355 TBool aLaunchedByTouchWin=EFalse, |
|
356 TBool aSmileyFirst=EFalse) = 0; |
|
357 |
|
358 /** |
|
359 * Play sound |
|
360 */ |
|
361 virtual void PlaySound(TAvkonSystemSID aSound) const = 0; |
|
362 /** |
|
363 * get uncommitted text |
|
364 */ |
|
365 virtual TCursorSelection UncommittedText() const = 0; |
|
366 |
|
367 /** |
|
368 * Gets the previous character depnding on wheather language is |
|
369 * contxet sensitve or not |
|
370 * since 3.2: aContextSensitive not in use, since no real meaning found. |
|
371 */ |
|
372 virtual TText PreviousChar( TBool aContextSensitive = EFalse ) = 0; |
|
373 /** |
|
374 * Returns the next character to the current cursor position |
|
375 */ |
|
376 virtual TText NextChar() = 0; |
|
377 virtual TBool IsZWSCharacterPresent( TBool aLigaturePresent = EFalse ) = 0; |
|
378 /** |
|
379 * Removes previous character to the current cursor position |
|
380 */ |
|
381 virtual void RemovePreviousCharacterL() = 0; |
|
382 /** |
|
383 * Removes Zero Width Space character from the inputted text. |
|
384 */ |
|
385 virtual void RemoveZWSCharacterL(TBool aIsViramaInputted, |
|
386 TBool aIsInMultitappingHalant = EFalse, |
|
387 TBool aIsCharModifier = EFalse, |
|
388 TBool aIsLigaturePresent = EFalse) = 0; |
|
389 /** |
|
390 * Adds text to the editor and commits the text. |
|
391 */ |
|
392 virtual void NewCharacterSequenceL(const TDesC& aText, TIndicInputResponse aResponse) = 0; |
|
393 |
|
394 virtual TDigitType LocalDigit() = 0; |
|
395 virtual TWidthChar CharacterWidth() const = 0; |
|
396 virtual void SetInlineEditingCursorVisibilityL(TBool aCursorVisibility) = 0; |
|
397 virtual CPtiEngine* PtiEngine() const = 0; |
|
398 |
|
399 /** |
|
400 * checks that the editor the editor has free space to add another character |
|
401 * An editor of unlimited length will return its maximum size as zero |
|
402 */ |
|
403 virtual TBool EditorHasFreeSpace( TInt aNumberOfCharacter = 0 ) const = 0; |
|
404 |
|
405 virtual void RedecorateAfterDeletionL( const TDesC& aTextThatWasDeleted ) = 0; |
|
406 |
|
407 /** |
|
408 * |
|
409 * |
|
410 * @param aKeyCode the value of the key to simulate |
|
411 */ |
|
412 virtual void SimulateKeyEventL(TUint aKeyCode, TBool aActiveObj=EFalse) = 0; |
|
413 |
|
414 /** |
|
415 * Queries supportting of ScrollLatinPredictive feature |
|
416 * |
|
417 * @since 2.6 |
|
418 * @return ETrue if ScrollLatinPredictive was supported |
|
419 */ |
|
420 virtual TBool IsAbleScrollLatinPredictive() const = 0; |
|
421 |
|
422 virtual TBool IsOnlyNumericPermitted() const = 0; |
|
423 |
|
424 virtual TInt EditorNumericKeymap() const = 0; |
|
425 |
|
426 /** |
|
427 * Queries supportting of SecretText |
|
428 * |
|
429 * @since 2.6 |
|
430 * @return ETrue if SecretText was supported |
|
431 */ |
|
432 virtual TBool IsSupportsSecretText() const = 0; |
|
433 |
|
434 |
|
435 /** |
|
436 * Returns current input mode. |
|
437 * |
|
438 * @since 3.0 |
|
439 * @return Integer value indicating current editor input mode. |
|
440 */ |
|
441 virtual TInt InputMode() const = 0; |
|
442 |
|
443 /** |
|
444 * Returns current CangJie input mode. |
|
445 * |
|
446 * @since 3.0 |
|
447 * @return Integer value indicating current CangJie input mode. |
|
448 */ |
|
449 virtual TInt CangJieMode() const = 0; |
|
450 |
|
451 /** |
|
452 * Returns boolean value indicating whether edit submenu functionality is in use. |
|
453 * |
|
454 * @since 3.1 |
|
455 * @return ETrue if edit submenu functionality is in use. |
|
456 * EFalse otherwise. |
|
457 */ |
|
458 virtual TBool EditSubmenuInUse() const = 0; |
|
459 |
|
460 /** |
|
461 * Launches the mode selection menu |
|
462 * |
|
463 * @since 3.1 |
|
464 */ |
|
465 virtual void LaunchSelectModeMenuL() = 0; |
|
466 |
|
467 /** |
|
468 * @since 3.2 |
|
469 */ |
|
470 virtual void SetCursorSelectionL(const TCursorSelection& aCurSel, TBool aSyncCursor) = 0; |
|
471 |
|
472 /** |
|
473 * Returns the status of arabic-indic digit mode setting. |
|
474 * |
|
475 * @since 3.0 |
|
476 */ |
|
477 virtual TBool ArabicIndicDigitsInUse() const = 0; |
|
478 virtual TBool EasternArabicIndicDigitsInUse() const = 0; |
|
479 #ifndef RD_INTELLIGENT_TEXT_INPUT |
|
480 |
|
481 /** |
|
482 * Returns the status of auto word completion in the editor. |
|
483 * |
|
484 * @since 5.0 |
|
485 */ |
|
486 virtual TBool IsAutoCompleteOn() const = 0; |
|
487 |
|
488 /** |
|
489 * Removes the suggested completion part |
|
490 * |
|
491 * @since 5.0 |
|
492 */ |
|
493 virtual void RemoveSuggestedCompletionL() = 0; |
|
494 #endif // RD_INTELLIGENT_TEXT_INPUT |
|
495 /** |
|
496 * Set current long clear key press |
|
497 * |
|
498 * @since 3.2 |
|
499 */ |
|
500 virtual void SetLongClearAfterCloseUI(TBool aLongClear) = 0; |
|
501 |
|
502 /** |
|
503 * Align the Logical and Visual cursor positions. |
|
504 * |
|
505 * @since 3.2 |
|
506 * @param aType Cursor type. |
|
507 * @param aToLeft ETrue if the position to the left is to be found, |
|
508 * EFalse if the position to the right is to be found. |
|
509 * @return None |
|
510 */ |
|
511 virtual void AlignLogicalAndVisualCursorL( TTmDocPosSpec::TType aType, |
|
512 TBool aToLeft ) = 0; |
|
513 |
|
514 /** |
|
515 * This method is called for removing the Repha character. The function |
|
516 * goes to the start of the consonant or ligature, checks if repha |
|
517 * character is present. |
|
518 * |
|
519 * @since 3.2 |
|
520 * @param None. |
|
521 * @return None. |
|
522 */ |
|
523 virtual void RemoveRephaCharacterL() = 0; |
|
524 |
|
525 /** |
|
526 * Checks if the Repha character has been attached to the consonant or |
|
527 * ligature. |
|
528 * |
|
529 * @since 3.2 |
|
530 * @param None. |
|
531 * @return ETrue if present else EFalse. |
|
532 */ |
|
533 virtual TBool IsRephaPresent() = 0; |
|
534 |
|
535 /** |
|
536 * Retrieve the Previous to previous character during multitapping. |
|
537 * |
|
538 * @since 3.2 |
|
539 * @param aContextSensitive EFalse is the default parameter. |
|
540 * ETrue is used for requesting the function |
|
541 * to check for extraction of the character |
|
542 * two positions before the seleted text. |
|
543 * |
|
544 * @return The previous to previous character if any. |
|
545 */ |
|
546 virtual TText PreviousToPreviousChar( TBool aContextSensitive = EFalse ) = 0; |
|
547 |
|
548 /** |
|
549 * This method is called for removing the Rakar character. The function |
|
550 * checks if Rakar (Virama+Ra) is present. |
|
551 * |
|
552 * @since 3.2 |
|
553 * @param None. |
|
554 * @return None. |
|
555 */ |
|
556 virtual void RemoveRakarCharacterL() = 0; |
|
557 |
|
558 /** |
|
559 * Returns the free space left in the Editor. |
|
560 * |
|
561 * @param aUnlimit. Set to EFalse in case of Editors with limited text |
|
562 * size |
|
563 * isToCountUncommittedTextLength. Pass ETrue if the lenght of |
|
564 * Uncommitted text is to be counted. |
|
565 * |
|
566 * @return TInt. Free space left in the Editor. |
|
567 */ |
|
568 virtual TInt EditorFreeSpace(TBool& aUnlimit, |
|
569 TBool isToCountUncommittedTextLength = EFalse ) const = 0; |
|
570 #ifdef RD_INTELLIGENT_TEXT_INPUT |
|
571 /** |
|
572 * Returns the free space left in the Editor. ITI specific implementation |
|
573 * |
|
574 * @param aUnlimit. Set to EFalse in case of Editors with limited text |
|
575 * size |
|
576 * isToCountUncommittedTextLength. Pass ETrue if the lenght of |
|
577 * Uncommitted text is to be counted. |
|
578 * |
|
579 * @return TInt. Free space left in the Editor. |
|
580 */ |
|
581 virtual TInt EditorFreeSpaceForAutoWordCompletion(TBool& aUnlimit, |
|
582 TBool isToCountUncommittedTextLength = EFalse ) const = 0; |
|
583 #endif |
|
584 #ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ |
|
585 #ifdef RD_INTELLIGENT_TEXT_INPUT |
|
586 /** |
|
587 * Gives the amount of characters in the document. |
|
588 * @return The number of characters in the active editor. |
|
589 */ |
|
590 virtual TInt DocumentLength() const = 0; |
|
591 |
|
592 #endif //RD_INTELLIGENT_TEXT_INPUT |
|
593 #endif //__ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ |
|
594 /** |
|
595 * from MAknFepManagerUIInterface |
|
596 * query whether the special char is valid in the current editor |
|
597 * |
|
598 * @since 3.2 |
|
599 * @param aChar Checking a chracter |
|
600 * @return TBool. IF ETrue, the character is valid. |
|
601 */ |
|
602 virtual TBool CharIsValidInEditor(TChar aChar) = 0; |
|
603 |
|
604 /** |
|
605 * Returns the status of predictive input. |
|
606 * |
|
607 * @since 3.2 |
|
608 * @return TBool. IF ETrue, it is possible to change prediction ON. |
|
609 */ |
|
610 virtual TBool IsAbleToChangePrediction() const = 0; |
|
611 |
|
612 /** |
|
613 * This method is called for removing the N characters from the |
|
614 * specified position. If the text to be removed is not yet |
|
615 * committed, it is updated with NULL descriptor and committed. |
|
616 * |
|
617 * @since 5.0 |
|
618 * @param TInt aPos position to start searching from. By default |
|
619 * Searching will start from the cursor position. |
|
620 * @param TInt aNumOfCharacters Number of characters to remove. |
|
621 * @param TBool Should cursor be positioned at the original location. |
|
622 * @return None. |
|
623 */ |
|
624 virtual void RemoveTextFromEditorL( TInt aNumOfCharacters, TInt aPos = 0, |
|
625 TBool aIsToAlignCursor = ETrue ) = 0; |
|
626 |
|
627 /** |
|
628 * Align the Logical and Visual cursor positions. |
|
629 * |
|
630 * @since 5.0 |
|
631 * @param None |
|
632 * @return None |
|
633 */ |
|
634 virtual void AlignLogicalAndVisualCursorL() = 0; |
|
635 |
|
636 #ifdef RD_MARATHI |
|
637 /** |
|
638 * This function checks if the previous two characters are |
|
639 * the combination of Chandra-A |
|
640 * |
|
641 * @since 5.0 |
|
642 * @param None |
|
643 * @return TBool. |
|
644 */ |
|
645 virtual TBool IsChandraAPresentL() = 0; |
|
646 #endif // RD_MARATHI |
|
647 |
|
648 /** |
|
649 * Returns boolean value indicating whether hash key is in selection mode or |
|
650 * in traditional mode. |
|
651 * |
|
652 * @since 3.1 |
|
653 * @return ETrue if hash key is in text selection mode. |
|
654 * EFalse otherwise. |
|
655 */ |
|
656 virtual TBool HashKeySelectionInUse() const = 0; |
|
657 |
|
658 /** |
|
659 * Returns the UI interface implementation used in the current app. |
|
660 * |
|
661 * @since 3.2 |
|
662 * @return The UI interface object used in the current app. |
|
663 */ |
|
664 virtual CAknFepUIInterface* UiInterface() = 0; |
|
665 |
|
666 #ifdef RD_INTELLIGENT_TEXT_INPUT |
|
667 |
|
668 // Predictive QWERTY (XT9) changes ----> |
|
669 /** |
|
670 * Function to get the text direction for current language. |
|
671 * @return ETrue if language id RTL, EFalse if it is not |
|
672 */ |
|
673 virtual TBool IsRightToLeftLanguage() = 0; |
|
674 |
|
675 /** |
|
676 * @return ETrue If the auto completion is On. EFalse otherwise. |
|
677 */ |
|
678 virtual TBool IsAutoCompleteOn() const = 0; |
|
679 |
|
680 /** |
|
681 * @return TInt Typing correction level. |
|
682 */ |
|
683 virtual TInt AdvancedPredictiveTypingCorrectionLevel() const = 0; |
|
684 |
|
685 /** |
|
686 * @return ETrue If the number candidate shown. EFalse otherwise. |
|
687 */ |
|
688 virtual TBool IsAdvancedPredictiveNumberCandidateShown() const = 0; |
|
689 |
|
690 /** |
|
691 * Cuts off the automatically completed tail of the suggested word candidate. |
|
692 */ |
|
693 virtual void RemoveSuggestedAdvanceCompletionL() = 0; |
|
694 |
|
695 /** |
|
696 * @return ETrue If the primary candidate is suggested. EFalse otherwise. |
|
697 */ |
|
698 virtual TBool AdvancedPredictivePrimaryCandidate() const = 0; |
|
699 |
|
700 /** |
|
701 * @Set the chr composition flag. |
|
702 */ |
|
703 virtual void SetComposChrFlag( TBool aFlag ) = 0; |
|
704 |
|
705 /** |
|
706 * @return ETrue If it is chr composition key |
|
707 */ |
|
708 virtual TBool GetComposChrFlag() = 0; |
|
709 |
|
710 // Predictive QWERTY (XT9) changs <---- |
|
711 #endif //RD_INTELLIGENT_TEXT_INPUT |
|
712 /** |
|
713 * Returns plugin ui manager |
|
714 * |
|
715 * @since 3.2 |
|
716 * @return The UI interface object used in the current app. |
|
717 */ |
|
718 virtual CAknFepPluginManager* PluginUIManager() = 0; |
|
719 #ifdef RD_HINDI_PHONETIC_INPUT |
|
720 //hindi_phonetic_fixes |
|
721 /* |
|
722 * This functions toggles the case from upper to lower |
|
723 * @since 5.0 |
|
724 * @param None |
|
725 * @return void |
|
726 */ |
|
727 virtual void HandleIndicCaseL()=0; |
|
728 #endif |
|
729 |
|
730 // the follow 2 functions for phrase creation |
|
731 virtual MZhuyinKeyHandler* ZhuyinKeyHandler() = 0; |
|
732 virtual CAknFepZhuyinAnalyser* ZhuyinAnalyser() = 0; |
|
733 |
|
734 #ifdef __ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ |
|
735 #ifdef RD_INTELLIGENT_TEXT_INPUT |
|
736 /** |
|
737 * @return ETrue If the number entry with long key press is supported on QWERTY keyboard. |
|
738 */ |
|
739 virtual TBool LongPressNumberEntryOnQwerty() const = 0; |
|
740 #endif //RD_INTELLIGENT_TEXT_INPUT |
|
741 #endif //__ITI_LONGPRESS_NUM_SHIFT_COPYPASTE__ |
|
742 #ifdef RD_INTELLIGENT_TEXT_INPUT |
|
743 virtual void MultitapThroughSCTCharL(TCallBack aCallBack) = 0; |
|
744 virtual TBool IsLanguageSupportPrediction() = 0; |
|
745 virtual TInt GetNumericSCTResID() = 0; |
|
746 /** |
|
747 * Hides the exact word pop up window. |
|
748 */ |
|
749 virtual void HideExactWordPopUp() = 0; |
|
750 /** |
|
751 * @return ETrue If the exact word pop up is shown. |
|
752 */ |
|
753 virtual TBool IsExactWordPopUpShown() = 0; |
|
754 #endif //RD_INTELLIGENT_TEXT_INPUT |
|
755 virtual CAknExtendedInputCapabilities::TEditorType EditorType() const = 0; |
|
756 virtual TBool IsAllowedKeymappingForNumberMode(TChar aChar) const = 0; |
|
757 }; |
|
758 #endif // __AKN_FEP_MANAGER_UI_INTERFACE_H__ |
|
759 |
|
760 // End of file |
|