CPtiEngine Class Reference

Link against: ptiengine.lib

#include <PtiEngine.h>

Detailed Description

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.


Public Member Functions

IMPORT_C ~CPtiEngine ()
 Destructor.
IMPORT_C TInt ActivateLanguageL (TInt aEpocLanguageID, TPtiEngineInputMode aMode=EPtiEngineInputModeNone)
 Activates language in requested input mode.
IMPORT_C void CloseCurrentLanguageL ()
 Closes active language.
IMPORT_C MPtiCoreInfo * CoreInfo (TPtiEngineInputMode aMode) const
 Returns core info structure for given input mode.
IMPORT_C MPtiLanguage * CurrentLanguage ()
 Returns pointer to currently active language.
IMPORT_C MPtiLanguage * GetLanguage (TInt aCode) const
 Returns pointer to requested language.
IMPORT_C TInt NumberOfCandidates ()
 Returns number of candidate words for current input sequence.
IMPORT_C TPtrC AppendKeyPress (TPtiKey aKey)
 This method handles key press and forwards it to correct core object depending on active language and input mode.
IMPORT_C TPtrC DeleteKeyPress ()
 Deletes last character in current word buffer and updates candidate list accordingly.
IMPORT_C TInt AddCoreL (const TDesC &aFileName, TBool aUseDefaultUserDictionary=EFalse)
 DEPRECATED (will leave if called).
IMPORT_C TInt AddCoreL (const TUid aCoreUid, TBool aUseDefaultUserDictionary=EFalse)
 Loads and constructs new core object.
IMPORT_C TInt GetCandidateListL (CDesCArray &aList)
 Returns list of candidate words for current input sequence.
IMPORT_C TInt GetNextWordCandidateListL (CDesCArray &aList)
 Returns next word candidate list.
IMPORT_C TPtrC FirstCandidate ()
 Returns pointer to first word in candidate list.
IMPORT_C TPtrC NextCandidate ()
 Returns pointer to next word in candidate list.
IMPORT_C TPtrC PreviousCandidate ()
 Returns pointer to previous word in candidate list.
IMPORT_C TInt SetInputMode (TPtiEngineInputMode aMode)
 Activates requested input mode for active language.
IMPORT_C TPtiEngineInputMode InputMode () const
 Returns active input mode.
IMPORT_C TInt SetReordering (TBool aStatus)
 Turns reordering feature on or off.
IMPORT_C TInt SetCurrentWord (TPtrC aWord)
 Fills text buffer with given word, refreshes current input sequence and asks current core object to update candidate list accordingly.
IMPORT_C TPtrC CurrentWord ()
 Returns pointer to current word buffer.
IMPORT_C void ClearCurrentWord ()
 Clears current word buffer.
IMPORT_C void SetCase (TPtiTextCase aCase)
 Sets text case.
IMPORT_C TPtiTextCase Case () const
 Returns active text case.
IMPORT_C void GetAvailableLanguagesL (CArrayFix< TInt > *aResult)
 Returns list of available input languages.
IMPORT_C void GetAvailableLanguagesL (RArray< TInt > &aResult)
 Returns list of available input languages.
IMPORT_C TInt NumberOfLanguages () const
 Returns number of available input languages.
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.
IMPORT_C MPtiUserDictionary * AttachUserDictionaryL (TDesC &aFileName)
 Attach user dictionary in given file to core for requested input mode.
IMPORT_C MPtiUserDictionary * AttachDefaultUserDictionaryL (TUid aCoreUid, TInt aSymbolClass)
 Attach default user dictionary.
IMPORT_C TInt DetachUserDictionary (TDesC &aFileName)
 Detaches currently attached user dictionary.
IMPORT_C TInt DetachUserDictionary (TInt aId)
 Detaches currently attached user dictionary.
IMPORT_C void GetLocalizedLanguageName (TInt aLangCode, TDes &aResult)
 Returns localized language name for given language.
IMPORT_C TInt CommitCurrentWord ()
 Commits current word.
IMPORT_C TInt CharConversion (TPtiCharConversion aType, TAny *aInput, TInt aInputLength, TAny *aOutput)
 Converts given string of characters to one coding system to another.
IMPORT_C TUint32 AvailableCharConversions () const
 Returns value indicating currently available character conversions.
IMPORT_C TInt SetExternalKeyMapL (TPtiEngineInputMode aMode, TPtiKey aKey, TDesC &aKeyMap, TPtiTextCase aCase)
 Replaces key map for single key.
IMPORT_C TPtiKey LastEnteredKey () const
 Returns last entered key press.
IMPORT_C TPtrC8 CurrentInputSequence () const
 Returns current input sequence (a list of key presses).
IMPORT_C TInt GetSpelling (TUint16 aInput, TDes &aOutput, TPtiSpelling aType)
 Returns alternate spelling for given character.
IMPORT_C TInt CancelTimerActivity ()
 Front end processeor uses this method for indicating PtiEngine that all key press related timers should be canceled.
