/*

* Copyright (c) 2002 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:

*

*/

// INCLUDE FILES

#include <barsread.h>

#include <uikon.hrh>

#include <e32std.h>

#include <eikcapc.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include "aknborders.h"

#include "aknconsts.h"

#include "AknUtils.h"

#include "aknPopupHeadingPane.h"

#include "aknCharMap.h"

#include "aknSctDialog.h"

#include "AknSettingCache.h"

#include "aknenv.h"

#include "AknDef.h"

#include <bautils.h>

#include <AknLayout.lag>

#include <StringLoader.h>

#include <e32property.h>

#include <AvkonInternalCRKeys.h>    // KAknQwertyInputModeActive

#include <featmgr.h> // temporary

#include <PtiIndicDefs.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikenvinterface.h>

#endif

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntransitionutils.h>

#endif

#include <AknTasHook.h>

#include "aknsctfocushandler.h"

#include <eikdialogext.h>

//

// class CAknCharMapDialog

//

// const TInt KHorizontalDialogMargin = 3;

// const TInt KVerticalDialogMargin = 3;

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

const TInt KWsBufferSize = 16000;

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

enum TCharMapDialogFlags

    {

    ECharMapDialogItemSelected = 0x01,

    ECharMapDialogItemLockNumericKeys = 0x02,

    ECharMapDialogRecentCharsRowDisabled = 0x04,

    ECharMapDialogTableExitSelected = 0x08

    };

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

// Extension class

//

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

//

NONSHARABLE_CLASS(CAknCharMapDialogExtension): public CBase

    {

public:

    static CAknCharMapDialogExtension* NewL(CAknCharMapDialog* aCaller);

    ~CAknCharMapDialogExtension();

private:

    CAknCharMapDialogExtension(CAknCharMapDialog* aCaller);

    void ConstructL();

public:

    TInt iFlags;

    TBool iQwertyMode;

    CAknCharMapDialog* iCaller;

    TBool iHaveReceivedKeyEvent;

    TInt iShowAnotherTableCharCase;

    TAknCharMapPictoMode    iPictoMode;

    TAknCharMapEmotionMode  iEmotionMode;

    };

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

// CAknCharMapDialogExtension::CAknCharMapDialogExtension

//

// Constructor of extension

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

//

CAknCharMapDialogExtension::CAknCharMapDialogExtension(CAknCharMapDialog* aCaller) : 

iFlags(0), iQwertyMode(EFalse), iCaller(aCaller), 

    {

    }

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

// CAknCharMapDialogExtension::~CAknCharMapDialogExtension

//

// Destructor of extension

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

//

CAknCharMapDialogExtension::~CAknCharMapDialogExtension()

    {

    }

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

// CAknCharMapDialogExtension::NewL

//

// Symbian 2 phase constructor

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

//

