/*

* Copyright (c) 2007-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:  Implementation for PeninputLayoutControl

*

*/

//#include <e32base.h>

#include <AknIconUtils.h>

#include <w32std.h>

#include <AknsDrawUtils.h>

#include <eikenv.h>

#include <AknsConstants.h>

#include <AknUtils.h>

#include <featmgr.h>

#include "peninputlayoutvirtualkeyctrl.h"

#include "peninputlayoutvkb.h"

#include "peninputlayout.h"

#include "peninputpluginutils.h"

#include "peninputcmd.h"

_LIT( KKeyShiftCharacter, "\x2191");

_LIT( KKeyStarCharacter, "\x002a");

const TInt KDefaultKeyMargin = 10;

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

// CVirtualKeyCtrl::NewL

// Static factory creator

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

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

//

CVirtualKeyCtrl* CVirtualKeyCtrl::NewL(CVirtualKeyboard* aKeyboard,

                                                        CVirtualKey* aKeyInfo)

    {

    if(!aKeyInfo || !aKeyboard)

        return 0;

    CVirtualKeyCtrl* keyCtrl = new(ELeave) CVirtualKeyCtrl(aKeyboard,aKeyInfo);

    CleanupStack::PushL(keyCtrl);

    keyCtrl->ConstructL();

    CleanupStack::Pop();    

    return keyCtrl;    

    }

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

// CVirtualKeyCtrl::CVirtualKeyCtrl

// constuctor

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

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

//    

CVirtualKeyCtrl::CVirtualKeyCtrl(CVirtualKeyboard* aKeyboard, CVirtualKey* aKeyInfo)

                                 :CFepUiBaseCtrl(aKeyInfo->Rect(), aKeyboard->UiLayout(),-1),

                                  iKeyInfo(aKeyInfo), iKeyboard(aKeyboard)

    {

    SetControlType(ECtrlVirtualKey);    

    //virtual key postion is kept as relative to key board, so we must change the 

    //key control's position relative to layout.

    Move(aKeyboard->Rect().iTl);

#ifdef RD_TACTILE_FEEDBACK     

    //register the key feedback area

    //UiLayout()->RegisterFeedbackArea(reinterpret_cast<TInt>(this),Rect());    

#endif // RD_TACTILE_FEEDBACK 

    aKeyInfo->iKeyCtrl = this;

    iScanCode = aKeyInfo->ScanCode();

    }

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

// CVirtualKeyCtrl::~CVirtualKeyCtrl

// destructor

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

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

//    

CVirtualKeyCtrl::~CVirtualKeyCtrl()

    {

    //Never uncomment the following statement. When this control is deleted,

    //iKeyInfo may be already invalid!!!

    //iKeyInfo->iKeyCtrl = 0;

#ifdef RD_TACTILE_FEEDBACK     

    UiLayout()->DeRegisterFeedbackArea(reinterpret_cast<TInt>(this),Rect());            

#endif // RD_TACTILE_FEEDBACK     

    }

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

// CVirtualKeyCtrl::ConsructL

// 2nd phase constuctor

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

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

//        

void CVirtualKeyCtrl::ConstructL()

    {

    BaseConstructL();

    //tap accuracy enhancement

    if( FeatureManager::FeatureSupported( KFeatureIdFfCapacitiveDisplay ))

        {

        EnableExtResponseArea( ETrue, TRect(TPoint(10,10),TSize(10,10)) );

        }

    }

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

// CVirtualKeyCtrl::DrawKeyText

// Draw key text

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

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

//        