IMPORT_C TPtiKey CharacterToKey (TUint16 aChar)
 Returns key for given character.
IMPORT_C TInt AddUserDictionaryEntry (MPtiUserDictionaryEntry &aEntry)
 Adds new entry (in most cases a word) to default user dictionary of currently active core object.
IMPORT_C TInt AddUserDictionaryEntry (MPtiUserDictionaryEntry &aEntry, TInt aId)
 Adds entry to specific user dictionary.
IMPORT_C TInt RemoveEntryFromUserDictionary (MPtiUserDictionaryEntry &aEntry)
 Removes entry from default user dictionary of currently active core object.
IMPORT_C TInt RemoveEntryFromUserDictionary (MPtiUserDictionaryEntry &aEntry, TInt aId)
 Removes word from specific user dictionary.
IMPORT_C TInt NumberOfEntriesInUserDictionary ()
 Returns number of entries in default user dictionary.
IMPORT_C TInt GetUserDictionaryEntry (TInt aIndex, MPtiUserDictionaryEntry &aResult)
 Returns entry for given index in default user dictionary.
IMPORT_C MPtiUserDictionary * DefaultUserDictionary (TPtiEngineInputMode aMode)
 Returns default user dictionary for given input mode.
IMPORT_C void SetObserver (MPtiObserver *aObserver)
 Sets observer.
IMPORT_C MPtiObserver * Observer ()
 Returns current observer.
IMPORT_C TInt HandleCommandL (TPtiEngineCommand aCommand, TAny *aParams=NULL)
 General command handling method.
IMPORT_C TPtrC CandidatePage ()
 Returns pointer to current Chinese candidate page.
IMPORT_C TBool NextCandidatePage ()
 Changes to next Chinese candidate page.
IMPORT_C TBool PreviousCandidatePage ()
 Changes to previous Chinese candidate page.
IMPORT_C TBool MoreCandidatePages ()
 Returns a boolean value indicating whether there are more candidate pages available.
IMPORT_C void SetCandidatePageLength (TInt aLength)
 Sets length of Chinese candidate page.
IMPORT_C TPtrC GetPhoneticSpelling (TInt aIndex) const
 Returns phonetic spelling for current input.
IMPORT_C TInt PhoneticSpellingCount () const
 Returns a value specifying how many phonetic spellings there is available for current input.
IMPORT_C TBool SelectPhoneticSpelling (TInt aIndex)
 Selects given phonetic spelling for current input.
IMPORT_C TInt SelectedPhoneticSpelling () const
 Returns the index of currently selected phonetic spelling.
IMPORT_C void EnableToneMarks (TBool aValue)
 Enables or disables tone marks.
IMPORT_C void ResetToneMark ()
 Resets tone mark.
IMPORT_C TBool ToneMark (TText &aToneMark) const
 Returns unicode value for current tone mark.
IMPORT_C TBool IsToneMarkValidForSpelling () const
 Returns boolean value indicating whether current tone mark is valid for spelling.
IMPORT_C TBool IncrementToneMark (TBool aOverrideInvalid)
 Cycles to next tone mark in core related tone mark list.
IMPORT_C TBool SetPredictiveChineseChar (const TDesC &aChar)
 Selects Chinese character (meaning that user has accepted character to be inserted into editor).
IMPORT_C MPtiEngineCompositionDataInterface * CompositionData ()
 Returns pointer to composition data interface (used with Japanese input).
IMPORT_C TPtrC ReadingTextL ()
 Returns reading text for Japanese input.
IMPORT_C void GetModeNameIndexL (TPtiChineseVariant aVariant, RArray< TInt > &aResult)
 Returns mode name index table for given Chinese variant.
IMPORT_C TInt GetPhoneticSpellingsL (CDesCArray &aList)
 Fills list with all the phonetic spellings for current input sequence.
IMPORT_C TInt GetChinesePhraseCandidatesL (CDesCArray &aList)
 Fills list with phrase candidates for currently selected phonetic spelling.
IMPORT_C TBool SetToneMark (TInt aToneMark)
 Sets tone mark directly.
IMPORT_C TBool IsQwertyBasedMode (TPtiEngineInputMode aMode) const
 A convinience method for cheking qwerty based input mode.
IMPORT_C void CreateDefaultUserDictionaryFileL (TUid aCoreUid, TInt aSymbolClass)
 Creates empty user default dictionary file for given core object and initializes it to PtiEngine user dictionary format.
IMPORT_C void WriteSecondaryDataFileL (TUid aCoreUid, TInt aIndexNumber, HBufC8 *aData)
 Creates secondary data file for given core object.
IMPORT_C HBufC8 * ReadSecondaryDataFileL (TUid aCoreUid, TInt aIndexNumber)
 Returns a heap buffer containing data from given secondary data file.
IMPORT_C void MappingDataForKey (TPtiKey aKey, TDes &aResult, TPtiTextCase aCase)
 Returns keymapping data for given key.
