/*

* Copyright (c) 2002-2009 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: Special character table.

*

*/

// INCLUDE FILES

#include <txtetext.h>

#include <barsread.h>

#include <eikappui.h>

#include <eikenv.h>

#include <aknenv.h>

#include <eiksbfrm.h>

#include <eikscrlb.h>

#include <eikdialogext.h>

#include <bidivisual.h>

#include <avkon.rsg>

#include "AknPanic.h"

#include "avkon.hrh"

#include "AknUtils.h"

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <AknLayout.lag>

#include "aknCharMap.h"

#include "aknappui.h"

#include "aknconsts.h"

#include "AknDef.h"

#include <PUAcodes.hrh>

#include <s32file.h>

#include <AknPanic.h>

#include "aknSctDialog.h" // CAknCharmapDialog

#include <aknPopupHeadingPane.h>

#include <aknfep.rsg>

#include <bautils.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikenvinterface.h>

#endif

#include <AknTasHook.h>

// For the TEikScrollBarModelType

#include <eikscrlb.h>

#include <AknsDrawUtils.h>

#include <AknPictographInterface.h>

#include <featmgr.h>

#include <StringLoader.h>

#include <AvkonInternalCRKeys.h>    // KCRUidAvkon, KAknRecentSctData

#include <centralrepository.h>      // CRepository

#include <AknsFrameBackgroundControlContext.h>

#include <aknbutton.h>

#include <gdi.h>

#include <eikedwin.h>

#include <gulbordr.h>

#include <touchfeedback.h>

#include <eiklabel.h>

#include <aknphysics.h>

#include <AknPriv.hrh>

#include "PictograhGrouping.h"

#include "AknSettingCache.h"

#include "aknsctfocushandler.h"

#include "AknSmileyModel.h"

_LIT(KResFileName, "z:\\resource\\avkon.r");

const TInt KAknSctCBaButtonDirections = 3; // bottom, right and left

const TUint KThaiSCTCombiningSymbolAdd = 0xE900;

enum

    {

    EAknCharMapButton1DownInGrid = 0x00000001,

    EAknCharMapHasBeenScrolledByDrag = 0x00000002,

    EAknCharMapCharsAllocated = 0x00000004, // flag that iChars points to HBufC

    EAknCharMapPressedDown = 0x00000008   // flag for press down effect

    };

const TUint KHistoryEmptyChar = CEditableText::ETabCharacter;

const TUint KHistoryEmptyCharForDisplay = CEditableText::ESpace;

const TInt KAreaIdRecent = 0;

const TInt KAreaIdMain   = 1;

const TInt KAreaIdTail   = 2;

// ----------------------------------------------------------------------------

// CAknCharMapHistory definition

// ----------------------------------------------------------------------------

//

/**

 *  Recent data management when a Special characters or a Pictograph characters 

 *  @lib avkon.lib

 *  @since 2.8

 *

 */

