#include <mw/PtiEngine.h>
| class CPtiEngine : public CBase |
CPtiEngine class.
This is the main client side API for PtiEngine. The purpose of PtiEngine API is to provide a single calling point for low level (below UI) text input functionality. The API provides methods for querying and activating installed input languages, changing input modes and text cases and performing text input operations. The API contains set of methods for latin based, Chinese and Japanese text input. Some of the methods are common to all of those variants. PtiEngine also provides access to predictive text input functionality, in case there is need to use it directly without standard CEikEdwin / FEP chain (hence the name 'predictive text input engine') Predictive text engine integration is hidden behind PtiCore plugin API and is used through PtiEngine main API.
Usage: PtiEngine is created by calling CPtiEngine::NewL method. In typical use case there is no need to pass core uid parameter to NewL method. Constructor will load and set up available core objects.
Typical use cases:
Entering text in latin multitapping mode ----------------------------------------
CPtiEngine* aEngine = CPtiEngine::NewL(); aEngine->ActivateLanguageL(ELangEnglish, EPtiEngineMultitapping); aEngine->AppendKeyPress(EPtiKey3); aEngine->AppendKeyPress(EPtiKey6); aEngine->AppendKeyPress(EPtiKey6); aEngine->AppendKeyPress(EPtiKey6); aEngine->AppendKeyPress(EPtiKey4); TBuf<100> temp; temp.Copy(aEngine->CurrentWord()); // At this point temp would contain // word "dog".
Entering text in latin predictive mode --------------------------------------
CPtiEngine* aEngine = CPtiEngine::NewL(); aEngine->ActivateLanguageL(ELangEnglish, EPtiEnginePredicitve); aEngine->AppendKeyPress(EPtiKey8); aEngine->AppendKeyPress(EPtiKey4); aEngine->AppendKeyPress(EPtiKey4); aEngine->AppendKeyPress(EPtiKey7); TBuf<100> temp; temp.Copy(aEngine->CurrentWord()); // At this point temp would contain // (depending on the underlying engine) // word "this". temp.Copy(aEngine->NextCandidate()); // Move on to next candidate. aEngine->CommitCurrentWord(); // Tell engine that current word was accepted, // so that the underlyinbg engine keeps // frequency information up-to-date. Entering text in latin qwerty mode ----------------------------------
CPtiEngine* aEngine = CPtiEngine::NewL(); aEngine->ActivateLanguageL(ELangEnglish, EPtiEngineQwerty); aEngine->AppendKeyPress(EPtiKeyQwertyQ); aEngine->AppendKeyPress(EPtiKeyQwertyW); aEngine->AppendKeyPress(EPtiKeyQwertyE); aEngine->AppendKeyPress(EPtiKeyQwertyR); aEngine->AppendKeyPress(EPtiKeyQwertyT); aEngine->AppendKeyPress(EPtiKeyQwertyY); TBuf<100> temp; temp.Copy(aEngine->CurrentWord()); // At this point temp would contain // word "qwerty". // Next line requires that French key mappings are available in device. aEngine->ActivateLanguageL(ELangFrench, EPtiEngineQwerty); aEngine->SetCase(EPtiCaseUpper); aEngine->ClearCurrentWord(); aEngine->AppendKeyPress(EPtiKeyQwertyQ); aEngine->AppendKeyPress(EPtiKeyQwertyW); aEngine->AppendKeyPress(EPtiKeyQwertyE); aEngine->AppendKeyPress(EPtiKeyQwertyR); aEngine->AppendKeyPress(EPtiKeyQwertyT); aEngine->AppendKeyPress(EPtiKeyQwertyY); temp.Copy(aEngine->CurrentWord()); // At this point temp would contain // word "AZERTY".
Entering text in preditcive latin qwerty mode --------------------------------------------- CPtiEngine* aEngine = CPtiEngine::NewL(); aEngine->ActivateLanguageL(ELangEnglish, EPtiEngineQwertyPredictive); aEngine->AppendKeyPress(EPtiKeyQwertyE); aEngine->AppendKeyPress(EPtiKeyQwertyN); aEngine->AppendKeyPress(EPtiKeyQwertyT); aEngine->AppendKeyPress(EPtiKeyQwertyE); aEngine->AppendKeyPress(EPtiKeyQwertyR); aEngine->AppendKeyPress(EPtiKeyQwertyT); aEngine->AppendKeyPress(EPtiKeyQwertyA); TBuf<100> temp; temp.Copy(aEngine->CurrentWord()); // At this point temp would contain // for example word "entertainment", assuming the. // underlying prediction engine supports word completion.
| IMPORT_C TInt | ActivateLanguageL | ( | TInt | aEpocLanguageID, |
| TPtiEngineInputMode | aMode = EPtiEngineInputModeNone | |||
| ) | ||||
Activates language in requested input mode. After calling this method language is ready to be used with all input modes it supports.
| Parameter | Description |
|---|---|
| aEpocLanguageID | Language to be activated. |
| aMode | Input mode after activation. If thise is left to default value, then default input mode is activated. |
Returns: KErrNone if success or system wide error code.
Adds new auto substitution entry to database. If entry for given shorcut already exists, then the old entry will be automatically deleted.
| Parameter | Description |
|---|---|
| aShortcut | Shortcut part for new entry. |
Returns: KErrNone or system wide error code.
Loads and constructs new core object. Core object is added to the list of available cores and is ready to be used after that.
| Parameter | Description |
|---|---|
| aCoreUid | Uid for core plugin. |
| aUseDefaultUserDictionary | .... |
Returns: KErrNone if operation was successful or system wide error code.
Some prediction engines support next word prediction feature but require database to be pre-filled with suitable phrase data. This method adds one new phrase or sentence to phrase dictionary. Active core object needs to support phrase based next word prediction, otherwise an error code is returned.
| Parameter | Description |
|---|---|
| aNewPhrase | New phrase to be added to phrase dictionary. |
Returns: KErrNone or system wide error code.
| IMPORT_C TInt | AddUserDictionaryEntry | ( | MPtiUserDictionaryEntry & | aEntry | ) |
Adds new entry (in most cases a word) to default user dictionary of currently active core object.
| Parameter | Description |
|---|---|
| aEntry | An entry to be added to dictionary. |
Returns: KErrNone if success, otherwise system wide error code.
| IMPORT_C TInt | AddUserDictionaryEntry | ( | MPtiUserDictionaryEntry & | aEntry, |
| TInt | aId | |||
| ) | ||||
Adds entry to specific user dictionary.
| Parameter | Description |
|---|---|
| aEntry | An entry to be added to dictionary. |
| aId | User dictionary id. |
Returns: KErrNone if success, otherwise system wide error code.
This method handles key press and forwards it to correct core object depending on active language and input mode. The current word buffer is updated accordingly. If input sequence buffer has reached its maximum length then nothing will be done.
| Parameter | Description |
|---|---|
| aKey | Key code. |
Returns: Pointer to current word buffer.
| IMPORT_C MPtiUserDictionary * | AttachDefaultUserDictionaryL | ( | TUid | aCoreUid, |
| TInt | aSymbolClass | |||
| ) | ||||
Attach default user dictionary.
| Parameter | Description |
|---|---|
| aCoreUid | Uid for owner core object. |
| aSymbolClass | Symbol class for udb data. |
Returns: Pointer to user dictionary object. NULL if failure.
| IMPORT_C MPtiUserDictionary * | AttachUserDictionaryL | ( | TDesC & | aFileName | ) |
Attach user dictionary in given file to core for requested input mode.
| Parameter | Description |
|---|---|
| aFileName | User dictionary file name. |
Returns: Pointer to user dictionary object. NULL if failure.
| IMPORT_C TUint32 | AvailableCharConversions | ( | ) | const |
Returns value indicating currently available character conversions.
Returns: Currently available character conversions. There is a bit set for each available char conversion. See definition of TPtiCharConversion.
| IMPORT_C TInt | CancelTimerActivity | ( | ) |
Front end processeor uses this method for indicating PtiEngine that all key press related timers should be canceled.
Returns: KErrNone if timers were successfully canceled. KErrNotFound if no active timers were found.
| IMPORT_C TPtrC | CandidatePage | ( | ) |
Returns pointer to current Chinese candidate page.
Returns: Pointer to current Chinese candidate page.
| IMPORT_C TPtiTextCase | Case | ( | ) | const |
Returns active text case.
Returns: Current text case.
| IMPORT_C TPtrC8 | CaseSequence | ( | ) |
Returns text case buffer. Case buffer contains shift state for each key press used for producing active word, ie. it remembers case values for each AppendKeyPress call. Case buffer is cleared when active word is commited or cleared. Return value is TPtrC8 containing string of EPtiTextCase values.
Returns: A string of EPtiTextCase values.
| IMPORT_C TInt | CharConversion | ( | TPtiCharConversion | aType, |
| TAny * | aInput, | |||
| TInt | aInputLength, | |||
| TAny * | aOutput | |||
| ) | ||||
Converts given string of characters to one coding system to another. See definition of TPtiCharConversion for list of supported conversion types. It is possible that only a small subset of supported conversion types is actually available at run time (that depends on available core objects). AvailableCharConversions() method can be used for querying available conversion types before using this method.
| Parameter | Description |
|---|---|
| aType | Requested conversion type. |
| aInput | Input string. This parameter may point to either 8-bit or 16-bit data depending on conversion type. |
| aInputLength | Number of characters in input string. |
| aOutput | Output string. This parameter may pint to either 8-bit or 16-bit data depending on conversion type. |
| IMPORT_C void | ClearCurrentWord | ( | ) |
Clears current word buffer. Calling this method means that current word was reject and will not be part of edited text. Either this method or CommitCurrentWord() must be called before starting a new word.
| IMPORT_C void | CloseCurrentLanguageL | ( | ) |
Closes active language. After calling this method there won't be active language and most PtiEngine API methods will return error until ActivateLanguageL is called again. Core objects for active language are asked to release related resources.
| IMPORT_C TInt | CommitCurrentWord | ( | ) |
Commits current word. Commiting means that core object is isntructed to end inline editing operation and accepted active word as part of edited text. Core object may then update frequency information, add unrecognized word to user dictioary or perform any other operation related to commiting a word. Word buffer is cleared. Either this method or ClearCurrentWord() must be called before starting a new word.
Returns: KErrNone if success. KErrNoActiveLanguage if no active language.
| IMPORT_C MPtiEngineCompositionDataInterface * | CompositionData | ( | ) |
Returns pointer to composition data interface (used with Japanese input).
Returns: Pointer to composition data interface.
| IMPORT_C MPtiCoreInfo * | CoreInfo | ( | TPtiEngineInputMode | aMode | ) | const |
Returns core info structure for given input mode.
Returns: Pointer to core info object. NULL if core for given input mode was not found.
Creates empty user default dictionary file for given core object and initializes it to PtiEngine user dictionary format. If file already exists, then this method does nothing. Normally this method is only used by core objects.
| Parameter | Description |
|---|---|
| aCoreUid | Uid for requesting core object. |
| aSymbolClass | Symbol class for udb data. |
| IMPORT_C TInt | CreateUserDictionaryL | ( | TDesC & | aFileName, |
| CDesCArrayFlat * | aWords, | |||
| TPtiEngineInputMode | aMode | |||
| ) | ||||
Creates new user dictionary file, inserts given list of words into it and attaches it to active core object for requested input mode. Active language must support requested input mode.
| Parameter | Description |
|---|---|
| aFileName | File name for new user dictionary. |
| aWords | A list of words to be inserted to new user dictionary. |
| aMode | Input mode for core object. |
Returns: KErrNone if success, otherwise system wide error code.
| IMPORT_C TPtrC8 | CurrentInputSequence | ( | ) | const |
Returns current input sequence (a list of key presses). Bytes in returned descriptor are TPtiKey enum values.
Returns: a descriptor containing current input sequence.
| IMPORT_C MPtiLanguage * | CurrentLanguage | ( | ) |
Returns pointer to currently active language.
Returns: Pointer to currently active language object.
| IMPORT_C TPtrC | CurrentWord | ( | ) |
Returns pointer to current word buffer.
Returns: Pointer to current word buffer.
| IMPORT_C MPtiUserDictionary * | DefaultUserDictionary | ( | TPtiEngineInputMode | aMode | ) |
Returns default user dictionary for given input mode.
Returns: User dictionary for given input mode. NULL if wasn't found.
| IMPORT_C TPtrC | DeleteKeyPress | ( | ) |
Deletes last character in current word buffer and updates candidate list accordingly.
Returns: Pointer to current word buffer.
| IMPORT_C void | EnableToneMarks | ( | TBool | aValue | ) |
Enables or disables tone marks.
| Parameter | Description |
|---|---|
| aValue | A boolean value specifying whether tone marks will be on or off. |
| IMPORT_C const RArray< TPtiNumericKeyBinding > & | ExtendedNumericModeKeysForQwertyL | ( | TInt | aLanguage | ) |
This method is same as GetNumericModeKeysForQwertyL, expect that instead of returning strict list of key bindings used in phone number editor, it returns list of all possible characters used in any of the "number only" editor variations. Returned list includes key bindings for characters: "*+pw#1234567890;.,-E?/" (Not necessarily in this order). See also GetNumericModeKeysForQwertyL.
This version first tries to return mappings according to currently active physical keyboard. It current keyboard is not qwerty based, it searches data for the first qwerty based keyboard type it can find. That is done in same order as keyboard types are defined in PtiDefs.h. There is also another version this method, which gets keyboard type as a parameter.
| Parameter | Description |
|---|---|
| aLanguage | Language id for requested mappings. |
| IMPORT_C const RArray< TPtiNumericKeyBinding > & | ExtendedNumericModeKeysForQwertyL | ( | TInt | aLanguage, |
| TPtiKeyboardType | aKeyboardType | |||
| ) | ||||
Same as previous version of ExtendedNumericModeKeysForQwertyL (see description above), but keyboard type is given as a parameter and mappings are return only for given keyboard type.
| Parameter | Description |
|---|---|
| aLanguage | Language id for requested mappings. |
| aKeyboardType | keyboard type. |
| IMPORT_C TPtrC | FirstCandidate | ( | ) |
Returns pointer to first word in candidate list. If there isn't any candidate words the returned pointer will point to empty descriptor.
Returns: Pointer to first word in candidate list.
Return auto substitution entry for given index.
| Parameter | Description |
|---|---|
| aIndex | Index for entry to be returned. |
| aShortcut | Shortcut part of the result entry will be stored here. |
| aSubstitution | Substitution part of result entry will be stored here. |
Returns: KErrNone or system wide error code.
| IMPORT_C TInt | GetCandidateListL | ( | CDesCArray & | aList | ) |
Returns list of candidate words for current input sequence. If word completion feature is on, then words accepted to result list may contain more letters than the number of key presses in current input sequence.
| Parameter | Description |
|---|---|
| aList | a list to be filled with candidate words. |
Returns: KErrNone if success, otherwise system wide error code.
| IMPORT_C HBufC * | GetCandidatesByInputString | ( | const TDesC & | aInputString, |
| RPointerArray< HBufC > & | aList, | |||
| const TBool | aIsPredictive | |||
| ) | ||||
| IMPORT_C TInt | GetChinesePhraseCandidatesL | ( | CDesCArray & | aList | ) |
Fills list with phrase candidates for currently selected phonetic spelling.
| Parameter | Description |
|---|---|
| aList | A descriptor list to be filled with phrase candidates. Any previous items in aList are cleared. |
Returns: Number of items in list.
| IMPORT_C MPtiHwrRecognizer * | GetHwrRecognizerL | ( | TLanguage | aLanguage | ) |
Get first hwr implementation support the specified language
| Parameter | Description |
|---|---|
| aLanguage | The language that hwr implementation supported |
Returns: The pointer points to hwr implementation instance
| IMPORT_C MPtiHwrRecognizer * | GetHwrRecognizerL | ( | TInt | aImpId | ) |
Get hwr implementation by give implementation uid
| Parameter | Description |
|---|---|
| aImpId | Given specific implementation uid |
Returns: The pointer points to hwr implementation instance
| IMPORT_C MPtiLanguage * | GetLanguage | ( | TInt | aCode | ) | const |
Returns pointer to requested language.
| Parameter | Description |
|---|---|
| aCode | Language code for requested language. |
Returns: Pointer to requested language object. NULL if no language for given code.
Returns localized language name for given language. This method is quite inefficient (always reads name table from resource file), when possible use Getlanguage()->LocalizedName() instead. This method can be used also when requested language is not among available input languages.
Returns: Localized language name.
| IMPORT_C void | GetModeNameIndexL | ( | TPtiChineseVariant | aVariant, |
| RArray< TInt > & | aResult | |||
| ) | ||||
Returns mode name index table for given Chinese variant.
| Parameter | Description |
|---|---|
| aVariant | Chinese variant to be queried. |
| aResult | Resulting index table. |
| IMPORT_C TInt | GetNextWordCandidateListL | ( | CDesCArray & | aList | ) |
Returns next word candidate list. This method requires that current core object supports next word prediction feature and it is turned on.
| Parameter | Description |
|---|---|
| aList | A List to be filled with next word cadidates. |
Returns: KErrNone if list was successfully filled. KErrNotSupported if current predictive core doesn't support next word prediction or the feature is not turned on.
| IMPORT_C void | GetNumericModeKeysForQwertyL | ( | TInt | aLanguage, |
| RArray< TPtiNumericKeyBinding > & | aResult | |||
| ) | ||||
Qwerty input mode has different keymapping layout for each language. Therefore the characters for numeric input mode may be mapped to different keys depending on language. There are several situations where client application needs to know which key and case combination produce numeric characters for given language. This convinience method can be used for extracting that information easily (it is also possible to achieve same result directly via CPtiCoreLanguage object). Result array will be left empty if requested language is not available or it doesn't support qwerty input mode. Returned list includes key bindings for characters: "0123456789pw+#*" (Not necessarily in this order). See also ExtendedNumericModeKeysForQwertyL.
This version first tries to return mappings according to currently active physical keyboard. It current keyboard is not qwerty based, it searches data for the first qwerty based keyboard type it can find. That is done in same order as keyboard types are defined in PtiDefs.h. There is also another version this method, which gets keyboard type as a parameter.
| Parameter | Description |
|---|---|
| aLanguage | Language id for requested mappings. |
| aResult | Array for storing resulting mappings. |
| IMPORT_C void | GetNumericModeKeysForQwertyL | ( | TInt | aLanguage, |
| RArray< TPtiNumericKeyBinding > & | aResult, | |||
| TPtiKeyboardType | aKeyboardType | |||
| ) | ||||
Same as previous version of GetNumericModeKeysForQwertyL (see description above) but keyboard type is given as a parameter and mappings are return only for given keyboard type.
| Parameter | Description |
|---|---|
| aLanguage | Language id for requested mappings. |
| aResult | Array for storing resulting mappings. |
| aKeyboardType | keyboard type. |
| IMPORT_C TInt | GetPhoneticSpellingsL | ( | CDesCArray & | aList | ) |
Fills list with all the phonetic spellings for current input sequence.
| Parameter | Description |
|---|---|
| aList | A descriptor list to be filled with phonetic spellings. Any previous items in aList are cleared. |
Returns: Number of items in list.
| IMPORT_C TInt | GetSpelling | ( | TUint16 | aInput, |
| TDes & | aOutput, | |||
| TPtiSpelling | aType | |||
| ) | ||||
Returns alternate spelling for given character.
| Parameter | Description |
|---|---|
| aInput | a character to be converted to requested spelling. |
| aOutput | output will be stored to this descriptor. |
| aType | spelling type |
Returns: KErrNone if operation was successful, KErrNotSupported if requested spelling type is not supported.
| IMPORT_C TInt | GetUserDictionaryEntry | ( | TInt | aIndex, |
| MPtiUserDictionaryEntry & | aResult | |||
| ) | ||||
Returns entry for given index in default user dictionary.
| Parameter | Description |
|---|---|
| aIndex | An index for requested entry. |
| aResult | Result will be stored here. |
Returns: KErrNone if success, otherwise system wide error code.
| IMPORT_C TInt | HandleCommandL | ( | TPtiEngineCommand | aCommand, |
| TAny * | aParams = NULL | |||
| ) | ||||
General command handling method. This method can be used for controlling core objects that require more information than just sequence of key presses.
| Parameter | Description |
|---|---|
| aCommand | A command to be handled. |
| aParams | Possible input data or parameters for command. |
Returns: KErrNone if success, otherwise an error code.
| IMPORT_C TPtiEngineInputMode | InputMode | ( | ) | const |
Returns active input mode.
Returns: Current input mode.
| IMPORT_C TBool | IsQwertyBasedMode | ( | TPtiEngineInputMode | aMode | ) | const |
A convinience method for cheking qwerty based input mode.
| Parameter | Description |
|---|---|
| aMode | Input mode to be checked. |
Returns: ETrue If aMode is qwerty based input mode. EFalse Otherwise.
| IMPORT_C TBool | IsToneMarkValidForSpelling | ( | ) | const |
Returns boolean value indicating whether current tone mark is valid for spelling.
Returns: ETrue if tone mark is valid for spelling. EFalse otherwise
| IMPORT_C TPtiKeyboardType | KeyboardType | ( | ) | const |
Returns currently selected qwerty keyboard type.
Returns: Currently selected keyboard type.
| IMPORT_C void | KeyboardTypesSupportedByLanguageL | ( | TInt | aLanguage, |
| RArray< TPtiKeyboardType > & | aResult | |||
| ) | ||||
Lists keyboard blocks available in keymapping data for given language.
| Parameter | Description |
|---|---|
| aLanguage | A language to be queried. |
| aResult | Resulting list of keyboard types will we stored here. |
| IMPORT_C TPtiKey | LastEnteredKey | ( | ) | const |
Returns last entered key press.
Returns: last entered key press.
| IMPORT_C void | ListAvailablePhysicalKeyboardsL | ( | RArray< TPtiKeyboardType > & | aResult | ) | [static] |
Returns a list containing keyboard type values for all available physical keyboards connected to the device. Keyboard doesn't have to be active at calling time to be included in the output list.
| Parameter | Description |
|---|---|
| aResult | An array to be filled with available keyboard types. |
| IMPORT_C void | MappingDataForKey | ( | TPtiKey | aKey, |
| TDes & | aResult, | |||
| TPtiTextCase | aCase | |||
| ) | ||||
Returns keymapping data for given key. Returned data depends on active language and input mode. Result string will be empty if there isn't key mapping adta available.
| Parameter | Description |
|---|---|
| aKey | A key to be queried. |
| aResult | Resulting mapping data. |
| IMPORT_C void | MarkAutoCapitalized | ( | ) |
Some core objects may provide different set of results depending on whether the auto captitalization feature was used for entering the word or not. There is now way to tell on core level whether the word was auto-capitalizedby FEP or capitalized normally by the user. This method can be used to incicate core object that auto-capitalization was used for current input sequence. Clearing or commiting the word will cancel the effect of this method.
| IMPORT_C TBool | MoreCandidatePages | ( | ) |
Returns a boolean value indicating whether there are more candidate pages available.
Returns: ETrue if there are more candidate pages available. EFalse otherwise.
| IMPORT_C CPtiEngine * | NewL | ( | TBool | aUseDefaultUserDictionary = EFalse | ) | [static] |
Two phase constructor.
| IMPORT_C CPtiEngine * | NewL | ( | const TDesC & | aCoreName, |
| TBool | aUseDefaultUserDictionary = EFalse | |||
| ) | [static] | |||
Two phase constructor.
NOTE: THIS METHOD IS DEPRECATED AND WILL LEAVE WHEN CALLED.
| IMPORT_C CPtiEngine * | NewL | ( | const TUid | aCoreUid, |
| TBool | aUseDefaultUserDictionary = EFalse | |||
| ) | [static] | |||
Two phase constructor.
| IMPORT_C TPtrC | NextCandidate | ( | ) |
Returns pointer to next word in candidate list. FirstCandidate() must be called before calling this method. Returns pointer to empty descriptor if there isn't more candidates available.
Returns: Pointer to next word in candidate list.
| IMPORT_C TBool | NextCandidatePage | ( | ) |
Changes to next Chinese candidate page.
Returns: ETrue if success. EFalse if there are no more candidate pages.
| IMPORT_C TInt | NumberOfAutoSubstitutionEntries | ( | ) | const |
Returns the number of auto substitution entries in auto subst db.
Returns: Number of entries in auto substitution db. Zero if the feature is not supported or is not activated.
| IMPORT_C TInt | NumberOfCandidates | ( | ) |
Returns number of candidate words for current input sequence.
Returns: number of cadidate words.
| IMPORT_C TInt | NumberOfEntriesInUserDictionary | ( | ) |
Returns number of entries in default user dictionary.
Returns: Number of entries in default user dictionary. KErrNotSupported if core can't return requested value.
| IMPORT_C TInt | NumberOfLanguages | ( | ) | const |
Returns number of available input languages.
Returns: Number of available languages.
| IMPORT_C MPtiObserver * | Observer | ( | ) |
Returns current observer.
Returns: Pointer to current observer object.
| IMPORT_C TInt | PhoneticSpellingCount | ( | ) | const |
Returns a value specifying how many phonetic spellings there is available for current input.
Returns: Number of phonetic spellings available for current input.
| IMPORT_C TPtrC | PreviousCandidate | ( | ) |
Returns pointer to previous word in candidate list. If there isn't previous candidate available (NextCandidate() wasn't succesfully called) then the return value will point to an empty string.
Returns: Pointer to previous word in candidate list.
| IMPORT_C TBool | PreviousCandidatePage | ( | ) |
Changes to previous Chinese candidate page.
Returns: ETrue if success. EFalse if current candidate page is first.
Returns a heap buffer containing data from given secondary data file. Returns null if file is not found.
| Parameter | Description |
|---|---|
| aCoreUid | Uid number for requesting core object. |
| aIndexNumber | Index number (see CreateDefaultUserDictionaryFileL). |
Returns: A heap buffer conataining requested data. NULL if file not found.
| IMPORT_C TPtrC | ReadingTextL | ( | ) |
Returns reading text for Japanese input.
Returns: Reading text for Japanese input.
| IMPORT_C TInt | RemoveEntryFromUserDictionary | ( | MPtiUserDictionaryEntry & | aEntry | ) |
Removes entry from default user dictionary of currently active core object.
| Parameter | Description |
|---|---|
| aEntry | an entry to be removed from default dictionary. |
Returns: KErrNone if success, otherwise system wide error code.
| IMPORT_C TInt | RemoveEntryFromUserDictionary | ( | MPtiUserDictionaryEntry & | aEntry, |
| TInt | aId | |||
| ) | ||||
Removes word from specific user dictionary.
| Parameter | Description |
|---|---|
| aEntry | an entry to be removed from default dictionary. |
| aId | User dictionary id. |
Returns: KErrNone if success, otherwise system wide error code.
| IMPORT_C TInt | SelectedPhoneticSpelling | ( | ) | const |
Returns the index of currently selected phonetic spelling.
Returns: The index of currently selected phonetic spelling. Returned value is negative if there isn't phonetic spelling available.
Turns auto substitution feature on or off. Auto substitution feature replaces predefined strings with other strings. For example, if user types xmas, it could be auto substituted with Christmas.
| Parameter | Description |
|---|---|
| aStatus | New status for auto substituiton feature |
Returns: KErrNone or system wide error code.
| IMPORT_C void | SetCandidatePageLength | ( | TInt | aLength | ) |
Sets length of Chinese candidate page.
| Parameter | Description |
|---|---|
| aLength | Length of Chinese candidate page. |
| IMPORT_C void | SetCase | ( | TPtiTextCase | aCase | ) |
Sets text case.
| Parameter | Description |
|---|---|
| aCase | Text case to be set. Possible values are: |
Fills text buffer with given word, refreshes current input sequence and asks current core object to update candidate list accordingly.
| Parameter | Description |
|---|---|
| aWord | a word to be set as current word. |
Returns: KErrNone if success, otherwise system wide error code.
| IMPORT_C TInt | SetExternalKeyMapL | ( | TPtiEngineInputMode | aMode, |
| TPtiKey | aKey, | |||
| TDesC & | aKeyMap, | |||
| TPtiTextCase | aCase | |||
| ) | ||||
Replaces key map for single key.
| Parameter | Description |
|---|---|
| aMode | Input mode of key map. |
| aKey | Key to be replaced. |
| aKeyMap | New key sequence for aKey. |
Returns: KErrNone if success, otherwise system wide error code.
| IMPORT_C TInt | SetInputMode | ( | TPtiEngineInputMode | aMode | ) |
Activates requested input mode for active language.
| Parameter | Description |
|---|---|
| aMode | requested input mode. |
Returns: KErrNone if input mode was activated. KErrNotSupported if current language doesn't support requested input mode.
| IMPORT_C TInt | SetKeyboardType | ( | TPtiKeyboardType | aType | ) |
Sets keyboard type for non-virtual keyboard. Keyboard type specifies which set of key mapping data is used.
| Parameter | Description |
|---|---|
| aType | New keyboard type. |
Returns: KErrNone if successful KErrNotSupported if currently selected language/input mode combination does not allow given keyboard type, or mapping data doesn't contain block for it.
Sets the maximum length for auto completed words. This method can be used when the client needs to be sure that all provided word completions will fit into remaining editor buffer. When the number of key presses in an input sequence exceeds the value given in aMaxLength, core will automatically reset this value to "no limit".
| Parameter | Description |
|---|---|
| aMaxLength | The maximum length fo auto completed candinates. Value 0 means no limit. |
Returns: KErrNone If the operation succeeded. Otherwise system wide error code.
Sets a boolean value indicating whether number candidates are included to predictive candidate list. Number candidates are strings containing only digits. Number candidate feature must be supported by active prediction engine, otherwise this setting will be ignored.
| Parameter | Description |
|---|---|
| aStatus | A boolean value indicating whether number candidates are included to cadidate list. |
Returns: KErrNone or a system wide error code.
| IMPORT_C void | SetObserver | ( | MPtiObserver * | aObserver | ) |
Sets observer. See PtiObserver.h for observer API details.
| Parameter | Description |
|---|---|
| aObserver | A observer to be set. |
Selects Chinese character (meaning that user has accepted character to be inserted into editor). Predictive candidate lists will be updated with Chinese characters associated to selected character. Associated charcaters can be accessed via ...CandidatePage() -methods. Return value can be ignored in current implementation.
| Parameter | Description |
|---|---|
| aChar | A character to be selected. |
Returns: Please ignore the return value.
Turns reordering feature on or off. This method can be used only if active core object supports reordering feature. It is also possible that core object supports reordering feature, but it can't be turned off. Reordeing feature keeps track of usage frequency for entered words and promotes most frequently used words in the candidate list. Details depend on underlying prediction engine.
| Parameter | Description |
|---|---|
| aStatus | New status for reordering feature. |
Returns: KErrNone if success, otherwise an error code.
Sets tone mark directly. This method is used if client wants to override default core dependant tone mark set or traditional cycle-through tone mark system doesn't suit its porposes.
| Parameter | Description |
|---|---|
| aToneMark | Tone mark to be set. |
Returns: ETrue if tone mark was legal, ie. produced candidates. EFalse otherwise.
Creates secondary data file for given core object. Existing file will be overwritten. This data file may contain any additional data that the core object needs to store between sessions (for example used word dictionary, if the engine keeps reordering data in separate memory area).
| Parameter | Description |
|---|---|
| aCoreUid | Uid number for requesting core object. |
| aIndexNumber | Index number. Core object may use this parameter for numerating data files if it needs more than one of then. Otherwise zero. |