IMPORT_C void GetNumericModeKeysForQwertyL (TInt aLanguage, RArray< TPtiNumericKeyBinding > &aResult)
 Qwerty input mode has different keymapping layout for each language.
IMPORT_C HBufC * GetCandidatesByInputString (const TDesC &aInputString, RPointerArray< HBufC > &aList, const TBool aIsPredictive)
IMPORT_C MPtiHwrRecognizer * GetHwrRecognizerL (TLanguage aLanguage)
 Get first hwr implementation support the specified language.
IMPORT_C MPtiHwrRecognizer * GetHwrRecognizerL (TInt aImpId)
 Get hwr implementation by give implementation uid.
IMPORT_C RArray< TUid > & ListHwrRecognizerL (TLanguage aLanguage)
 Get hwr implementation uid list which support given language.
IMPORT_C void GetHwrAvailableLanguagesL (RArray< TInt > &aResult)
 Get hwr available languages list.
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.
IMPORT_C TInt SetAutoSubstitution (TBool aStatus)
 Turns auto substitution feature on or off.
IMPORT_C TInt AddAutoSubstitutionEntry (const TDesC &aShortcut, const TDesC &aSubstituition)
 Adds new auto substitution entry to database.
IMPORT_C TInt DeleteAutoSubstitutionEntry (const TDesC &aShortcut)
 Remove auto substitution entry.
IMPORT_C TInt NumberOfAutoSubstitutionEntries () const
 Returns the number of auto substitution entries in auto subst db.
IMPORT_C TInt GetAutoSubstitutionEntry (TInt aIndex, TDes &aShortcut, TDes &aSubstitution)
 Return auto substitution entry for given index.
IMPORT_C TPtiKeyboardType KeyboardType () const
 Returns currently selected qwerty keyboard type.
IMPORT_C TInt SetKeyboardType (TPtiKeyboardType aType)
 Sets keyboard type for non-virtual keyboard.
IMPORT_C void KeyboardTypesSupportedByLanguageL (TInt aLanguage, RArray< TPtiKeyboardType > &aResult)
 Lists keyboard blocks available in keymapping data for given language.
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.
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.
IMPORT_C TInt SetNumberCandidateStatus (TBool aStatus)
 Sets a boolean value indicating whether number candidates are included to predictive candidate list.
IMPORT_C TBool IsValidKey (TPtiKey aKey) const
 Returns a boolean value indicating whether given scan code is allowed for current input mode.
IMPORT_C TInt SetMaxLengthForAutoCompletedCandidates (TInt aMaxLength)
 Sets the maximum length for auto completed words.
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.
IMPORT_C TPtrC8 CaseSequence ()
 Returns text case buffer.
IMPORT_C TInt AddPhrase (const TDesC &aNewPhrase)
 Some prediction engines support next word prediction feature but require database to be pre-filled with suitable phrase data.

Static Public Member Functions

static IMPORT_C CPtiEngine * NewL (TBool aUseDefaultUserDictionary=EFalse)
 Two phase constructor.
static IMPORT_C CPtiEngine * NewL (const TDesC &aCoreName, TBool aUseDefaultUserDictionary=EFalse)
 Two phase constructor.
static IMPORT_C CPtiEngine * NewL (const TUid aCoreUid, TBool aUseDefaultUserDictionary=EFalse)
 Two phase constructor.
static IMPORT_C void ListAvailablePhysicalKeyboardsL (RArray< TPtiKeyboardType > &aResult)
 Returns a list containing keyboard type values for all available physical keyboards connected to the device.

Constructor & Destructor Documentation

IMPORT_C CPtiEngine::~CPtiEngine (   ) 
 

Destructor.

Member Function Documentation

IMPORT_C TInt CPtiEngine::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.

Since:
S60 V2.6
Parameters:
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.
IMPORT_C TInt CPtiEngine::AddAutoSubstitutionEntry ( const TDesC &  aShortcut,
const TDesC &  aSubstituition
) 
 

Adds new auto substitution entry to database.

If entry for given shorcut already exists, then the old entry will be automatically deleted.

Since:
S60 V5.0
Parameters:
aShortcut Shortcut part for new entry.
aSubstitution Substitution part for new entry.
Returns:
KErrNone or system wide error code.
IMPORT_C TInt CPtiEngine::AddCoreL ( const TUid  aCoreUid,
TBool  aUseDefaultUserDictionary = EFalse
) 
 

Loads and constructs new core object.

Core object is added to the list of available cores and is ready to be used after that.

Since:
S60 V2.6
Parameters:
aCoreUid Uid for core plugin.
aUseDefaultUserDictionary ....
Returns:
KErrNone if operation was successful or system wide error code.
IMPORT_C TInt CPtiEngine::AddCoreL ( const TDesC &  aFileName,
TBool  aUseDefaultUserDictionary = EFalse
) 
 

DEPRECATED (will leave if called).

IMPORT_C TInt CPtiEngine::AddPhrase ( const TDesC &  aNewPhrase  ) 
 

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.