CAknCharMapDialogExtension* CAknCharMapDialogExtension::NewL(CAknCharMapDialog* aCaller)

    { // static

    CAknCharMapDialogExtension* self = new (ELeave) CAknCharMapDialogExtension(aCaller);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CAknCharMapDialogExtension::ConstructL

//

// Symbian construction

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

//

void CAknCharMapDialogExtension::ConstructL()

    {

    }

// CAknCharMapDialog

EXPORT_C CAknCharMapDialog::CAknCharMapDialog(TInt aCharCase, TDes& aSpecialChars, TInt aCharSetResourceId) : 

    iSpecialChars(&aSpecialChars), iCharCase(aCharCase), iCharSetResourceId(aCharSetResourceId)

    {

    CEikDialog::SetBorder( AknBorderId::EAknBorderNotePopup );

    TRAP_IGNORE(iExtension=CAknCharMapDialogExtension::NewL(this));

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    GfxTransEffect::Register( this, KGfxContextMenuControlUid );

#endif

    AKNTASHOOK_ADD( this, "CAknCharMapDialog" );

    }

CAknCharMapDialog::~CAknCharMapDialog()

    {

    AKNTASHOOK_REMOVE();

    iAvkonEnv->CancelWsBufferRequest( iWsBufferRequestId );

    delete iExtension;

    }

EXPORT_C void CAknCharMapDialog::HandleResourceChange(TInt aType)

    {

    CAknCharMap* charmapControl = static_cast<CAknCharMap*>( Control( EAknSCTQueryContentId ) );

    CAknDialog::HandleResourceChange(aType);

    if (aType==KEikDynamicLayoutVariantSwitch)

        {

        // Softkeys

        ButtonGroupContainer().MakeVisible(AknLayoutUtils::PenEnabled() ? EFalse : ETrue);

        // Heading

        CAknPopupHeadingPane* headingPane = static_cast< CAknPopupHeadingPane* >( Control( EAknSCTQueryHeadingId ) );

        CEikCaptionedControl *ctrl = GetLineByLineAndPageIndex(0, EAknSCTQueryHeadingId);

        if (AknLayoutUtils::PenEnabled())

            {

            ctrl->SetLatent(ETrue);

            ctrl->SetLatentGroupLineFollows(ETrue);

            TRAP_IGNORE(charmapControl->UpdateInputFieldL());

            }

        else

            {

            ctrl->SetLatent(EFalse);

            ctrl->SetLatentGroupLineFollows(EFalse);

            if ( headingPane && charmapControl )

                {

                TRAP_IGNORE(

                    {

                    headingPane->SetPageL(

                        charmapControl->CurrentPage(),

                        charmapControl->PageCount() );

                        const TDesC* title = (charmapControl->IsJapaneseSctUi()) ?

                        charmapControl->TitleWithSelectingSpecialChar() : charmapControl->Title();

                    if ( title )

                        {

                        headingPane->SetTextL( *title );

                        }

                    });

                }

            //Set softkeys

            TRAP_IGNORE(SetSoftKeyL());

            }

        ctrl->SetFocusing(EFalse);

        DoLayout();

        DrawNow();

        Window().SetVisible( ETrue );

        }

    }

EXPORT_C TBool CAknCharMapDialog::OkToExitL(TInt aButtonId)

    {

    CAknCharMap* charmapControl = STATIC_CAST(CAknCharMap*, Control(EAknSCTQueryContentId));

    if (aButtonId == EAknSoftkeyNext)

        {

        TInt page = charmapControl->NextPageL();

        CAknPopupHeadingPane* headingPane = STATIC_CAST(CAknPopupHeadingPane*, Control(EAknSCTQueryHeadingId));

        headingPane->SetPageL(charmapControl->CurrentPage(), page);

        if (page && !AknLayoutUtils::PenEnabled())

            {

            const TDesC* title = charmapControl->IsJapaneseSctUi() ? 

                                 charmapControl->TitleWithSelectingSpecialChar() : 

                                 charmapControl->Title();

            headingPane->SetTextL(*title);

            }

        return(EFalse);

        }

    // Selection key / select softkey adds a character only if 5-key was not used

    // to select multiple characters before.

    if (aButtonId == EAknSoftkeyOk || aButtonId == EAknSoftkeySelect || aButtonId == EAknSoftkeyExit)

        {

        MAknSctFocusHandler* handler = charmapControl->FocusHandler();

        TKeyEvent key;

        key.iCode=EKeyOK;

        key.iModifiers=0;

        if(handler->FocusedControl()->OfferKeyEventL(key, EEventKey) == EKeyWasNotConsumed)

            {

            return EFalse;

            }

        else

            {

            return handler->ExitWithKey(key.iCode);

            }

        }

    return(ETrue);

    }

EXPORT_C void CAknCharMapDialog::PreLayoutDynInitL()

    {

    CAknCharMap* charmapControl = STATIC_CAST(CAknCharMap*, Control(EAknSCTQueryContentId));

    // Softkeys

    ButtonGroupContainer().MakeVisible(AknLayoutUtils::PenEnabled() ? EFalse : ETrue);

    // Heading

    CAknPopupHeadingPane* headingPane = STATIC_CAST(CAknPopupHeadingPane*, Control(EAknSCTQueryHeadingId));

    headingPane->SetLayout(CAknPopupHeadingPane::EColourSelectionGridHeadingPane);

    charmapControl->SetTitleL(headingPane->PromptText());

    SetLineNonFocusing(EAknSCTQueryHeadingId);

    CEikCaptionedControl *ctrl = GetLineByLineAndPageIndex(0, EAknSCTQueryHeadingId);

    ctrl->SetLatent(AknLayoutUtils::PenEnabled() ? ETrue : EFalse);

    ctrl->SetLatentGroupLineFollows(AknLayoutUtils::PenEnabled() ? ETrue : EFalse);

    // Pictographs

    charmapControl->SetPictoMode(iExtension->iPictoMode);

    // Emotion

    charmapControl->SetEmotionModeL(iExtension->iEmotionMode);

    // ShowAnotherTable

    RArray<TInt> caseTable(3);

    if (iExtension->iShowAnotherTableCharCase > 0)

        {

        caseTable.AppendL(iExtension->iShowAnotherTableCharCase);

        }

    charmapControl->SetCaseTableL(caseTable);

    caseTable.Close();

    charmapControl->SetBuffer(*iSpecialChars);

    charmapControl->SetCharacterCaseL(iCharCase);

    if (!AknLayoutUtils::PenEnabled())

        {

        if (charmapControl->PageCount() > 1)

            {

            const TDesC* title = charmapControl->IsJapaneseSctUi()?

                                 charmapControl->TitleWithSelectingSpecialChar() : 

                                 charmapControl->Title();

            headingPane->SetPageL(1, charmapControl->PageCount());

            headingPane->SetTextL(*title);

            // Set softkeys

            SetSoftKeyL();

            }

        }

    else

        {

        charmapControl->UpdateInputFieldL();

        }

    // Key events should be received even when cba is invisible

    MEikButtonGroup* cba = ButtonGroupContainer().ButtonGroup();

    STATIC_CAST( CEikCba*, cba)->SetButtonGroupFlags( cba->ButtonGroupFlags() | EAknCBAFlagRespondWhenInvisible );

    RWsSession& wsSession = iEikonEnv->WsSession();

    TInt myWgId = iEikonEnv->RootWin().Identifier();

    TInt wgPrio = wsSession.GetWindowGroupOrdinalPriority(myWgId);

    // we are already on forgeround, need to update priority differently

    if (wgPrio == ECoeWinPriorityAlwaysAtFront)

        {

        iEikonEnv->RootWin().SetOrdinalPosition(0,ECoeWinPriorityAlwaysAtFront+1);

        }

	/// -- Change Window Priority for dialog and CBA 

	DrawableWindow()->SetOrdinalPosition(0,ECoeWinPriorityAlwaysAtFront); //

	ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0,ECoeWinPriorityAlwaysAtFront);

    }

