/*
* Copyright (c) 2003-2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0""
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Global PtiEngine definitions
*
*/
#ifndef _PTI_DEFS_H
#define _PTI_DEFS_H
#include <e32keys.h>
#ifdef RD_HINDI_PHONETIC_INPUT
/* Indic Phonetic input */
/*
* Defines the state of the syllable. This is used by FEP for either committing
* the inline text or updating the inline text.
*/
enum TSyllableState
{
EIndicSyllableStateFirst,
EIndicSyllableStateInsideSyllable,
EIndicSyllableStateSyllableBroken,
EIndicSyllableStateLast
};
/*
* This is a structure that abstracts the phonetic argument and the response
* from the Indic phonetic core in a structure.
*/
typedef struct
{
TChar iChar;
TDes *iDest;
TSyllableState iState;
}TPhoneticArg;
#endif
const TInt KMaxLanguageNameLength = 50;
const TInt KMaxAutoSubstStringLength = 32;
const TInt KErrPtiEngineBase = (-1000); //based on the value of leave in PtiEngine
enum TPtiError
{
KErrNoActiveLanguage = KErrPtiEngineBase-1,
KErrLanguageNotFound = KErrPtiEngineBase-2,
KErrNoSuitableCore = KErrPtiEngineBase-3,
KErrNotAllowed = KErrPtiEngineBase-4,
KErrTooLongWord = KErrPtiEngineBase-5,
KErrInvalidWord = KErrPtiEngineBase-6,
KErrTooLongReading = KErrPtiEngineBase-7,
KErrInvalidReading = KErrPtiEngineBase-8,
KErrUserDic = KErrPtiEngineBase-9,
KErrInternalCoreError = KErrPtiEngineBase-10,
KErrLengthMismatch = KErrPtiEngineBase-11
};
/**
* Enumerations for all the possible input modes supported by PtiEngine.
* The modes actually available in the device depend on core object, resource
* and keyboard configuration.
* Here are short descriptions:
*
* EPtiEngineMultitapping
* Traditional text input method for latin-like languages, where
* a list of characters is associated to each keypad keys
* and user cycles through associated characters by consecutive key presses.
*
* EPtiEnginePredictive
* Predictive text input mode, where user presses only one key press per
* character and the prediction engine provides a list of candidate words
* associated top that key sequence.
*
* EPtiEngineWordCompletion
* This is same as EPtiEnginePredictive, except that prediction engine
* will include also complete words containing more characters than
* the number of key presses in current key sequence.
*
* EPtiEngineNumeric
* This is numeric input mode. All the languages suppor it, since it uses
* static keymappings built directly into PtiEngine. It works in same way
* as EPtiEngineMultitapping, except that keymapping data contains
* only number mode characters.
*
* EPtiEngineQwerty
* Standard qwerty-keyboard input mode for latin-like languages.
*
* EPtiEnginePinyin
* Chinese PinYin input mode for ITU-T keypad.
*
* EPtiEngineStroke
* Chinese Strokes input mode for ITU-T keypad.
*
* EPtiEngineStroke
* Chinese ZhuYin input mode for ITU-T keypad.
*
* EPtiEngineHirakanaKanji
* Japanese Hiragana/Kanji input mode.
*
* EPtiEngineHirakanaKanjiPredictive
* Predictive Japanese Hiragana/Kanji input mode.
*
* EPtiEngineKatakana
* Japanese Katakana input mode.
*
* EPtiEngineFullWitdthKatakana
* Japanese full width Katakana input mode.
*
* EPtiEngineFullWitdthKatakana
* Japanese full width numeric input mode.
*
* EPtiEngineFullWitdthAlphabet
* Japanese full width alphabet input mode.
*
* EPtiEngineHiragana
* Japanese Hiragana input mode.
*
* EPtiEnginePinyinByPhrase
* Chinese Pinyin phrase input. This is same as EPtiEnginePinyin, execpt that
* input string may contain pinyin words for several chinese characters.
*
* EPtiEngineZhuyinByPhrase
* Chinese Zinyin phrase input. This is same as EPtiEngineZhuyin, execpt that
* input string may contain zhuyin sequences for several chinese characters.
*
* EPtiEngineZhuyinQwerty
* Chinese Zhuyin input for qwerty keyboard.
*
* EPtiEngineZhuyinPhraseQwerty
* Chinese Zinyin phrase input for qwerty keyboard. This is same as EPtiEngineZhuyinQwerty,
* execpt that input string may contain zhuyin sequences for several chinese characters.
*
* EPtiEnginePinyinQwerty
* Chinese Pinyin input for qwerty keyboard.
*
* PtiEnginePinyinPhraseQwerty
* Same as EPtiEnginePinyinByPhrase but for qwerty keyboard
*
* EPtiEngineStrokeQwerty
* Same as EPtiEngineStroke but for qwerty keyboard
*
* EPtiEngineNormalCangjieQwerty
* Normal Chinese CangJie input for qwerty keyboard
* (CangJie is available only for qwerty).
*
* EPtiEngineEasyCangjieQwerty
* Easy Chinese CangJie input for qwerty keyboard
* (CangJie is available only for qwerty).
*
* EPtiEngineAdvCangjieQwerty
* Advanced Chinese CangJie input for qwerty keyboard
* (CangJie is available only for qwerty).
*
* EPtiEngineHiraganaKanjiQwerty
* Japanese Hiragana/Kanji input for qwerty keyboard.
*
* EPtiEngineHiraganaKanjiPredictiveQwerty
* Japanese predictive Hiragana/Kanji input for qwerty keyboard
*
* EPtiEngineKatakanaQwerty
* Japanese Half-width Katakana input for qwerty keyboard.
*
* EPtiEngineFullWidthKatakanaQwerty
* Japanese Full-width Katakana input for qwerty keyboard.
*
* EPtiEngineFullWidthNumericQwerty
* Japanese Full-width Alphabet input for qwerty keyboard.
*
* EPtiEngineFullWidthAlphabetQwerty
* Japanese Full-width Alphabet input for qwerty keyboard.
*
* EPtiEngineHiraganaQwerty
* Japanese Hiragana input for qwerty keyboard.
*
* EPtiEngineStrokeByPhrase, // Stroke phrase input.
* Chinese Stroke input for ITU-T keypad. Phrasal version.
*
* EPtiEngineStrokePhraseQwerty
* Chinese Stroke input for qwerty keyboard. Phrasal version.
*
* EPtiEngineQwertyPredictive, // "Sloppy type" input for qwerty keyboard.
* Intelligent qwerty input. Used for word completion and spell
* correction features for qwerty keyboard.
*
* EPtiEngineHalfQwerty
* Basic multitaping style text input for half-qwerty keyboard. The functionality
* of half-qwerty keyboard is same as conventional itu-t phone keypad, except that
* each key is associated with two basic characters (instead of three or four
* as in itu-t keypad). Character mapping is also organized to follow qwerty
* layout (instead of alphabetical order as in itu-t keypad).
*
* EPtiEngineHalfQwertyPredictive,
* Predictive text input for half-qwerty keyboard. The functionality
* of half-qwerty keyboard is same as conventional itu-t phone keypad, except that
* each key is associated with two basic characters(instead of three or four
* as in itu-t keypad). . Character mapping is also organized to follow qwerty
* layout (instead of alphabetical order as in itu-t keypad). This input mode
* is essentially same as EPtiEngineWordCompletion but uses half-qwerty keyboard.
*
* EPtiEngineInputModeIndicPhoneticMultitap
* Hindi phonetic input for itu-t keypad.
*
* EPtiEngineInputModeIndicPhoneticQwerty
* Hindi phonetic input for qwerty keyboard.
*
* EPtiEngineInputModeZhuyinMiniQwertyFind
* Zhuyin multitap input method for mini qwerty symbol find.
*
*/
enum TPtiEngineInputMode
{
EPtiEngineInputModeNone = 0,
EPtiEngineMultitapping, // Basic multitapping input for latin languages.
EPtiEnginePredictive, // Predictive input for latin languages.
EPtiEngineWordCompletion, // Predictive input with word completion for latin languages.
EPtiEngineNumeric, // Latin numeric input mode.
EPtiEngineQwerty, // Basic qwerty input mode.
EPtiEnginePinyin, // Chinese pinyin mode.
EPtiEngineStroke, // Chinese stroke mode.
EPtiEngineZhuyin, // Chinese zhuyin mode.
EPtiEngineHiraganaKanji, // Hiragana/Kanji mode.
EPtiEngineHiraganaKanjiPredictive, // Predictive Hiragana/Kanji mode.
EPtiEngineKatakana, // Half-width Katakana mode.
EPtiEngineFullWidthKatakana, // Full-width Katakana mode.
EPtiEngineFullWidthNumeric, // Full-width Alphabet mode (for Japanese input).
EPtiEngineFullWidthAlphabet, // Full-width Alphabet mode (for Japanese input).
EPtiEngineHiragana, // Hiragana only mode.
EPtiEnginePinyinByPhrase, // Pinyin phrase input.
EPtiEngineZhuyinByPhrase, // Zhuyin phrase input.
EPtiEngineZhuyinQwerty, // Zhuyin qwerty input.
EPtiEngineZhuyinPhraseQwerty, // Zhuyin phrase qwerty input.
EPtiEnginePinyinQwerty, // Pinyin qwerty input.
EPtiEnginePinyinPhraseQwerty, // Pinyin phrase qwerty input.
EPtiEngineStrokeQwerty, // Stroke qwerty input.
EPtiEngineNormalCangjieQwerty, // Normal Cangjie qwerty input
EPtiEngineEasyCangjieQwerty, // Easy Cangjie qwerty input
EPtiEngineAdvCangjieQwerty, // Advanced Cangjie qwerty input
EPtiEngineHiraganaKanjiQwerty, // Hiragana/Kanji qwerty input mode.
EPtiEngineHiraganaKanjiPredictiveQwerty, // Predictive Hiragana/Kanji qwerty input mode.
EPtiEngineKatakanaQwerty, // Half-width Katakana qwerty input mode.
EPtiEngineFullWidthKatakanaQwerty, // Full-width Katakana qwerty input mode.
EPtiEngineFullWidthNumericQwerty, // Full-width Alphabet qwerty input mode (for Japanese input).
EPtiEngineFullWidthAlphabetQwerty, // Full-width Alphabet qwerty input mode (for Japanese input).
EPtiEngineHiraganaQwerty, // Hiragana only qwerty input mode.
EPtiEnginePinyinVkb, // Chinese pinyin mode.
EPtiEngineStrokeVkb, // Chinese stroke mode.
EPtiEngineZhuyinVkb, // Chinese zhuyin mode.
EPtiEngineStrokeByPhrase, // Stroke phrase input.
EPtiEngineStrokePhraseQwerty, // Stroke phrase qwerty input.
EPtiEngineHiraganaKanjiVkb, // Hiragana/Kanji mode for VKB.
EPtiEngineHiraganaKanjiPredictiveVkb, // Predictive Hiragana/Kanji mode for VKB.
EPtiEngineHiraganaKanjiHwr, // Hiragana/Kanji mode for HWR.
EPtiEngineHiraganaKanjiPredictiveHwr, // Predictive Hiragana/Kanji mode for HWR.
EPtiEngineKatakanaVkb, // Half-width Katakana mode for VKB.
EPtiEngineFullWidthKatakanaVkb, // Full-width Katakana mode for VKB.
EPtiEngineHiraganaVkb, // Hiragana only qwerty input mode for VKB.
EPtiEngineNormalCangjieVkb,
EPtiEngineEasyCangjieVkb,
EPtiEngineAdvCangjieVkb,
EPtiEngineInputModeIndicPhoneticMultitap,
EPtiEngineInputModeIndicPhoneticQwerty,
EPtiEngineHiraganaKanjiVkbRomaji, // Hiragana/Kanji mode for VKB/FSQ Romaji input.
EPtiEngineHiraganaKanjiPredictiveVkbRomaji, // Predictive Hiragana/Kanji mode for VKB/FSQ Romaji input.
EPtiEngineQwertyPredictive, // "Sloppy type" input for qwerty keyboard.
EPtiEngineHalfQwerty,
EPtiEngineHalfQwertyPredictive,
EPtiEngineInputModeQwertyPredictive ,
EPtiEngineInputModeZhuyinMiniQwertyFind,
EPtiEnginePinyinPhraseHalfQwerty,
EPtiEngineStrokePhraseHalfQwerty,
EPtiEngineZhuyinPhraseHalfQwerty,
EPtiEngineMultitappingKorean, // Basic multitapping input for korean language.
EPtiEngineQwertyKorean,
EPtiEngineMaxInputModes = EPtiEngineQwertyKorean
};
/*
* Predictive qwerty error correction levels.
*/
enum TPtiErrorCorrectionLevel
{
EPtiErrorCorrectionLevelOff = 0,
EPtiErrorCorrectionLevelLow = 1,
EPtiErrorCorrectionLevelHigh = 2
};
/**
* Key enumerations for conventional (ITU-T) and qwerty keyboards.
* Constant names for qwerty keypad keys are named after scan code
* values of a device using English language keymappings. The
* actual character that will be inserted into editor buffer depends on
* keymappings of currently selected input language and may be something else
* than what enum name suggests. For example
* non-shifted EPtiKeyQwertyHash produces '#'-character if input language is
* English, but will produce '+'-character if
* input language is Danish, Norwegian, Swedish or Finnish.
* The key coordinates on standard 4x12 qwerty keypad are given in
* comments.
*/
enum TPtiKey
{
EPtiKeyNone = 0,
EPtiKey1 = '1',
EPtiKey2 = '2',
EPtiKey3 = '3',
EPtiKey4 = '4',
EPtiKey5 = '5',
EPtiKey6 = '6',
EPtiKey7 = '7',
EPtiKey8 = '8',
EPtiKey9 = '9',
EPtiKeyStar = '*',
EPtiKey0 = '0',
EPtiKeyHash = '#',
// alternate names
EPtiKeyPunct = EPtiKey1,
EPtiKeyABC = EPtiKey2,
EPtiKeyDEF = EPtiKey3,
EPtiKeyGHI = EPtiKey4,
EPtiKeyJKL = EPtiKey5,
EPtiKeyMNO = EPtiKey6,
EPtiKeyPQRS = EPtiKey7,
EPtiKeyTUV = EPtiKey8,
EPtiKeyWXYZ = EPtiKey9,
// qwerty keys
EPtiKeyQwerty1 = 0x31,
EPtiKeyQwerty2 = 0x32,
EPtiKeyQwerty3 = 0x33,
EPtiKeyQwerty4 = 0x34,
EPtiKeyQwerty5 = 0x35,
EPtiKeyQwerty6 = 0x36,
EPtiKeyQwerty7 = 0x37,
EPtiKeyQwerty8 = 0x38,
EPtiKeyQwerty9 = 0x39,
EPtiKeyQwerty0 = 0x30,
EPtiKeyQwertyPlus = 0x2b,
EPtiKeyQwertyMinus = EStdKeyMinus,
EPtiKeyQwertyComma = EStdKeyComma,
EPtiKeyQwertySemicolon = EStdKeySemiColon,
EPtiKeyQwertyFullstop = EStdKeyFullStop,
EPtiKeyQwertyHash = EStdKeyHash,
EPtiKeyQwertySlash = EStdKeyForwardSlash,
EPtiKeyQwertyApostrophe = EStdKeySingleQuote,
EPtiKeyQwertySpace = EStdKeySpace,
EPtiKeyQwertyAtCharacter = EStdKeySquareBracketRight,
EPtiKeyQwertyLeftShift = EStdKeyLeftShift, // Needed only for special cases.
EPtiKeyQwertyA = 0x41,
EPtiKeyQwertyB = 0x42,
EPtiKeyQwertyC = 0x43,
EPtiKeyQwertyD = 0x44,
EPtiKeyQwertyE = 0x45,
EPtiKeyQwertyF = 0x46,
EPtiKeyQwertyG = 0x47,
EPtiKeyQwertyH = 0x48,
EPtiKeyQwertyI = 0x49,
EPtiKeyQwertyJ = 0x4a,
EPtiKeyQwertyK = 0x4b,
EPtiKeyQwertyL = 0x4c,
EPtiKeyQwertyM = 0x4d,
EPtiKeyQwertyN = 0x4e,
EPtiKeyQwertyO = 0x4f,
EPtiKeyQwertyP = 0x50,
EPtiKeyQwertyQ = 0x51,
EPtiKeyQwertyR = 0x52,
EPtiKeyQwertyS = 0x53,
EPtiKeyQwertyT = 0x54,
EPtiKeyQwertyU = 0x55,
EPtiKeyQwertyV = 0x56,
EPtiKeyQwertyW = 0x57,
EPtiKeyQwertyX = 0x58,
EPtiKeyQwertyY = 0x59,
EPtiKeyQwertyZ = 0x5a
// ----> Half Qwerty
, EPtiKeyQwertyChr = EStdKeyLeftFunc // key (4, 4)
// Half Qwerty <----
};
/**
* Enumerations for PtiCore capabilities. These can be queries through
* MPtiCoreInfo::CapsBits().
* Here are descriptions:
*
* EWordCompletion
* The core object supports word completion -feature.
*
* EReordering
* The core object supports user dictionary reordering. This feature means that
* most commonly used words are moved up in prediction candidate
* list.
*
* ENextWordPrediction
* The core supports next word prediction feature. When this feature is
* enabled, prediction engine tries to guess next word based on previous word(s).
*
* ESupportUserDictionaries
* The core supports supports user dictionaries.
*
* ESupportSCTToneMarks
*
* ESupportCangjieInput
* The core object supports Chinese CangJie input.
*
* ESupportDualLanguage
* The core object supports dual language preditcion.
*
* ESupportAutoSubstitution
* The core object supports auto-substitution feature. This feature
* automatically expands predefined string to longer string.
* ie. "l8r" -> "later"
*/
enum TPtiEngineCapsBits
{
EWordCompletion = 0x01,
EReordering = 0x02,
ENextWordPrediction = 0x04,
ESupportUserDictionaries = 0x08,
ESupportSCTToneMarks = 0x10,
ESupportCangjieInput = 0x20,
EPreferedSpelling = 0x40,
ESupportDualLanguage = 0x80,
ESupportAutoSubstitution = 0x100
};
/**
* Text case defintions.
*/
enum TPtiTextCase
{
EPtiCaseLower = 0, // Normal lower case input
EPtiCaseUpper, // Normal upper case input.
EPtiCaseChrLower, // Qwerty chr-key lower case input.
EPtiCaseChrUpper, // Qwerty chr-key upper case input.
EPtiCaseFnLower, // Qwerty fn-key lower case input.
EPtiCaseFnUpper, // Qwerty fn-key upper case input.
EPtiCaseMax
};
enum TPtiCharConversion
{
EPtiSimplifiedToComplex = 0x01, // Chinese simplified to Chinese complex
EPtiUcs2ToUtf8 = 0x02, // Unicode to utf8
EPtiUcs2ToBig5 = 0x04, // Unicode to big5
EPtiUcs2ToGB = 0x08, // Unicode to Guo-Biao
EPtiUtf8ToUcs2 = 0x10, // Utf8 to Unicode
EPtiKo2ToWc = 0x20, // KSC5601 to Hangul Syllable
EPtiWcToKo2 = 0x30, // Hangul Syllable to KSC5601
EPtiBig5ToUcs2 = 0x40, // Big5 to Unicode
EPtiComplexToSimplified = 0x80 // Chinese complex to Chinese simplified
};
/**
* Enumerates supported spelling types for CPtiEngine::GetSpelling method.
*/
enum TPtiSpelling
{
EPtiStrokes = 0x01,
EPtiPinyin = 0x02,
EPtiBopomofo = 0x04,
EPtiZhuyin = 0x08,
EPtiCangJie = 0x10,
EPtiEasyCangjie = 0x20,
EPtiAdvCangjie = 0x40
};
/**
* Enumerates different Chinese variants.
*/
enum TPtiChineseVariant
{
EPtiChineseVariantPrc = 0,
EPtiChineseVariantHk,
EPtiChineseVariantTw
};
/**
* Command definitions for CPtiEngine::HandleCommandL api methods. Many of these
* are for internal communication between PtiEngine framework and a specific
* core object and there for not documented.
*/
enum TPtiEngineCommand
{
EPtiCommandNone,
EPtiCommandUserActionLeft,
EPtiCommandUserActionRight,
EPtiCommandUserActionConvert,
EPtiCommandUserActionPrevious,
EPtiCommandUserActionLengthen,
EPtiCommandUserActionShorten,
EPtiCommandUserActionCancel,
EPtiCommandUserActionComplete,
EPtiCommandUserActionAllComplete,
EPtiCommandUserActionGetCurrentIndexOfCandidates,
EPtiCommandUserActionCompleteCandidate,
EPtiCommandUserActionCompleteFull0,
EPtiCommandUserActionCompleteFull1,
EPtiCommandUserActionCompleteFull2,
EPtiCommandUserActionCompleteFull3,
EPtiCommandUserActionCompleteFull4,
EPtiCommandUserActionCompleteFull5,
EPtiCommandUserActionCompleteFull6,
EPtiCommandUserActionCompleteFull7,
EPtiCommandUserActionCompleteFull8,
EPtiCommandUserActionCompleteFull9,
EPtiCommandUserActionCompleteHalf0,
EPtiCommandUserActionCompleteHalf1,
EPtiCommandUserActionCompleteHalf2,
EPtiCommandUserActionCompleteHalf3,
EPtiCommandUserActionCompleteHalf4,
EPtiCommandUserActionCompleteHalf5,
EPtiCommandUserActionCompleteHalf6,
EPtiCommandUserActionCompleteHalf7,
EPtiCommandUserActionCompleteHalf8,
EPtiCommandUserActionCompleteHalf9,
EPtiCommandEnableToneMarks,
EPtiCommandDisableToneMarks,
EPtiCommandResetToneMark,
EPtiCommandIncrementToneMark,
EPtiCommandIncrementToneMarkOverrideInvalid,
EPtiCommandReloadLearningInfo,
EPtiCommandUserDictionaryDelaySaving,
EPtiCommandUserDictionarySaveNow,
EPtiCommandUserActionSetCurrentIndexOfCandidates,
EPtiCommandUseLatinDefaultKeyMap,
EPtiCommandUseLatinCaseUpperOnlyKeyMap,
EPtiCommandUseLatinCaseLowerOnlyKeyMap,
EPtiCommandResetLearningInfo,
EPtiCommandPollQwertyDeadKeyRootFlag, // Indicates that dead key root char was added to buffer.
EPtiCommandGetAndClearDeadKeyRootChar,
EPtiCommandDeadKeyWaiting,
EPtiCommandQueryAndClearGetAllFlag,
EPtiCommandGetAndClearVowelSequence,
EPtiCommandSetMultitapTimer, // Set multitap timer for japanese varint only
EPtiCommandVowelSeqFlag,
EPtiCommandClearVowelSeq,
EPtiCommandSetJapaneseQwertyFlags, // Set Japanese Qwerty flags for japanese varint only
EPtiCommandGetAndClearLastVietnameseChar,
EPtiCommandSetVietnameseLastChar,
EPtiCommandQueryReplacePrevious,
EPtiCommandSetLastKeyForVietnamese,
EPtiCommandResetVietnameseVowelSeqAndToneMark,
EPtiCommandGetVietnameseLastKey,
EPtiCommandDoubleWideEntry,
EPtiCommandSetClearFunction, // Set the behavior of clear key for japanese varint only
EPtiCommandUserActionRetroActiveCandidateHalf,
EPtiCommandUserActionRetroActiveCandidateFull,
EPtiCommandUserActionRetroActiveClear,
EPtiCommandUserActionRetroActiveCommit,
EPtiCommandAppendCharacter, // Append a character for Japanese varint only
EPtiCommandBackSpaceByForce, // BackSpace by force for Japanese varint only
EPtiCommandGetPhoneticText,
EPtiCommandClearPhoneticBuffer,
EPtiCommandBreakSyllable,
EPtiCommandAllowPictographCandidate, // Allow the candidates with pictograph cahracter for Japanese variant only
EPtiCommandLoopback, // Loop back input character (Loop back: c->b->a)
EPtiCommandSetAutoSubstitution,
EPtiCommandAddAutoSubstEntry, // TPtiAutoSubstBinding passed in aParams.
EPtiCommandDeleteAutoSubstEntry, // TPtiAutoSubstBinding passed in aParams.
EPtiCommandNumberOfAutoSubstEntries,
EPtiCommandGetAutoSubstEntry, // TPtiAutoSubstBinding passed in aParams.
EPtiCommandFindAutoSubstEntry, // TPtiAutoSubstBinding* passed in aParams.
EPtiCommandUncommitWord,
EPtiCommandEnableAutoCompletion,
EPtiCommandDisableAutoCompletion,
EPtiCommandSetCorrectionLevel, // TErrorCorrectionLevel* passed in aParams.
EPtiCommandGetAutoCompletionTailLength, // TInt* passed in aParams for output.
EPtiCommandLockCurrentCandidate,
EPtiCommandSetProactiveCorrection, // TBool passed in aParams
EPtiCommandIsExactKnownWord,
EPtiCommandSetAutoCompletion,
EPtiCommandSetNumberCandidateStatus, //
EPtiCommandSetAutoCompletionMaxLength, // Param is integer. Sets maximum lenght of ato completed word. Zero == no limit.
EPtiCommandMarkAutoCapitalized, // No parameters.
EPtiCommandUserActionGetIndexOfSecondaryCandidate, // index of secondary candidate, TInt* passed in param
EPtiCommandAddPhrase, // Add new phrase for next word prediction. const TDesC* passed in param.
EPtiCommandSetSecondaryInputLanguage,
EPtiCommandSetFlagToUpdateCandidates,
EPtiCommandSetCursorCrossedMaxLength, // sets when cursor crosses max words length in editor
EPtiCommandResetCursorCrossedMaxLength,
EPtiCommandUserActionSetIndexOfActiveCandidate,
EPtiCommandAddWordToUDBWithoutPunctMark,
EPtiCommandGetSecondaryCandidate,
EPtiCommandAutoCompletionOnToOff //to signify that autocompletion is set from on to off in between typing
};
/**
* A convinience class for auto substitution related EPtiCommands. Needed
* only in core object and framework code.
*/
class TPtiAutoSubstBinding
{
public:
TInt iIndex;
TBuf<KMaxAutoSubstStringLength> iShortcut;
TBuf<KMaxAutoSubstStringLength> iSubstitution;
};
/**
* A structure for binding language name and language code.
* only in core object and framework code.
*/
class TPtiLangName
{
public:
TInt iLanguageCode;
TBuf<KMaxLanguageNameLength> iName;
};
/**
* This is language code for 'numeric' language.
* It is langugae object which is always available and
* has only numeric input mode.
*/
#define ELangNumeric 0x5000
/**
* An interface class for accessing core info attributes.
*/
class MPtiCoreInfo
{
public:
/**
* Returns a boolean value indicating whether the word completion
* feature is supported by the core object in question
*
* @since S60 V2.6
* @return ETrue if core object supports word completion feature.
* EFalse otherwise.
*/
virtual TBool WordCompletion() const = 0;
/**
* Returns a boolean value indicating whether the user dictionary
* re-ordering feature is supported by the core object in question.
*
* @since S60 V2.6
* @return ETrue if core object supports re-ordering feature.
* EFalse otherwise.
*/
virtual TBool Reordering() const = 0;
/**
* Returns maximum length of single word this core object is able to produce.
*
* @since S60 V2.6
* @return The maximum word length.
*/
virtual TInt MaximumWordLength() const = 0;
/**
* Returns the maximum number of prediction candidates the core object
* is able to produce for any input sequence. Doesn't apply for
* Chinese and Japanese modes.
*
* @since S60 V2.6
* @return The maximum number of candidates.
*/
virtual TInt MaximumNumberOfCandidates() const = 0;
/**
* Returns a boolean value indicating whether the next word prediction feature
* supported by the core object in question.
*
* @since S60 V2.6
* @return ETrue if next wrod prediction is supported.
* EFalse otherwise.
*/
virtual TBool NextWordPrediction() const = 0;
/**
* Returns core object vendor specific id string.
*
* @since S60 V2.6
* @return Vendor specific id string.
*/
virtual TPtrC VendorString() const = 0;
/**
* Returns a bit vector containing flags for various core object features.
* See TPtiEngineCapsBits for list of specified bits.
*
* @since S60 V2.6
* @return A bit vector containing flags for various core object features.
*/
virtual TUint32 CapsBits() const = 0;
/**
* Returns uid value for core object.
*
* @since S60 V2.6
* @return Core object uid as an integer value.
*/
virtual TInt32 Uid() const = 0;
/**
* Returns a bitvector containing flags for available character conversion
* methods. See TPtiCharConversion for list of specified bits.
*
* @since S60 V2.6
* @return A bit vector containing flags for available character conversions.
*/
virtual TUint32 CharConversions() const = 0;
/**
* Returns a bitvector containing flags for available spelling conversion
* methods. See TPtiSpelling for list of specified bits.
*
* @since S60 V2.6
* @return A bit vector containing flags for available spelling conversions.
*/
virtual TUint32 Spellings() const = 0;
};
class TPtiCoreInfo : public MPtiCoreInfo
{
public:
inline TBool WordCompletion() const;
inline TBool Reordering() const;
inline TInt MaximumWordLength() const;
inline TInt MaximumNumberOfCandidates() const;
inline TBool NextWordPrediction() const;
inline TPtrC VendorString() const;
inline TInt32 Uid() const;
inline TUint32 CharConversions() const;
inline TUint32 Spellings() const;
inline TUint32 CapsBits() const;
inline void SetCapsBits(TUint32 aBits);
inline void SetVendorString(const TDesC& aStr);
inline void SetMaxWordLength(TInt aMaxLen);
inline void SetUid(TInt32 aUid);
inline void SetSpellings(TUint32 aSpellings);
inline void SetMaxNumberOfCandidates(TInt aMax);
inline void SetCharConversions(TUint32 aConvs);
private:
TUint32 iCapsBits;
TPtrC iVendorIdStr;
TInt iMaxWordLength;
TInt iMaxNumberOfCandidates;
TInt32 iUid;
TUint32 iCharConversions;
TUint32 iSpellings;
};
#define KPtiEngineChineseSeparator 0x0027
// Tone marks for pinyin input
enum
{
KPtiPinyinTone0 = 0x02C9,
KPtiPinyinTone1 = 0x02CA,
KPtiPinyinTone2 = 0x02C7,
KPtiPinyinTone3 = 0x02CB,
KPtiPinyinTone4 = 0x02D9
};
// Tone marks for zhuyin input
enum
{
KPtiZhuyinTone0 = 0x0020,
KPtiZhuyinTone1 = 0x02CA,
KPtiZhuyinTone2 = 0x02C7,
KPtiZhuyinTone3 = 0x02CB,
KPtiZhuyinTone4 = 0x02D9
};
class TPtiNumericKeyBinding
{
public:
TUint16 iChar;
TPtiKey iKey;
TPtiTextCase iCase;
};
// type definition for HWR
typedef struct TRecognitionRangeTag
{
TLanguage iLanguage;
TUint iSubRange;
} TRecognitionRange;
enum TRecognitionSubRanges
{
EPtiRangePRCChinese,
EPtiRangeHKChinese,
EPtiRangeTWChinese,
EPtiRangeLatin,
EPtiRangeSymbol,
EPtiRangeNumber,
EPtiRangeNative, // native text of a language, EPtiRangeLatin also belong to it
EPtiRangeHiraganaKanji,
EPtiRangeKatakana,
EPtiRangeFullWidthKatakana,
EPtiRangeFullWidthEnglish,
EPtiRangeFullWidthNumeric,
EPtiRangeHiraganaOnly,
EPtiRangeNativeNumber,
EPtiRangeNone
};
enum TLatinLetterOrder
{
EUpperFirst,
ELowerFirst
};
/*
* List of supported keyboard types. Each of these keyboard types
* may have own data block in keyboard data file.
*/
enum TPtiKeyboardType
{
EPtiKeyboardNone,
/**
* Conventional 12 phone keypad
*/
EPtiKeyboard12Key,
/**
* 4x12 Qwerty keyboard.
*/
EPtiKeyboardQwerty4x12,
/**
* 4x10 Qwerty keyboard.
*/
EPtiKeyboardQwerty4x10,
/**
* 3x11 Qwerty keyboard.
*/
EPtiKeyboardQwerty3x11,
/**
* Half qwerty.
*/
EPtiKeyboardHalfQwerty,
/**
* Custom qwerty keyboard.
* Bound to [KEYBOARD BLOCK QWERTY CUSTOM] in keymapping
* definition files.
*/
EPtiKeyboardCustomQwerty,
EPtiKeyboardMaxLayout
};
#include "PtiDefs.inl"
#endif // _PTI_DEFS_H
// End od file