Since:
S60 V5.0
Parameters:
aNewPhrase New phrase to be added to phrase dictionary.
Returns:
KErrNone or system wide error code.
IMPORT_C TInt CPtiEngine::AddUserDictionaryEntry ( MPtiUserDictionaryEntry &  aEntry,
TInt  aId
) 
 

Adds entry to specific user dictionary.

Since:
S60 V2.6
Parameters:
aEntry An entry to be added to dictionary.
aId User dictionary id.
Returns:
KErrNone if success, otherwise system wide error code.
IMPORT_C TInt CPtiEngine::AddUserDictionaryEntry ( MPtiUserDictionaryEntry &  aEntry  ) 
 

Adds new entry (in most cases a word) to default user dictionary of currently active core object.

Since:
S60 V2.6
Parameters:
aEntry An entry to be added to dictionary.
Returns:
KErrNone if success, otherwise system wide error code.
IMPORT_C TPtrC CPtiEngine::AppendKeyPress ( TPtiKey  aKey  ) 
 

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.

Since:
S60 V2.6
Parameters:
aKey Key code.
Returns:
Pointer to current word buffer.
IMPORT_C MPtiUserDictionary* CPtiEngine::AttachDefaultUserDictionaryL ( TUid  aCoreUid,
TInt  aSymbolClass
) 
 

Attach default user dictionary.

Since:
S60 V2.6
Parameters:
aCoreUid Uid for owner core object.
aSymbolClass Symbol class for udb data.
Returns:
Pointer to user dictionary object. NULL if failure.
IMPORT_C MPtiUserDictionary* CPtiEngine::AttachUserDictionaryL ( TDesC &  aFileName  ) 
 

Attach user dictionary in given file to core for requested input mode.

Since:
S60 V2.6
Parameters:
aFileName User dictionary file name.
Returns:
Pointer to user dictionary object. NULL if failure.
IMPORT_C TUint32 CPtiEngine::AvailableCharConversions (   )  const
 

Returns value indicating currently available character conversions.

Since:
S60 V2.6
Returns:
Currently available character conversions. There is a bit set for each available char conversion. See definition of TPtiCharConversion.
IMPORT_C TInt CPtiEngine::CancelTimerActivity (   ) 
 

Front end processeor uses this method for indicating PtiEngine that all key press related timers should be canceled.

Since:
S60 V2.6
Returns:
KErrNone if timers were successfully canceled. KErrNotFound if no active timers were found.
IMPORT_C TPtrC CPtiEngine::CandidatePage (   ) 
 

Returns pointer to current Chinese candidate page.

Since:
S60 V2.6
Returns:
Pointer to current Chinese candidate page.
IMPORT_C TPtiTextCase CPtiEngine::Case (   )  const
 

Returns active text case.

Since:
S60 V2.6
Returns:
Current text case.
IMPORT_C TPtrC8 CPtiEngine::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.

Since:
S60 V5.0
Returns:
A string of EPtiTextCase values.
IMPORT_C TPtiKey CPtiEngine::CharacterToKey ( TUint16  aChar  ) 
 

Returns key for given character.

Returned key depends on current language and input mode.

Since:
S60 V2.6
Parameters:
aChar Requested character.
Returns:
Key for requested character. EPtiKeyNone if no key was found for given character.
IMPORT_C TInt CPtiEngine::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.

Since:
S60 V2.6
Parameters:
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 CPtiEngine::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.

Since:
S60 V2.6
IMPORT_C void CPtiEngine::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.

Since:
S60 V2.6
IMPORT_C TInt CPtiEngine::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.

Since:
S60 V2.6
Returns:
KErrNone if success. KErrNoActiveLanguage if no active language.
IMPORT_C MPtiEngineCompositionDataInterface* CPtiEngine::CompositionData (   ) 
 

Returns pointer to composition data interface (used with Japanese input).

Since:
S60 V2.6
Returns:
Pointer to composition data interface.
IMPORT_C MPtiCoreInfo* CPtiEngine::CoreInfo ( TPtiEngineInputMode  aMode  )  const
 

Returns core info structure for given input mode.

Since:
S60 V2.6
Returns:
Pointer to core info object. NULL if core for given input mode was not found.
IMPORT_C void CPtiEngine::CreateDefaultUserDictionaryFileL ( TUid  aCoreUid,
TInt  aSymbolClass
) 
 

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.

Since:
S60 V3.0
Parameters:
aCoreUid Uid for requesting core object.
aSymbolClass Symbol class for udb data.
IMPORT_C TInt CPtiEngine::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.

Since:
S60 V2.6
Parameters:
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 CPtiEngine::CurrentInputSequence (   )  const
 

Returns current input sequence (a list of key presses).

Bytes in returned descriptor are TPtiKey enum values.

Since:
S60 V2.6
Returns:
a descriptor containing current input sequence.
IMPORT_C MPtiLanguage* CPtiEngine::CurrentLanguage (   ) 
 

Returns pointer to currently active language.