class CAknCharMapHistory : public CBase

    {

    public: // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static CAknCharMapHistory* NewL();

        /**

        * Destructor.

        */

        ~CAknCharMapHistory();

    public: // enum

        enum THistoryType

            {

            EHistoryTypeNull = -1,

            EHistoryTypeFull = 0,

            EHistoryTypeHalf,

            EHistoryTypePicto,

            EHistoryTypePicto2,

            EHistoryTypeMax

            };

        enum THistoryFilter

            {

            EHistoryFilterMixed = 0, // text and emotion

            EHistoryFilterTextOnly,

            EHistoryFilterEmotionOnly,

            EHistoryFilterMax

            };

        enum THistorySize

            {

            KHistoryBufferSize = 15

            };

    public: // New functions

        /**

        * Load recent characters from file.

        * @since 2.8

        */

        TInt LoadL();

        /**

        * Reset recent data arrary.

        * @since 2.8

        */

        void ResetArray();

        /**

        * Store recent data to file.

        * @since 2.8

        */

        TInt SaveL();

        /**

        * Get recent data.

        * @since 2.8

        * @param aHistoryType The kind of charctor map, refer to THistoryType

        */

        const TDesC& RecentString(THistoryType aHistoryType, THistoryFilter aHistoryFilter=EHistoryFilterMixed);

        /**

        * Insert a character which select on SCT/Picto.

        * @since 2.8

        * @param aHistoryType The kind of charctor map, refer to THistoryType

        * @param aChar    Insert a character

        */

        void InsertChar(THistoryType aHistoryType, const TChar aChar, TBool aIsEmotion);

    private:

        /**

        * C++ default constructor.

        * @since 2.8

        */

        CAknCharMapHistory();

        /**

        * By default Symbian 2nd phase constructor is private.

        * @since 2.8

        */

        void ConstructL();

    private:

        /**

        * Insert a character to a HBufC.

        * @param aHistoryBuf ahistory buffer

        * @param aChar    Insert a character

        */

        void InsertCharToHistoryBuf(TDes& aHistoryBuf, const TChar aChar);

    private:    // Data

        // Recent characters

        TBuf<KHistoryBufferSize> iMixedHistoryArray[EHistoryTypeMax];

        TBuf<KHistoryBufferSize> iTextHistoryArray[EHistoryTypeMax];

        TBuf<KHistoryBufferSize> iEmotionHistory;

        enum TBufferCount

            {

            KHistoryBufferCount = (EHistoryTypeMax+EHistoryTypeMax+1)

            };

    };

// ----------------------------------------------------------------------------

// Navi button class definition

// ----------------------------------------------------------------------------

//

NONSHARABLE_CLASS(CAknSctNaviButton) : public CBase, public MCoeControlObserver

    {

    public:

        static CAknSctNaviButton* NewL(const CCoeControl& aParent, TInt aButtonId, TResourceReader& reader);

        ~CAknSctNaviButton();

    private:

        CAknSctNaviButton(TInt aButtonId);

        void ConstructL(const CCoeControl& aParent, TResourceReader& reader);

    private: // from MCoeControlObserver

        virtual void HandleControlEventL(CCoeControl* aControl, TCoeEvent aEventType);

    public:

        void SetObserver(MCoeControlObserver* aObserver);

        void SetFocused(TBool aState);

        void SetEnabled(TBool aState);

        TBool IsFocused();

        TBool IsEnabled();

    public:

        CAknButton* iButtonControl;

        MCoeControlObserver* iObserver;

        TInt iButtonId;

        TBool iPressed;

        TBool iRepeat;

    };

// ----------------------------------------------------------------------------

// Navigator class definition

// ----------------------------------------------------------------------------

//

NONSHARABLE_CLASS(CAknSctPageNavi) : public CAknControl, public MAknSctFocusHandler, public MCoeControlObserver

    {

    public:

        CAknSctPageNavi( CAknCharMap* aCharMap, CAknCharMapExtension* aExtension);

        ~CAknSctPageNavi();

    public: // new methods

       void UpdatePageTitleL() const;

    public:  // from CCoeControl

        TInt CountComponentControls() const;

        CCoeControl* ComponentControl( TInt aIndex ) const;

        virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode);

        void ConstructFromResourceL(TResourceReader& aReader);

        virtual void HandlePointerEventL(const TPointerEvent& aPointerEvent);

        virtual TSize MinimumSize();

        virtual void SizeChanged();

        virtual void Draw(const TRect& aRect) const;

    public: // from MCoeControlObserver

        void HandleControlEventL(CCoeControl* aControl, TCoeEvent aEventType); // for button repeat

    public:  // from MAknSctFocusHandler

        virtual CCoeControl* FocusedControl();

        virtual TBool EnterControl(TInt aX, TInt aY);

        virtual void MoveFocus(TInt aX, TInt aY);

        virtual TBool ExitWithKey(TInt aKeycode);

        virtual TBool LeaveControl();

    public:

        void UpdateNextTableButtonL();

        TInt LastButton() const;

    private:

        void MoveFocus(TBool aInternalMove, TInt aX, TInt aY );

        TBool IsNextButton() const;

        TBool CalcNextStep( TUint aKey, TInt& aX, TInt& aY );

        void TableExitL();

        static TInt TableExitCallBackL(TAny* aThis);

        void DoTableExitL();

        void NextTableL();

        static TInt NextTableCallBackL(TAny* aThis);

        void DoNextTableL();

    private:  // data

        TInt iButtonIndex;

        RPointerArray<CAknSctNaviButton> iButtonArray;

        CAknCharMap* iCharMap;

        CAknCharMapExtension* iExtension;

        CEikLabel* iTitle;

        CIdle *iIdle;

    };