void CVirtualKeyCtrl::DrawKeyText(CFbsBitGc* aGc)  

    {

    TBool textlineset = EFalse;

    // if text line set

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

        {

        if (iKeyboard->TextLineLayoutSet(TVirtualKeyTextPos(i)))

            {

            textlineset = ETrue;

            if (iKeyInfo->KeyUnicodes(TVirtualKeyTextPos(i)) != KNullDesC)

                {

                TAknLayoutText textLayout;

                textLayout.LayoutText(GetRect(), 

                                      iKeyboard->TextLineLayout(TVirtualKeyTextPos(i)));

				TRgb color( KRgbBlack );  // sane default for nonskinned case			    

			    if ( AknsUtils::AvkonSkinEnabled() )

			        {

			        AknsUtils::GetCachedColor( UiLayout()->SkinInstance(),

				                               color, 

				                               KAknsIIDQsnTextColors, 

				                               iKeyboard->KeyTextColorGroup() );

			        }

			    // replace the shift text to shift icon			        

				if( iKeyboard->ShiftIcon() &&

					iKeyInfo->KeyUnicodes(TVirtualKeyTextPos(i)) == KKeyShiftCharacter )

					{

					//CFbsBitGc* gc = GetGc();//static_cast<CFbsBitGc*>(BitGc());

					AknPenInputDrawUtils::DrawColorIcon( iKeyboard->ShiftIcon(),

														 *aGc,

														 textLayout.TextRect() );	

					}

				else if(iKeyboard->StarIcon() &&

						iKeyInfo->KeyUnicodes(TVirtualKeyTextPos(i)) == KKeyStarCharacter )

					{

					//CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());

					AknPenInputDrawUtils::DrawColorIcon( iKeyboard->StarIcon(),

														 *aGc,

														 textLayout.TextRect() );		

					}

				else				    

				    {

				    textLayout.DrawText(*aGc, iKeyInfo->KeyUnicodes(TVirtualKeyTextPos(i)), 

                                    EFalse, color);

				    }

                }

            }

        }

    if (!textlineset)

        {

		TAknLayoutText textLayout;

		textLayout.LayoutText(GetRect(), iKeyboard->iVKBTextLineLayout);

	    //CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());    

	    //charRect.Move(keyboardRect.iTl);

	    //if(iKeyInfo->Dimmed())

	    //    {        

	    //    gc->SetFadingParameters(iKeyboard->iFadingParamBlack, iKeyboard->iFadingParamWhite);

	    //    gc->SetFaded(ETrue);            

	    //    }

		TRgb color( KRgbBlack );  // sane default for nonskinned case			    

	    if ( AknsUtils::AvkonSkinEnabled() || 

	    	 iKeyboard->KeyTextColorGroup() != INVALID_COLOR_GROUP )

	        {

	        AknsUtils::GetCachedColor( UiLayout()->SkinInstance(),

		                               color, 

		                               KAknsIIDQsnTextColors, 

		                               iKeyboard->KeyTextColorGroup() );

	        }

	    else

    		{

			color = iKeyboard->iFontColor;

    		}

    	if( iKeyInfo->Dimmed() )

			{			

			color = KRgbGray;	

			}	

    	if( iKeyInfo->DisplayUnicode() && iKeyInfo->DisplayUnicode()->Length() != 0)

    		{

    		textLayout.DrawText(*aGc, *iKeyInfo->DisplayUnicode(), EFalse, color);		

    		}

    	else

    		{

    		textLayout.DrawText(*aGc, iKeyInfo->KeyUnicodes(), EFalse, color);		

    		}		

	    //if(iKeyInfo->Dimmed())

	    //    gc->SetFaded(EFalse);            

    	}

    }

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

// CVirtualKeyCtrl::DrawDimKey

// Draw dimmed key

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

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

//        

void CVirtualKeyCtrl::DrawDimKey()

    {

    CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());    

    TRect rect = Rect();

    TRect bmpRect(TPoint(0,0),rect.Size());    

    gc->Activate( BitmapDevice() );

    if(iVirtualKeyDrawInfo.iVKDimLeftImgID.iMajor && 

       iVirtualKeyDrawInfo.iVKDimMiddleImgID.iMajor &&

       iVirtualKeyDrawInfo.iVKDimRightImgID.iMajor)

        {

        TRect innerRect = Rect();

		innerRect.Shrink( 4, 0 );

		AknPenInputDrawUtils::Draw3PiecesFrame(UiLayout()->SkinInstance(),

								   *gc,

								   Rect(),

								   innerRect,

								   iVirtualKeyDrawInfo.iVKDimLeftImgID,

								   iVirtualKeyDrawInfo.iVKDimMiddleImgID,

								   iVirtualKeyDrawInfo.iVKDimRightImgID);

        }

    else if (iKeyboard->IsIrregularKeyBoard())

        {

        DrawIrregularKey(EKeyStateDimmed, EKeyStateDimmedMask);

        }

    else if (iKeyboard->KeySkinId(EKeyBmpDim) != KAknsIIDNone)

        {

        TRect innerrect = rect;

        innerrect.Shrink( KDefaultKeyMargin, KDefaultKeyMargin );

        AknsDrawUtils::DrawFrame(UiLayout()->SkinInstance(),

                                 *gc,

                                 rect,

                                 innerrect,

                                 iKeyboard->KeySkinId(EKeyBmpDim),

                                 KAknsIIDDefault);

        }

    else if( iKeyboard->NonIrregularKeyBitmap( EKeyBmpDim ) )

    	{

        TRect srcRect(TPoint(0,0), iKeyboard->NonIrregularKeyBitmap( EKeyBmpDim )->SizeInPixels());

        DrawBmp(rect,

                srcRect,

                iKeyboard->NonIrregularKeyBitmap( EKeyBmpDim ),

                iKeyboard->NonIrregularKeyBitmap( EkeyBmpDimMask ),

                ETrue); 

    	}

    else if (iKeyboard->iDimKeyBmp)

        {

        TRect srcRect(TPoint(0,0),iKeyboard->iDimKeyBmp->SizeInPixels());

        DrawBmp(rect,srcRect,iKeyboard->iDimKeyBmp,

                                            iKeyboard->iDimKeyMaskBmp,ETrue);

        }    

    else

        {

        gc->SetFaded(ETrue);

        //use if keboard has background bitmap            

        if (iKeyboard->BackgroundBmp())

            {

            TRect srcRect = Rect();

            srcRect.Move(-iKeyboard->Rect().iTl);

            DrawBmp(Rect(),srcRect,iKeyboard->BackgroundBmp(),iKeyboard->BkMaskBmp());

            }

        else

            {

            //self draw background if background bitmap

            gc->SetBrushColor( BkColor());

            gc->SetPenColor( BkColor() );

            gc->SetBrushStyle( CGraphicsContext::ESolidBrush );                

            gc->DrawRect(rect);		                      

            }

        }

    gc->SetPenColor(KRgbBlack);

    gc->SetBrushStyle( CGraphicsContext::ENullBrush );    

    //Draw text again.

    DrawKeyText(gc); 

    }

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