Since:
S60 V2.6
Returns:
Pointer to currently active language object.
IMPORT_C TPtrC CPtiEngine::CurrentWord (   ) 
 

Returns pointer to current word buffer.

Since:
S60 V2.6
Returns:
Pointer to current word buffer.
IMPORT_C MPtiUserDictionary* CPtiEngine::DefaultUserDictionary ( TPtiEngineInputMode  aMode  ) 
 

Returns default user dictionary for given input mode.

Since:
S60 V2.6
Returns:
User dictionary for given input mode. NULL if wasn't found.
IMPORT_C TInt CPtiEngine::DeleteAutoSubstitutionEntry ( const TDesC &  aShortcut  ) 
 

Remove auto substitution entry.

Since:
S60 V5.0
Parameters:
aShortcut Shortcut for auto substitution entry to be removed.
Returns:
KErrNone or system wide error code. KErrNotFound if given shortcut was nout found.
IMPORT_C TPtrC CPtiEngine::DeleteKeyPress (   ) 
 

Deletes last character in current word buffer and updates candidate list accordingly.

Since:
S60 V2.6
Returns:
Pointer to current word buffer.
IMPORT_C TInt CPtiEngine::DetachUserDictionary ( TInt  aId  ) 
 

Detaches currently attached user dictionary.

Since:
S60 V2.6
Parameters:
aId User dictionary id.
Returns:
KErrNone if success, otherwise system wide error code.
IMPORT_C TInt CPtiEngine::DetachUserDictionary ( TDesC &  aFileName  ) 
 

Detaches currently attached user dictionary.

Since:
S60 V2.6
Parameters:
aFileName User dictionary file name.
Returns:
KErrNone if success, otherwise system wide error code.
IMPORT_C void CPtiEngine::EnableToneMarks ( TBool  aValue  ) 
 

Enables or disables tone marks.

Since:
S60 V2.6
Parameters:
aValue A boolean value specifying whether tone marks will be on or off.
IMPORT_C const RArray<TPtiNumericKeyBinding>& CPtiEngine::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.

Since:
S60 V5.0
Parameters:
aLanguage Language id for requested mappings.
aKeyboardType keyboard type.
aResult Array for storing resulting mappings.
IMPORT_C const RArray<TPtiNumericKeyBinding>& CPtiEngine::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.

Since:
S60 V3.2
Parameters:
aLanguage Language id for requested mappings.
aResult Array for storing resulting mappings.
IMPORT_C TPtrC CPtiEngine::FirstCandidate (   ) 
 

Returns pointer to first word in candidate list.

If there isn't any candidate words the returned pointer will point to empty descriptor.

Since:
S60 V2.6
Returns:
Pointer to first word in candidate list.
IMPORT_C TInt CPtiEngine::GetAutoSubstitutionEntry ( TInt  aIndex,
TDes &  aShortcut,
TDes &  aSubstitution
) 
 

Return auto substitution entry for given index.

Since:
S60 V5.0
Parameters:
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 void CPtiEngine::GetAvailableLanguagesL ( RArray< TInt > &  aResult  ) 
 

Returns list of available input languages.

Since:
S60 V2.6
Parameters:
aResult List to be filled with language codes.
IMPORT_C void CPtiEngine::GetAvailableLanguagesL ( CArrayFix< TInt > *  aResult  ) 
 

Returns list of available input languages.

Since:
S60 V2.6
Parameters:
aResult List to be filled with language codes.
IMPORT_C TInt CPtiEngine::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.

Since:
S60 V2.6
Parameters:
aList a list to be filled with candidate words.
Returns:
KErrNone if success, otherwise system wide error code.
IMPORT_C HBufC* CPtiEngine::GetCandidatesByInputString ( const TDesC &  aInputString,
RPointerArray< HBufC > &  aList,
const TBool  aIsPredictive
) 
 
IMPORT_C TInt CPtiEngine::GetChinesePhraseCandidatesL ( CDesCArray &  aList  ) 
 

Fills list with phrase candidates for currently selected phonetic spelling.

Since:
S60 V2.6
Parameters:
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 void CPtiEngine::GetHwrAvailableLanguagesL ( RArray< TInt > &  aResult  ) 
 

Get hwr available languages list.

Since:
S60 V4.0
Parameters:
aResult Carry the hwr available languages list on return
Returns:
None
IMPORT_C MPtiHwrRecognizer* CPtiEngine::GetHwrRecognizerL ( TInt  aImpId  ) 
 

Get hwr implementation by give implementation uid.

Since:
S60 V4.0
Parameters:
aImpId Given specific implementation uid
Returns:
The pointer points to hwr implementation instance
IMPORT_C MPtiHwrRecognizer* CPtiEngine::GetHwrRecognizerL ( TLanguage  aLanguage  ) 
 

Get first hwr implementation support the specified language.

Since:
S60 V4.0
Parameters:
aLanguage The language that hwr implementation supported
Returns:
The pointer points to hwr implementation instance
IMPORT_C MPtiLanguage* CPtiEngine::GetLanguage ( TInt  aCode  )  const
 