EXPORT_C void CAknCharMapDialog::SetSizeAndPosition( const TSize& aSize )

    {

    if ( AknLayoutUtils::PenEnabled() )

        {

        CAknDialog::SetSizeAndPosition( aSize );

        CAknCharMap* charmapControl = STATIC_CAST(CAknCharMap*,

                Control(EAknSCTQueryContentId));

        charmapControl->DrawOffscreenBackgroundIfRequired();      

        }

    else

        {

        SetBorder( TGulBorder::ENone ); // No Dialog borders in SCT.

        DoLayout();

        }

    }

EXPORT_C TKeyResponse CAknCharMapDialog::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aModifiers)

    {

    CAknCharMap* charmapControl = STATIC_CAST(CAknCharMap*, Control(EAknSCTQueryContentId));

    CAknPopupHeadingPane* headingPane = STATIC_CAST(CAknPopupHeadingPane*, Control(EAknSCTQueryHeadingId));

    TBool isLockNumericKeys = (iExtension->iFlags&ECharMapDialogItemLockNumericKeys != EFalse);

    if (aModifiers == EEventKey)

        {

        switch (aKeyEvent.iCode)

            {

            case '5':

                if (isLockNumericKeys || aKeyEvent.iRepeats)

                    {

                    return EKeyWasConsumed;

                    }

				break;

            case EKeySpace:     // for Qwerty

                // If there is only one empty position left in the buffer.

                if (iSpecialChars->Length() + 1 >= iSpecialChars->MaxLength())

                    {

                    // Add the selected character to list of special chars

                    charmapControl->OfferKeyEventL(aKeyEvent, aModifiers);

                    TKeyEvent event = {EKeyOK, EKeyOK, 0, 0};

                    return CEikDialog::OfferKeyEventL( event, EEventKey );

                    }

                // No break. Fall through.

            case '2':

            case '4':

            case '6':

            case '8':

                if (isLockNumericKeys && aKeyEvent.iCode!=EKeySpace)

                    {

                    return EKeyWasConsumed;

                    }

            case EKeyLeftArrow:

            case EKeyRightArrow:

            case EKeyUpArrow:

            case EKeyDownArrow:

                {

                TKeyResponse res = charmapControl->OfferKeyEventL(aKeyEvent, aModifiers);

                RefreshTitleAndNaviL();

                return res;

                }

            case EKeyEnter:

            case EKeyDevice3:

                {

                TryExitL(EAknSoftkeySelect);

                return EKeyWasConsumed;

                }

            case '*':

                {

                if (!aKeyEvent.iRepeats) // switch another table when repeat count is 0 only.

                    {

                    if(iExtension->iHaveReceivedKeyEvent)

                        {

                        SwitchTablesOrPagesL();

                        }

                    else

                        {

                        iExtension->iHaveReceivedKeyEvent = ETrue;

                        }

                    }

                }

                break;

            default:

                break;

            }

        }

        {

            {

            case EStdKeyLeftFunc:

            case EStdKeyRightFunc:

                {

                    {

                    if (!isLockNumericKeys) // Check whether current input mode is Qwerty.

                        {

                        SwitchTablesOrPagesL();

                        }

                    }

                }

                break;

            default:

                break;

            }

        }

    return CEikDialog::OfferKeyEventL( aKeyEvent, aModifiers );

    }