// CVirtualKeyCtrl::DrawBmp

// Draw bitmap

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

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

//        

void CVirtualKeyCtrl::DrawBmp(const TRect& aDestRect,const TRect& aSourceRect,

                                  const CFbsBitmap* aBmp,CFbsBitmap* aMask,

                                  TBool aInvertFlag)

    {

    CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());

    DrawBmp(gc,aDestRect,aSourceRect,aBmp,aMask,aInvertFlag);					     

    }

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

// CVirtualKeyCtrl::DrawBmp

// Draw bitmap

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

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

//        

void CVirtualKeyCtrl::DrawBmp(CFbsBitGc* aGc, const TRect& aDestRect,const TRect& aSourceRect,

                                  const CFbsBitmap* aBmp,CFbsBitmap* aMask,

                                  TBool aInvertFlag)

    {

    if(aMask)

        {

        //TRect bmpRect(TPoint(0,0),aMask->SizeInPixels());

        aGc->DrawBitmapMasked(aDestRect,aBmp,aSourceRect,aMask,aInvertFlag);        

        }

    else

        {

        aGc->DrawBitmap(aDestRect,aBmp,aSourceRect);

        }                            

    }

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

// CVirtualKeyCtrl::DrawNormalStateKey

// Draw key in normal state

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

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

//            

void CVirtualKeyCtrl::DrawNormalStateKey()

    {    

    CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());

    TRect rect = Rect();    

    TRect bmpRect(TPoint(0,0),rect.Size());

    if(iVirtualKeyDrawInfo.iVKLeftImgID.iMajor && 

       iVirtualKeyDrawInfo.iVKMiddleImgID.iMajor &&

       iVirtualKeyDrawInfo.iVKRightImgID.iMajor)

        {

        TRect innerRect = Rect();

		innerRect.Shrink( 4, 0 );

		AknPenInputDrawUtils::Draw3PiecesFrame(UiLayout()->SkinInstance(),

								   *gc,

								   Rect(),

								   innerRect,

								   iVirtualKeyDrawInfo.iVKLeftImgID,

								   iVirtualKeyDrawInfo.iVKMiddleImgID,

								   iVirtualKeyDrawInfo.iVKRightImgID);

        }

    else if (iKeyboard->IsIrregularKeyBoard())

        {

        DrawIrregularKey(EKeyStateNormal, EKeyStateNormalMask);

        }

    else if (iKeyboard->KeySkinId(EKeyBmpNormal) != KAknsIIDNone)

        {

        TRect innerrect = rect;

        innerrect.Shrink( KDefaultKeyMargin, KDefaultKeyMargin );

        TBool bHasDrawn = EFalse;

        if(UiLayout()->NotDrawToLayoutDevice())

            {

            /*TBool ret = iKeyboard->PrepareKeyBmp(iKeyboard->NormalKeyBmp(),

                                    iKeyboard->NormalKeyDev(),

                                    rect,innerrect,

                                    iKeyboard->KeySkinId(EKeyBmpNormal), 

                                    KAknsIIDDefault,Rect());*/

            TBool ret = iKeyboard->PrepareNormalKeyBmp(rect,innerrect,Rect());                                    

            if(ret)

                {

                gc->BitBlt(rect.iTl,iKeyboard->NormalKeyBmp());

                bHasDrawn = ETrue;

                }

            }

        if(!bHasDrawn)

            {

	        AknsDrawUtils::DrawFrame(UiLayout()->SkinInstance(), 

	                                 *gc, 

	                                 rect, 

	                                 innerrect,

	                                 iKeyboard->KeySkinId(EKeyBmpNormal), 

	                                 KAknsIIDDefault); 

            }

        }

    else if( iKeyboard->NonIrregularKeyBitmap( EKeyBmpNormal ) )

    	{

        TRect srcRect(TPoint(0,0), 

                      iKeyboard->NonIrregularKeyBitmap( EKeyBmpNormal )->SizeInPixels());

        DrawBmp(rect,

                srcRect,

                iKeyboard->NonIrregularKeyBitmap( EKeyBmpNormal ),

                iKeyboard->NonIrregularKeyBitmap( EKeyBmpNormalMask ),

                ETrue); 

    	}

    else

        {

        gc->SetFaded(EFalse);

        //use if keboard has background bitmap            

        if (iKeyboard->BackgroundBmp())

            {

            TRect srcRect = Rect();

            srcRect.Move(-iKeyboard->Rect().iTl);

            DrawBmp(Rect(),srcRect,iKeyboard->BackgroundBmp(),iKeyboard->BkMaskBmp());

            }

        else

            {

            //self draw background if background bitmap

            gc->SetBrushColor( BkColor());

            gc->SetPenColor( BkColor() );

            gc->SetBrushStyle( CGraphicsContext::ESolidBrush );                

            gc->DrawRect(rect);		                      

            }

        }        

    gc->SetPenColor( KRgbBlack );

    gc->SetBrushStyle( CGraphicsContext::ENullBrush );    

    gc->SetFaded(EFalse);            

    DrawKeyText(gc);        

    }