Returns pointer to requested language.

Since:
S60 V2.6
Parameters:
aCode Language code for requested language.
Returns:
Pointer to requested language object. NULL if no language for given code.
IMPORT_C void CPtiEngine::GetLocalizedLanguageName ( TInt  aLangCode,
TDes &  aResult
) 
 

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.

Since:
S60 V2.6
Parameters:
Epoc language code.
Returns:
Localized language name.
IMPORT_C void CPtiEngine::GetModeNameIndexL ( TPtiChineseVariant  aVariant,
RArray< TInt > &  aResult
) 
 

Returns mode name index table for given Chinese variant.

Since:
S60 V2.6
Parameters:
aVariant Chinese variant to be queried.
aResult Resulting index table.
IMPORT_C TInt CPtiEngine::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.

Since:
S60 V2.6
Parameters:
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 CPtiEngine::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.

Since:
S60 V5.0
Parameters:
aLanguage Language id for requested mappings.
aResult Array for storing resulting mappings.
aKeyboardType keyboard type.
IMPORT_C void CPtiEngine::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.

Since:
S60 V3.1
Parameters:
aLanguage Language id for requested mappings.
aResult Array for storing resulting mappings.
IMPORT_C TPtrC CPtiEngine::GetPhoneticSpelling ( TInt  aIndex  )  const
 

Returns phonetic spelling for current input.

Since:
S60 V2.6
Parameters:
aIndex Index of requested phonetic spelling.
Returns:
Pointer to phonetic spelling.
IMPORT_C TInt CPtiEngine::GetPhoneticSpellingsL ( CDesCArray &  aList  ) 
 

Fills list with all the phonetic spellings for current input sequence.

Since:
S60 V2.6
Parameters:
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 CPtiEngine::GetSpelling ( TUint16  aInput,
TDes &  aOutput,
TPtiSpelling  aType
) 
 

Returns alternate spelling for given character.

Since:
S60 V2.6
Parameters:
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 CPtiEngine::GetUserDictionaryEntry ( TInt  aIndex,
MPtiUserDictionaryEntry &  aResult
) 
 

Returns entry for given index in default user dictionary.

Since:
S60 V2.6
Parameters:
aIndex An index for requested entry.
aResult Result will be stored here.
Returns:
KErrNone if success, otherwise system wide error code.
IMPORT_C TInt CPtiEngine::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.

Since:
S60 V2.6
Parameters:
aCommand A command to be handled.
aParams Possible input data or parameters for command.
Returns:
KErrNone if success, otherwise an error code.
IMPORT_C TBool CPtiEngine::IncrementToneMark ( TBool  aOverrideInvalid  ) 
 

Cycles to next tone mark in core related tone mark list.

Since:
S60 V2.6
Parameters:
aOverrideInvalid Indicates whether invalid tone marks should be skipped.
Returns:
ETrue If new tone mark was found and set. EFalse Otherwise.
IMPORT_C TPtiEngineInputMode CPtiEngine::InputMode (   )  const
 

Returns active input mode.

Since:
S60 V2.6
Returns:
Current input mode.
IMPORT_C TBool CPtiEngine::IsQwertyBasedMode ( TPtiEngineInputMode  aMode  )  const
 

A convinience method for cheking qwerty based input mode.

Since:
S60 V3.0
Parameters:
aMode Input mode to be checked.
Returns:
ETrue If aMode is qwerty based input mode. EFalse Otherwise.
IMPORT_C TBool CPtiEngine::IsToneMarkValidForSpelling (   )  const
 

Returns boolean value indicating whether current tone mark is valid for spelling.

Since:
S60 V2.6
Returns:
ETrue if tone mark is valid for spelling. EFalse otherwise
IMPORT_C TBool CPtiEngine::IsValidKey ( TPtiKey  aKey  )  const
 

Returns a boolean value indicating whether given scan code is allowed for current input mode.

Since:
S60 V5.0
Parameters:
aKey A key to be queried.
Returns:
ETrue if given scan code is allowed fore currently active input mode. EFalse otherwise.
IMPORT_C TPtiKeyboardType CPtiEngine::KeyboardType (   )  const
 

Returns currently selected qwerty keyboard type.

Since:
S60 V5.0
Returns:
Currently selected keyboard type.
IMPORT_C void CPtiEngine::KeyboardTypesSupportedByLanguageL ( TInt  aLanguage,
RArray< TPtiKeyboardType > &  aResult
) 
 

Lists keyboard blocks available in keymapping data for given language.

Since:
S60 V5.0
Parameters:
aLanguage A language to be queried.
aResult Resulting list of keyboard types will we stored here.
IMPORT_C TPtiKey CPtiEngine::LastEnteredKey (   )  const
 

Returns last entered key press.

Since:
S60 V2.6
Returns:
last entered key press.
static IMPORT_C void CPtiEngine::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.