// ----------------------------------------------------------------------------

// Category button class defintion

// ----------------------------------------------------------------------------

//

class CAknSctCategoryButton : public CBase

    {

    public:

        static CAknSctCategoryButton* NewL(

            const CCoeControl& aParent,

            TResourceReader& reader,

            TInt aCategoryButtonId,

            TInt aSctCaseId);

        ~CAknSctCategoryButton();

    private:

        CAknSctCategoryButton(

            TInt aCategoryButtonId,

            TInt aSctCaseId);

        void ConstructL(

            const CCoeControl& aParent,

            TResourceReader& reader);

    public:

        void SetFocused(TBool aState);

    public:

        CAknButton* iButtonControl;     // own

        TInt        iButtonId;

        TInt        iSctCaseId;

        TBool       iValid;

    };

// ----------------------------------------------------------------------------

// Radio button class defintion

// ----------------------------------------------------------------------------

//

// stay for BC

class CAknSctRadioButton : public CAknControl

    {

    public:

        CAknSctRadioButton();

        ~CAknSctRadioButton();

    private:  // data

        RPointerArray<CAknSctCategoryButton> iButtonArray;

    };

CAknSctRadioButton::CAknSctRadioButton()

    {

    }

CAknSctRadioButton::~CAknSctRadioButton()

    {

    iButtonArray.ResetAndDestroy();

    iButtonArray.Close();

    }

// end of CAknSctRadioButton class definition

// ----------------------------------------------------------------------------

// Extension class defintion

// ----------------------------------------------------------------------------

//