CFbsBitGc* CVirtualKeyCtrl::GetGc()

    {

    if(UiLayout()->NotDrawToLayoutDevice())

        {

        //draw to highligh bitmap

        if(Keyboard()->Bitmap()->SizeInPixels() != Rect().Size())

            {

            Keyboard()->Bitmap()->Resize(Rect().Size());

            Keyboard()->HighlightDev()->Resize( Rect().Size());

                //gc must be adjusted

            Keyboard()->HighlightGc()->Activate(Keyboard()->HighlightDev());

            Keyboard()->HighlightGc()->Resized();

            }

        return Keyboard()->HighlightGc();

        }

    else

        return static_cast<CFbsBitGc*>(BitGc());

    }

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

// CVirtualKeyCtrl::DrawHighlightKey

// Draw key in highlight state

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

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

//                

void CVirtualKeyCtrl::DrawHighlightKey()

    {    

    CFbsBitGc* gc = GetGc();

    if(UiLayout()->NotDrawToLayoutDevice())

        gc->Activate( Keyboard()->HighlightDev() );

    TRect rect = GetRect();

    TPoint bmpPos = rect.iTl;

    TRect bmpRect(TPoint(0,0),rect.Size());

    if(iVirtualKeyDrawInfo.iVKPressedLeftImgID.iMajor && 

       iVirtualKeyDrawInfo.iVKPressedMiddleImgID.iMajor &&

       iVirtualKeyDrawInfo.iVKPressedRightImgID.iMajor)

        {

        TRect innerRect = GetRect();

		innerRect.Shrink( 4, 0 );

		AknPenInputDrawUtils::Draw3PiecesFrame(UiLayout()->SkinInstance(),

								   *gc,

								   GetRect(),

								   innerRect,

								   iVirtualKeyDrawInfo.iVKPressedLeftImgID,

								   iVirtualKeyDrawInfo.iVKPressedMiddleImgID,

								   iVirtualKeyDrawInfo.iVKPressedRightImgID);

        }

    else if (iKeyboard->IsIrregularKeyBoard())

        {

        DrawIrregularKey(EKeyStatePressed, EKeyStatePressedMask);

        }

    //do we have highlight background bmp for this key?

    else if (iKeyboard->KeySkinId(EKeyBmpHighlight) != KAknsIIDNone)

        {

        TRect innerrect = rect;

        innerrect.Shrink( KDefaultKeyMargin, KDefaultKeyMargin );

        TBool bHasDrawn = EFalse;

        if(UiLayout()->NotDrawToLayoutDevice())

            {

            /*TBool ret = iKeyboard->PrepareKeyBmp(iKeyboard->HighightKeyBmp(),

                                    iKeyboard->HighlightKeyDev(),

                                    rect,innerrect,

                                    iKeyboard->KeySkinId(EKeyBmpHighlight), 

                                    KAknsIIDDefault,Rect());*/

            TBool ret = iKeyboard->PrepareHighlightKeyBmp(rect,innerrect,Rect());                                    

            if(ret)

                {

                gc->BitBlt(rect.iTl,iKeyboard->HighightKeyBmp());

                bHasDrawn = ETrue;