Since:
S60 V5.0
Parameters:
aResult An array to be filled with available keyboard types.
IMPORT_C RArray<TUid>& CPtiEngine::ListHwrRecognizerL ( TLanguage  aLanguage  ) 
 

Get hwr implementation uid list which support given language.

Since:
S60 V4.0
Parameters:
aLanguage The language that hwr implementation supported
Returns:
The array of implementation uid list
IMPORT_C void CPtiEngine::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.

Since:
S60 V3.0
Parameters:
aKey A key to be queried.
aResult Resulting mapping data.
IMPORT_C void CPtiEngine::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.

Since:
S60 V5.0
IMPORT_C TBool CPtiEngine::MoreCandidatePages (   ) 
 

Returns a boolean value indicating whether there are more candidate pages available.

Since:
S60 V2.6
Returns:
ETrue if there are more candidate pages available. EFalse otherwise.
static IMPORT_C CPtiEngine* CPtiEngine::NewL ( const TUid  aCoreUid,
TBool  aUseDefaultUserDictionary = EFalse
)  [static]
 

Two phase constructor.

Parameters:
aCoreUid 
aUseDefaultUserDictionary 
Returns:
static IMPORT_C CPtiEngine* CPtiEngine::NewL ( const TDesC &  aCoreName,
TBool  aUseDefaultUserDictionary = EFalse
)  [static]
 

Two phase constructor.

NOTE: THIS METHOD IS DEPRECATED AND WILL LEAVE WHEN CALLED.

static IMPORT_C CPtiEngine* CPtiEngine::NewL ( TBool  aUseDefaultUserDictionary = EFalse  )  [static]
 

Two phase constructor.

Parameters:
aUseDefaultUserDictionary 
Returns:
IMPORT_C TPtrC CPtiEngine::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.

Since:
S60 V2.6
Returns:
Pointer to next word in candidate list.
IMPORT_C TBool CPtiEngine::NextCandidatePage (   ) 
 

Changes to next Chinese candidate page.

Since:
S60 V2.6
Returns:
ETrue if success. EFalse if there are no more candidate pages.
IMPORT_C TInt CPtiEngine::NumberOfAutoSubstitutionEntries (   )  const
 

Returns the number of auto substitution entries in auto subst db.

Since:
S60 V5.0
Returns:
Number of entries in auto substitution db. Zero if the feature is not supported or is not activated.
IMPORT_C TInt CPtiEngine::NumberOfCandidates (   ) 
 

Returns number of candidate words for current input sequence.

Since:
S60 V2.6
Returns:
number of cadidate words.
IMPORT_C TInt CPtiEngine::NumberOfEntriesInUserDictionary (   ) 
 

Returns number of entries in default user dictionary.

Since:
S60 V2.6
Returns:
Number of entries in default user dictionary. KErrNotSupported if core can't return requested value.
IMPORT_C TInt CPtiEngine::NumberOfLanguages (   )  const
 

Returns number of available input languages.

Since:
S60 V2.6
Returns:
Number of available languages.
IMPORT_C MPtiObserver* CPtiEngine::Observer (   ) 
 

Returns current observer.

Since:
S60 V2.6
Returns:
Pointer to current observer object.
IMPORT_C TInt CPtiEngine::PhoneticSpellingCount (   )  const
 

Returns a value specifying how many phonetic spellings there is available for current input.

Since:
S60 V2.6
Returns:
Number of phonetic spellings available for current input.
IMPORT_C TPtrC CPtiEngine::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.

Since:
S60 V2.6
Returns:
Pointer to previous word in candidate list.
IMPORT_C TBool CPtiEngine::PreviousCandidatePage (   ) 
 

Changes to previous Chinese candidate page.

Since:
S60 V2.6
Returns:
ETrue if success. EFalse if current candidate page is first.
IMPORT_C TPtrC CPtiEngine::ReadingTextL (   ) 
 

Returns reading text for Japanese input.

Since:
S60 V2.6
Returns:
Reading text for Japanese input.
IMPORT_C HBufC8* CPtiEngine::ReadSecondaryDataFileL ( TUid  aCoreUid,
TInt  aIndexNumber
) 
 

Returns a heap buffer containing data from given secondary data file.

Returns null if file is not found.

Since:
S60 V3.0
Parameters:
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 TInt CPtiEngine::RemoveEntryFromUserDictionary ( MPtiUserDictionaryEntry &  aEntry,
TInt  aId
) 
 

Removes word from specific user dictionary.

Since:
S60 V2.6
Parameters:
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 CPtiEngine::RemoveEntryFromUserDictionary ( MPtiUserDictionaryEntry &  aEntry  ) 
 

Removes entry from default user dictionary of currently active core object.

Since:
S60 V2.6
Parameters:
aEntry an entry to be removed from default dictionary.
Returns:
KErrNone if success, otherwise system wide error code.
IMPORT_C void CPtiEngine::ResetToneMark (   ) 
 

Resets tone mark.

Since:
S60 V2.6
IMPORT_C TInt CPtiEngine::SelectedPhoneticSpelling (   )  const
 

