/*

* 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

* which accompanies this distribution, and is available

* at the URL "http://www.symbianfoundation.org/legal/licencesv10.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.

    EPtiEngineMaxInputModes = EPtiEngineMultitappingKorean

    };

/*

* 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