/*
* Copyright (c) 2006-2007 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:  Class to hold the character to key mappings
*
*/

#ifndef __CPCS_KEY_MAP_ALGORITHM_2_H__
#define __CPCS_KEY_MAP_ALGORITHM_2_H__


// INCLUDES
#include <e32base.h>
#include <e32property.h>
#include <PtiDefs.h>
#include "CPcsDefs.h"

class CPcsAlgorithm2;
class CPsQuery;
class CPtiEngine;
class CPtiKeyMapData;

class TKeyMappingData
    {
public:
    TPtiKey iKey; // key
    RArray<TInt> iKeyMappingArray; // All the characters mapped to the key
    };

// CLASS DECLARATION
class CPcsKeyMap : public CBase
    {

public:

    /**
     * Two phase construction
     */
    static CPcsKeyMap* NewL(CPcsAlgorithm2* aAlgorithm);

    /**
     * Destructor
     */
    virtual ~CPcsKeyMap();

    /**
     * Convert functions to get the key string from query and/or chars string
     */
    void GetMixedKeyStringForQueryL(CPsQuery& aSrcQuery, TDes& aDestStr) const;
    void GetMixedKeyStringForDataL(CPsQuery& aSrcQuery, const TDesC& aSrcData, TDes& aDestStr) const;

    /**
     * Returns the numeric key id corresponding to a specific character
     */
    TPtiKey KeyForCharacter(TText aChar, TKeyboardModes aKbMode) const;

    /**
     * Returns ETrue if this language is supported
     */
    TBool IsLanguageSupportedL(const TUint32 aLanguage);

    void ReconstructKeymapL();
    
    /**
     * Returns the pool Id for a key
     */
    TInt PoolIdForCharacter(TChar aChar, TKeyboardModes aKbMode );
    
    /**
     * Returns total number of pools
     */
    TInt PoolCount();

    /**
     * Returns true if the characters "0" and " " are on the same key
     */
    TBool GetSpaceAndZeroOnSameKey( TKeyboardModes aMode );

private:

    /**
     * Constructor
     */
    CPcsKeyMap();

    /**
     * Second phase constructor
     */
    void ConstructL(CPcsAlgorithm2* aAlgorithm);

    /**
     * Set flags to indicate if space and zero are on same key.
     * Keymappings must be constructed before calling this.
     */
    void SetSpaceAndZeroOnSameKey();
    
    /**
     * Helper function to construct keyboard specific mappings
     */
    void ConstructForItutKeyboardL();
    void ConstructForQwertyKeyboardL(TPtiKeyboardType aKbType);

    /**
     * Helper function to populate Itut key mappings
     */
    void AddKeyMapforItutL(TLanguage aLanguage);

    void AddDataForItutKeyboardL(CPtiKeyMapData* aPtiKeyMapData,
            TPtiKey aKey, TKeyMappingData& aKeyDataList);
    /**
     * Helper function to populate 4x10 Qwerty Keyboard  key mappings
     */
    void AddKeyMapForQwertyKeyboardL(TLanguage aLanguage, TPtiKeyboardType aKbType);

    void AddDataForQwertyKeyboardL(
            CPtiKeyMapData* aPtiKeyMapData, 
            TPtiKeyboardType aKbType, 
            TPtiKey aKey,
            TKeyMappingData& aKeyDataList);
    
    /**
     * Create list of PTI keys for the given keyboard type
     */
    void CreateKeyListFromKeyBindingTable( RArray<TPtiKey>& aKeyArray, TPtiKeyboardType aKbType );

    void ResetKeyMap();
    
    /**
     * Function to construct key mappings for a particula language
     * 
     */
    void ConstructKeymapL();
    
    /**
     * Select keyboard types according to available physical keyboard(s)
     */
    void SetupKeyboardTypesL();
    
    /**
     * 
     * Construct keymaps
     */
    void ConstructConcreteKeyMapL();
    
    /**
     * 
     * Add keymap for keyboard by type and language
     * @ aKeyboardType, the current keyboard type.
     * @ aLanguage, the keymap construct language.
     */
    void AddKeyMapforConcreteKeyboardL( TLanguage aLanguage );

    /**
     * In case the given character is a Chinese characer, give the first
     * character of it's first spelling using the current spelling mode.
     * Otherwise, the character is returned unmodified.
     */
    TChar FirstCharFromSpellingL( TChar aChar ) const;
    
    TInt PoolIdForKey(TPtiKey aKey, TKeyboardModes aKbMode) const;
    
    /**
     * Gets predictive keyboard mapping data for given match mode.
     * @param   aMode      Matching mode for which keymappings are asked. 
     * @return  Mapping table for the given mode. NULL if asked for non-predictive mode.
     */
    const RPointerArray<TKeyMappingData>* KeyMappings( TKeyboardModes aMode ) const;

    /**
     * Resolve any ambiguity from the given keyboard mode.
     * Keyboard mode "predictive default keyboard" will be replaced by 
     * "ITU-T predictive" or "QWERTY predictive", depending on the configuration
     * of the device. Predictive keyboard modes, which can't be supported
     * in this device, are replaced with "non-predictive" mode.
     */
    TKeyboardModes ResolveKeyboardMode( TKeyboardModes aKbMode ) const;
    
    /**
     * Get the default charcter for the given key in given keyboard.
     * The default character is used to construct the compare string for
     * predictive mode.
     */
    TText DefaultCharForKey( TPtiKey aKey, TKeyboardModes aKbMode ) const;
    
private:
    /**
     * PTI engine istance. Owned.
     */
    CPtiEngine* iPtiEngine;

    /**
     * Algorithm instacne pointer. NOT owned.
     */
    CPcsAlgorithm2* iAlgorithm;
    
    /**
     * Array to hold the list of languages not supported
     */
    RArray<TLanguage> iLanguageNotSupported;

    /**
     * Type of keyboard used in ITU-T search mode. Typically this is standard ITU-T
     * 12-key keypad.
     */
    TPtiKeyboardType iItutKeyboardType;

    /**
     * PTI keys of the ITU-T keyboard.
     */
    RArray<TPtiKey> iItutKeys;

    /**
     * Contains all the ITU-T keys and the characters mapped to each key. Owned.
     */
    RPointerArray<TKeyMappingData> iItutKeyMappings;

    /**
     * True if "0" and " " are on the same key in the ITU-T mode
     */
    TBool iSpaceAndZeroOnSameKeyOnItut;
    
    /**
     * Type of keyboard used in QWERTY search mode. Typically this is either 3x11 or 4x10 QWERTY
     * or EPtiKeyboardNone if there's no any kind of QWERTY available. This may also be
     * half-QWERTY.
     */
    TPtiKeyboardType iQwertyKeyboardType;

    /**
     * PTI keys of the QWERTY keyboard.
     */
    RArray<TPtiKey> iQwertyKeys;

    /**
     * Contains all the QWERTY keys and the characters mapped to each key. Owned.
     */
    RPointerArray<TKeyMappingData> iQwertyKeyMappings;
    
    /**
     * True if "0" and " " are on the same key in the QWERTY mode
     */
    TBool iSpaceAndZeroOnSameKeyOnQwerty;
    
    /**
     * Flag to indicate if the default multi-matching mode is ITU-T or QWERTY mode.
     * ETrue, if ITU-T is defualt and EFalse if QWERTY is default.
     */
    TBool iItutIsDefault;
    };

#endif // __CPCS_KEY_MAP_ALGORITHM_2_H__

// End of file