/*

* Copyright (c) 2002-2005 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:  Implementation of button

*

*/

// system includes

#include <barsread.h>

#include <AknIconUtils.h>

#include <coemain.h>

#include <AknsUtils.h>

// user includes

#include "peninputvkbctrllayout.h"

#include "peninputvkbctrlext.h"

// constants

const TInt KInvalidBmp = -1 ;

// ======== MEMBER FUNCTIONS ========

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

// CAknFepCtrlVkbLayout::CAknFepCtrlVkbLayout

// C++ default constructor can NOT contain any code, that

// might leave.

// (other items were commented in a header).

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

//

CAknFepCtrlVkbLayout::CAknFepCtrlVkbLayout()

    : iFirstTimeConstruct(ETrue), iResourceId( -1 ), iVkbLayoutId( -1 )

    {

    }

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

// CAknFepCtrlVkbLayout::NewL

// Two-phased constructor.

// (other items were commented in a header).

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

//

EXPORT_C CAknFepCtrlVkbLayout* CAknFepCtrlVkbLayout::NewL()

    {

    CAknFepCtrlVkbLayout* self = NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// CAknFepCtrlVkbLayout::NewLC

// Two-phased constructor.

// (other items were commented in a header).

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

//

EXPORT_C CAknFepCtrlVkbLayout* CAknFepCtrlVkbLayout::NewLC()

    {

    CAknFepCtrlVkbLayout* self = new (ELeave) CAknFepCtrlVkbLayout();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }    

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

// CAknFepCtrlVkbLayout::Reset

// (other items were commented in a header).

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

//

EXPORT_C void CAknFepCtrlVkbLayout::Reset()

    {

    iVkbLayoutId = -1;

    iFirstTimeConstruct = ETrue;

    }

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

// CAknFepCtrlVkbLayout::ConstructL

// Two-phased constructor.

// (other items were commented in a header).

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

//

void CAknFepCtrlVkbLayout::ConstructL()

    {

    }

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

// Destructor.

// (other items were commented in a header).

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

//

EXPORT_C CAknFepCtrlVkbLayout::~CAknFepCtrlVkbLayout()

    {

    iVkbLayoutInfoList.ResetAndDestroy();

    iVkbLayoutInfoList.Close();

    }

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

// CAknFepCtrlVkbLayout::SetVkbKeyboard

// Two-phased constructor.

// (other items were commented in a header).

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

//    

EXPORT_C void CAknFepCtrlVkbLayout::SetVkbKeyboard( 

    CPeninputVkbCtrlExt* aVkbCtrl )

    {

    iVkbCtrl = aVkbCtrl;

    }

EXPORT_C void CAknFepCtrlVkbLayout::SetIrregularResourceId(TInt32 aResId)

    {

    iIrregularResId = aResId;

    }    

EXPORT_C void CAknFepCtrlVkbLayout::SetNonIrregularResourceId(TInt32 aResId)

    {

    iNonIrregularResId = aResId;

    }    

EXPORT_C void CAknFepCtrlVkbLayout::ConstructFromIrregularResourceL()          

    {

    if ( iIrregularResId < 0 )

        {

        return;

        }

    TResourceReader reader;

    CCoeEnv::Static()->CreateResourceReaderLC( reader, iIrregularResId );      

    TPtrC bmpFileName = reader.ReadTPtrC();

    for (TInt index = 0; index <= EKeyRightUp; index ++)

        {

        CreateIrregularKeyBitmapsL(reader, bmpFileName, (TVirtualKeyIrregularKeyType) index);

        }

    // Pop and destroy reader

    CleanupStack::PopAndDestroy( 1 );

  	for( TInt i = 0; i < iVkbLayoutInfoList.Count(); i++ )

   	    {

   	    iVkbLayoutInfoList[i]->iIrregular = ETrue;

        }

    }

EXPORT_C void CAknFepCtrlVkbLayout::ConstructFromNonIrregularResourceL()          

    {

    if ( iNonIrregularResId < 0 )

        {

        return;

        }

    TResourceReader reader;

    CCoeEnv::Static()->CreateResourceReaderLC( reader, iNonIrregularResId );      

    TPtrC bmpFileName = reader.ReadTPtrC();

    TInt32 imgMajorSkinId = reader.ReadInt32();

    TAknsItemID id;

    for (TInt index = 0; index <= EKeyBmpLastType ; index += 2)

        { 

        // Get the image ids and mask ids from resource

        TInt bmpId = reader.ReadInt16(); 

        TInt bmpMskId = reader.ReadInt16();

        // read skin item id

        const TInt skinitemid = reader.ReadInt16();

        id.Set(TInt(imgMajorSkinId), skinitemid);

        if (bmpId != KInvalidBmp)

            {

        	CFbsBitmap* bmp = NULL;

        	CFbsBitmap* maskbmp = NULL;

        	if (bmpMskId != KInvalidBmp)

        		{

        		AknsUtils::CreateIconL(AknsUtils::SkinInstance(),

        		                       id,

        		                       bmp,

        		                       maskbmp,

        		                       bmpFileName,

        		                       bmpId,

        		                       bmpMskId);

       		    // set maskbmp and size

                iVkbCtrl->SetNonIrregularKeyBitmapL(TVirtualKeyBmpType(EKeyBmpNormal + index + 1), 

                                                    maskbmp );

                }

            else

                {

        	    AknsUtils::CreateIconL(AknsUtils::SkinInstance(),

        	                           id,

        	                           bmp,

        	                           bmpFileName,

        	                           bmpId);

                }

            // set bmp and size

           	iVkbCtrl->SetNonIrregularKeyBitmapL( TVirtualKeyBmpType(EKeyBmpNormal + index), bmp );

            }       

        }

    // Pop and destroy reader

    CleanupStack::PopAndDestroy( 1 );

  	for( TInt i = 0; i < iVkbLayoutInfoList.Count(); i++ )

   	    {

   	    iVkbLayoutInfoList[i]->iIrregular = EFalse;

        }

    }  

void CAknFepCtrlVkbLayout::CreateIrregularKeyBitmapsL(TResourceReader& reader, TPtrC& bmpFileName, 

                                                      TVirtualKeyIrregularKeyType aKeyType)

    {

    int maskid = 0;

    for(TInt index = 0; index <= EKeyStateDimmedMask; index += 2)

        {

        maskid = index + 1;

        CreateIrregularKeyBitmapL(reader, bmpFileName, aKeyType ,

                                 (TVirtualKeyIrregularKeyState)index,

                                 (TVirtualKeyIrregularKeyState)maskid);         

        }

    }

void CAknFepCtrlVkbLayout::CreateIrregularKeyBitmapL(TResourceReader& reader, TPtrC& bmpFileName, 

                                                    TVirtualKeyIrregularKeyType aKeyType ,

                                                    TVirtualKeyIrregularKeyState aKeyState, 

                                                    TVirtualKeyIrregularKeyState aKeyStateMask)

    {

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* bitmapmaks = NULL;

    TAknsItemID id;

    MAknsSkinInstance* skininstance = AknsUtils::SkinInstance();

    TInt bmpID = reader.ReadInt16();

    TInt bmpmaskID = reader.ReadInt16();

    TInt minorskinID = reader.ReadInt16();    

    id.Set(TInt(EAknsMajorGeneric), minorskinID);

    if (bmpID > 0)

        {

        AknsUtils::CreateIconL( skininstance,

                                id,

                                bitmap,

                                bitmapmaks,

                                bmpFileName,

                                bmpID,

                                bmpmaskID );        

        if (bitmapmaks)

            {

            AknIconUtils::DisableCompression(bitmapmaks);

            }

        if (bitmap && iVkbCtrl)

            {

            iVkbCtrl->AddIrregularKeyBitmapL(aKeyType, aKeyState, bitmap);

            }

        if (bitmapmaks && iVkbCtrl)

            {

            iVkbCtrl->AddIrregularKeyBitmapL(aKeyType, aKeyStateMask, bitmapmaks);

            }            

        }

    }

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

// CAknFepCtrlVkbLayout::SetResourceId

// Set resurce Id

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

//        

EXPORT_C void CAknFepCtrlVkbLayout::SetResourceId(TInt32 aResId)

    {

    iResourceId = aResId;

    }

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

// CAknFepCtrlVkbLayout::ConstructFromResourceL

// (other items were commented in a header).

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

//

EXPORT_C void CAknFepCtrlVkbLayout::ConstructFromResourceL()

	{

    if ( iResourceId < 0 )

        {

        return;

        }

    TResourceReader reader;

    CCoeEnv::Static()->CreateResourceReaderLC( reader, iResourceId );      

    TInt count = reader.ReadInt16();

    if( iFirstTimeConstruct )

        {

        iVkbLayoutInfoList.ResetAndDestroy();

        for ( TInt i = 0; i < count; i++ )

            {

            CPeninputVkbLayoutInfo* vkbLayoutInfo = 

                CPeninputVkbLayoutInfo::NewL( reader );

            if (iVkbCtrl)

            	{

            	vkbLayoutInfo->iIrregular = iVkbCtrl->IsIrregularKeyBoard();	

            	}

            iVkbLayoutInfoList.Append( vkbLayoutInfo );

            }

        }

    else

        {

        // vkb keyboard must reset first, because iKeyInfoList will reset and destroy later

        iVkbCtrl->Reset();

        for ( TInt i = 0; i < count; i++ )

            {

            iVkbLayoutInfoList[i]->ConstructFromResourceL( reader, iVkbCtrl, iVkbLayoutId );

            iVkbLayoutInfoList[i]->ResetSize( 

                iVkbLayoutInfoList[i]->UnitWidth(),

                iVkbLayoutInfoList[i]->UnitHeight(),

                iVkbLayoutInfoList[i]->UnitCharWidth(),

                iVkbLayoutInfoList[i]->UnitCharHeight(),

                iVkbLayoutInfoList[i]->CharLeftTopPoint(),

                iVkbLayoutInfoList[i]->CharFont() );

            if (iVkbCtrl)

            	{                

                iVkbLayoutInfoList[i]->iIrregular = iVkbCtrl->IsIrregularKeyBoard();

            	}

            } 

        }    

    // Pop and destroy reader

    CleanupStack::PopAndDestroy( 1 ); 

    iFirstTimeConstruct = EFalse;

	}

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

// CAknFepCtrlVkbLayout::VkbLayoutInfoList

// (other items were commented in a header).

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

//

EXPORT_C RPointerArray<CPeninputVkbLayoutInfo> CAknFepCtrlVkbLayout::VkbLayoutInfoList()

    {

    return iVkbLayoutInfoList;

    }

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

// CAknFepCtrlVkbLayout::ChangeVkbLayout

// (other items were commented in a header).

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

//

EXPORT_C void CAknFepCtrlVkbLayout::ChangeVkbLayout( TInt aVkbLayoutId )

    {

    if( iVkbLayoutId == aVkbLayoutId )

        {

        return;

        }

	iVkbLayoutId = aVkbLayoutId;

	for( TInt i = 0; i < iVkbLayoutInfoList.Count(); i++ )

	    {

	    if( aVkbLayoutId == iVkbLayoutInfoList[i]->LayoutID() )

	        {

	        iVkbCtrl->ReorganizeVkbKeys( iVkbLayoutInfoList[i] );

	        return;

	        }

	    }

    }

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

// CPeninputVkbKeyInfo::NewL

// (other items were commented in a header)

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

//

EXPORT_C CPeninputVkbKeyInfo* CPeninputVkbKeyInfo::NewL( 

    TResourceReader& aReader )

    {

    CPeninputVkbKeyInfo* self = new ( ELeave ) CPeninputVkbKeyInfo();

    CleanupStack::PushL( self );

    self->ConstructL( aReader );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPeninputVkbKeyInfo::~CPeninputVkbKeyInfo

// (other items were commented in a header)

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

//

EXPORT_C CPeninputVkbKeyInfo::~CPeninputVkbKeyInfo()

    {

    delete iKey;

    iKey = NULL;

    delete iUnicode;

    iUnicode = NULL;

    }

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

// CPeninputVkbKeyInfo::ConstructL

// (other items were commented in a header)

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

//

void CPeninputVkbKeyInfo::ConstructL( TResourceReader& aReader )

    {

    ConstructFromResourceL( aReader );

    }

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

// CPeninputVkbKeyInfo::ConstructFromResourceL

// (other items were commented in a header)

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

//

void CPeninputVkbKeyInfo::ConstructFromResourceL( TResourceReader& aReader )

    {

    iUnicode = aReader.ReadHBufCL();

    iScanCode = aReader.ReadInt16();

    iBeginRow = aReader.ReadInt16();

    iBeginColumn = aReader.ReadInt16();

    iEndRow = aReader.ReadInt16();

    iEndColumn = aReader.ReadInt16();

    iHighlightBmpIndex = aReader.ReadInt16();

    iHighlightMaskBmpIndex = aReader.ReadInt16();

    TPtrC displayUnicode = aReader.ReadTPtrC();

    TInt baseLine = 0;

    iKey = CVirtualKey::NewL( *iUnicode, iScanCode, TRect(), 

                              TRect(), baseLine, iHighlightBmpIndex, iHighlightMaskBmpIndex );

 	if( displayUnicode.Length() != 0 )

 		{

 		iKey->SetDisplayUnicodeL( displayUnicode );

 		}

    }

TVirtualKeyIrregularKeyType CPeninputVkbKeyInfo::KeyTypeFromColumn(TInt aColumns)

    {

    if (iBeginColumn == 0)

        {

        return EKeyLeftDown;

        }

    if ((iBeginColumn == aColumns - 1) && (aColumns % 2  == 0))

        {

        return EKeyRightUp;

        }

    if ((iBeginColumn == aColumns - 1) && (aColumns % 2  == 1))

        {

        return EKeyRightDown;

        }

    if (iBeginColumn % 2  == 0)

        {

        return EKeyMiddleDown;

        }

    return EKeyMiddleUp;

    }

void CPeninputVkbKeyInfo::SetIrregularKeyType(TInt aColumns)

    {

    if (iKey)

        {

        iKey->SetIrregualrKeyType(KeyTypeFromColumn(aColumns));

        }

    }

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

// CPeninputVkbKeyInfo::CreateKeyL

// (other items were commented in a header)

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

// 

void CPeninputVkbKeyInfo::CreateKeyL()

    {

    TInt baseLine = 0;

    iKey = CVirtualKey::NewL( *iUnicode, iScanCode, TRect(), 

                              TRect(), baseLine, iHighlightBmpIndex, iHighlightMaskBmpIndex );

    }

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

// CPeninputVkbLayoutInfo::NewL

// (other items were commented in a header)

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

//

EXPORT_C CPeninputVkbLayoutInfo* CPeninputVkbLayoutInfo::NewL(

    TResourceReader& aReader )

    {

    CPeninputVkbLayoutInfo* self = NewLC( aReader );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPeninputVkbLayoutInfo::NewLC

// (other items were commented in a header)

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

//

EXPORT_C CPeninputVkbLayoutInfo* CPeninputVkbLayoutInfo::NewLC( 

    TResourceReader& aReader )

    {

    CPeninputVkbLayoutInfo* self = new ( ELeave ) CPeninputVkbLayoutInfo();

    CleanupStack::PushL( self );

    self->ConstructL( aReader ); 

    return self;

    }

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

// CPeninputVkbLayoutInfo::GetRealSize