EXPORT_C TInt CAknCharMapDialog::ExecuteLD(TInt aResourceId)

    {

    iWsBufferRequestId = iAvkonEnv->RequestWsBuffer( KWsBufferSize );

    // Prepare real char map

    CEikDialog::PrepareLC(aResourceId);

    // Build up input language spesific avkon resource file

    TBuf<32> fileName(KResFileName);

    TInt langcode= iAvkonEnv->SettingCache().InputLanguage();

    // get the phone language

    TLanguage phoneLanguage = AknLangUtils::UserLanguage();

    if ( (langcode & KAknLanguageMask) == ELangEnglish && phoneLanguage != ELangEnglish  )

        {

        switch ( phoneLanguage )

        	{

        	case ELangThai:

        		langcode = ELangEnglish_Thailand;

        		break;

        	default:

        		break;

        	}

        }

    if (langcode < 10)

        {

        fileName.Append('0');

        }

    if(langcode == KLangHindiPhonetic)

        langcode = ELangHindi;

    fileName.AppendNum(langcode);

    TResourceReader reader;

    RFs& fs = iEikonEnv->FsSession();

    // if input language spesific avkon resourcefile exists

    if ( BaflUtils::FileExists(fs, fileName) )

        {

        RResourceFile resourceFile;

        resourceFile.OpenL( fs, fileName );

        CleanupClosePushL( resourceFile ); // push

        resourceFile.ConfirmSignatureL( 0 );

        // if resources with correct id exists

        // -> read characters from resource and copy them to real char map

        if ( resourceFile.OwnsResourceId(aResourceId) )

            {

            HBufC8* resource=resourceFile.AllocReadLC(aResourceId); // push

            reader.SetBuffer(resource);

            // Create input language specific CharMapDialog.

            // Used only for reading input language spesific characters

            // from avkon resource file (avkon.r**).

            TBuf<32> specialChars;

            CAknCharMapDialog* langDialog = new( ELeave ) CAknCharMapDialog(EAknSCTLowerCase, specialChars );

            CleanupStack::PushL( langDialog ); // push