NONSHARABLE_CLASS(CAknCharMapExtension) : 

    public CBase,

    public MObjectProvider,

    public MAknSctFocusHandler,

    public MAknSmileyObserver

    {

    public:

        CAknCharMapExtension();

        ~CAknCharMapExtension();

    public: // new methods

        void SetCharMapControl(CAknCharMap* aCtrl);

        MAknSctFocusHandler* FocusHandler();

    public: // from MAknSctFocusHandler

        virtual CCoeControl* FocusedControl();

        virtual TBool EnterControl(TInt aX, TInt aY);

        virtual void MoveFocus(TInt aX, TInt aY);

        virtual TBool ExitWithKey(TInt aKeycode);

        virtual TBool LeaveControl();

    protected:

        TTypeUid::Ptr MopSupplyObject(TTypeUid aId);

        MObjectProvider* MopNext();

    private: // from MSmileyIconObserver

        virtual void SmileyStillImageLoaded(CAknSmileyIcon* aSmileyIcon);

        virtual void SmileyAnimationChanged(CAknSmileyIcon* aSmileyIcon);

    public:

        TBool IsEmotionEnabled() const;

        TBool IsShowingEmotion() const;

        void SwitchEmotionVisibilityL();

        TBool NeedEmotionSwitchIcon() const;

        HBufC* ReadEmotionHBufCL();

        void LoadEmotionTumbnails(const TDesC& aText);

        void PlayAnimationL(const TDesC& aText);

        void StopAnimation(const TDesC& aText);

        void SetEmotionSize(const TSize& aSize);

        TBool IsEmotionChar(TChar aChar);

        TChar SwitchToSctChar();

        TChar SwitchToEmotionChar();

        CAknSmileyIcon* EmotionIcon(TChar aChar);

        const TDesC& EmotionText(TChar aChar);

        TBool DrawEmotion(CWindowGc& aGc, const TRect& aRect, CAknSmileyIcon* aSmileyIcon);

        void HandleFocusStatusChanged(TChar aChar, TBool aIsFocused);

    public: // data

        MCoeControlObserver *iObserver;

        HBufC* iCharsQwerty;

        HBufC* iTitleBuf;

        TUint iFlags;

        TInt iMaxVisibleRows;

        CAknsFrameBackgroundControlContext* iBgContext;

        MObjectProvider* iCharMap;

        TBool iMenuSct; // Is SCT used in editing menu

        TBool iKeyOkEvent; // ETrue is set after pressing OK Key

        // FeatureManager

        TBool iPictographsBuffer;         // ETrue means Picto is valid.

        TBool iPictographsBufferGrouping; // ETrue means Picto grouping is valid.

        TInt  iCurrentCategory;     // defined enum TAknSCTCategoryButton on avkon.hrh

        // QHD layout.

        CAknCharMap* iCharMapProxy;

        MAknSctFocusHandler* iFocusHandler;

        CAknSctPageNavi* iPageNavi;

        HBufC* iEntryBuf;

        CEikLabel* iCategoryTitle;

        CEikLabel* iCategoryEntry;

        TBool iSelectAllowed;

        // Whether or not kinetic scrolling is enabled in the device.

        // Focus scrolling is disabled if kinetic scrolling is used.

        TBool iKineticScrolling;

        // Indicates whether menu sct is highlighted or not.

        TBool iMenuSctHighlighted;

        // flag for focus status of char map dialog

        TBool iCharMapFocusGained;

    public: // for Emotion

        HBufC* iCharsSmiley;

        CSmileyModel* iSmileyModel;

        TChar iLastFocusedSmileyChar;

        TBool iIsShowingEmotion;

        TBool iIsEnableEmotion;

    public: // Single click        

       /**

        * Is single click mode enabled

        */

        TBool iSingleClickEnabled;

       /**

        * Is highlight visible

        */

        TBool iHighlightVisible;         

        /**

        * Is keyboard event

        */

        TBool iKeyBrdEvent;

    private:

        CAknSctRadioButton iForBCDoNotUse;

    };

// ----------------------------------------------------------------------------

// Navi button class implementation

// ----------------------------------------------------------------------------

//

CAknSctNaviButton* CAknSctNaviButton::NewL(const CCoeControl& aParent, TInt aButtonId, TResourceReader& aReader)

    {

    CAknSctNaviButton* self = new( ELeave ) CAknSctNaviButton(aButtonId);

    CleanupStack::PushL( self );

    self->ConstructL(aParent, aReader);

    CleanupStack::Pop();

    return self;

    }

CAknSctNaviButton::CAknSctNaviButton(TInt aButtonId) : iButtonId(aButtonId)

    {

    }

void CAknSctNaviButton::ConstructL(const CCoeControl& aParent, TResourceReader& aReader)

    {

    iButtonControl = CAknButton::NewL(aReader);

    iButtonControl->SetContainerWindowL(aParent);

    iButtonControl->SetObserver(this);

    }

void CAknSctNaviButton::SetObserver(MCoeControlObserver* aObserver)

    {

    iObserver = aObserver;

    }

void CAknSctNaviButton::HandleControlEventL(CCoeControl* aControl, TCoeEvent aEventType)

    {

    if(iObserver) iObserver->HandleControlEventL(aControl, aEventType);

    }

CAknSctNaviButton::~CAknSctNaviButton()

    {

    delete iButtonControl;

    }

void CAknSctNaviButton::SetFocused(TBool aState)

    {

    iButtonControl->SetFocus(aState);

    iButtonControl->DrawDeferred();

    }

void CAknSctNaviButton::SetEnabled(TBool aState)

    {

    iButtonControl->MakeVisible(aState);