Returns the index of currently selected phonetic spelling.

Since:
S60 V2.6
Returns:
The index of currently selected phonetic spelling. Returned value is negative if there isn't phonetic spelling available.
IMPORT_C TBool CPtiEngine::SelectPhoneticSpelling ( TInt  aIndex  ) 
 

Selects given phonetic spelling for current input.

Since:
S60 V2.6
Parameters:
aIndex Index of requested phonetic spelling.
IMPORT_C TInt CPtiEngine::SetAutoSubstitution ( TBool  aStatus  ) 
 

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.

Since:
S60 V5.0
Parameters:
aStatus New status for auto substituiton feature
Returns:
KErrNone or system wide error code.
IMPORT_C void CPtiEngine::SetCandidatePageLength ( TInt  aLength  ) 
 

Sets length of Chinese candidate page.

Since:
S60 V2.6
Parameters:
aLength Length of Chinese candidate page.
IMPORT_C void CPtiEngine::SetCase ( TPtiTextCase  aCase  ) 
 

Sets text case.

Since:
S60 V2.6
Parameters:
aCase Text case to be set. Possible values are:
EPtiCaseLower Normal lower text case EPtiCaseUpper Normal capitalized text case EPtiCaseChrLower Lower text case when Chr key is being held EPtiCaseChrUpper Upper text case when Chr key is being held EPtiCaseFnLower Lower text case when Fn key is being held EPtiCaseFnUpper Upper text case when Fn key is being held
IMPORT_C TInt CPtiEngine::SetCurrentWord ( TPtrC  aWord  ) 
 

Fills text buffer with given word, refreshes current input sequence and asks current core object to update candidate list accordingly.

Since:
S60 V2.6
Parameters:
aWord a word to be set as current word.
Returns:
KErrNone if success, otherwise system wide error code.
IMPORT_C TInt CPtiEngine::SetExternalKeyMapL ( TPtiEngineInputMode  aMode,
TPtiKey  aKey,
TDesC &  aKeyMap,
TPtiTextCase  aCase
) 
 

Replaces key map for single key.

Since:
S60 V2.6
Parameters:
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 CPtiEngine::SetInputMode ( TPtiEngineInputMode  aMode  ) 
 

Activates requested input mode for active language.

Since:
S60 V2.6
Parameters:
aMode requested input mode.
Returns:
KErrNone if input mode was activated. KErrNotSupported if current language doesn't support requested input mode.
IMPORT_C TInt CPtiEngine::SetKeyboardType ( TPtiKeyboardType  aType  ) 
 

Sets keyboard type for non-virtual keyboard.

Keyboard type specifies which set of key mapping data is used.

Since:
S60 V5.0
Parameters:
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.
IMPORT_C TInt CPtiEngine::SetMaxLengthForAutoCompletedCandidates ( TInt  aMaxLength  ) 
 

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".

Since:
S60 V5.0
Parameters:
aMaxLength The maximum length fo auto completed candinates. Value 0 means no limit.
Returns:
KErrNone If the operation succeeded. Otherwise system wide error code.
IMPORT_C TInt CPtiEngine::SetNumberCandidateStatus ( TBool  aStatus  ) 
 

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.

Since:
S60 V5.0
Parameters:
aStatus A boolean value indicating whether number candidates are included to cadidate list.
Returns:
KErrNone or a system wide error code.
IMPORT_C void CPtiEngine::SetObserver ( MPtiObserver *  aObserver  ) 
 

Sets observer.

See PtiObserver.h for observer API details.

Since:
S60 V2.6
Parameters:
aObserver A observer to be set.
IMPORT_C TBool CPtiEngine::SetPredictiveChineseChar ( const TDesC &  aChar  ) 
 

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.

Since:
S60 V2.6
Parameters:
aChar A character to be selected.
Returns:
Please ignore the return value.
IMPORT_C TInt CPtiEngine::SetReordering ( TBool  aStatus  ) 
 

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.

Since:
S60 V2.6
Parameters:
aStatus New status for reordering feature.
Returns:
KErrNone if success, otherwise an error code.
IMPORT_C TBool CPtiEngine::SetToneMark ( TInt  aToneMark  ) 
 

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.

Since:
S60 V2.8
Parameters:
aToneMark Tone mark to be set.
Returns:
ETrue if tone mark was legal, ie. produced candidates. EFalse otherwise.
IMPORT_C TBool CPtiEngine::ToneMark ( TText &  aToneMark  )  const
 

Returns unicode value for current tone mark.

Since:
S60 V2.6
Parameters:
aToneMark resulting tone mark is store here.
Returns:
ETrue if tone mark was available. EFalse otherwise.
IMPORT_C void CPtiEngine::WriteSecondaryDataFileL ( TUid  aCoreUid,
TInt  aIndexNumber,
HBufC8 *  aData
) 
 

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).

Since:
S60 V3.0
Parameters:
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.
The documentation for this class was generated from the following file:
Copyright © Nokia Corporation 2001-2007
Back to top