/*

* 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 "peninputlayoutvirtualkeyctrl.h"

#include "peninputlayoutvkb.h"

#include "peninputlayout.h"

#include "peninputpluginutils.h"

_LIT( KKeyShiftCharacter, "\x2191");

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();

    }

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

// CVirtualKeyCtrl::DrawKeyText

// Draw key text

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

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

//        

void CVirtualKeyCtrl::DrawKeyText()    

    {

    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(Rect(), 

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

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

			    if ( AknsUtils::AvkonSkinEnabled() )

			        {

			        AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),

				                               color, 

				                               KAknsIIDQsnTextColors, 

				                               iKeyboard->KeyTextColorGroup() );

			        }

			    // replace the shift text to shift icon			        

				if( iKeyboard->ShiftIcon() &&

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

					{

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

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

														 *gc,

														 textLayout.TextRect() );	

					}

				else				    

				    {

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

                                    EFalse, color);

				    }

                }

            }

        }

    if (!textlineset)

        {

		TAknLayoutText textLayout;

		textLayout.LayoutText(Rect(), 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( AknsUtils::SkinInstance(),

		                               color, 

		                               KAknsIIDQsnTextColors, 

		                               iKeyboard->KeyTextColorGroup() );

	        }

	    else

    		{

			color = iKeyboard->iFontColor;

    		}

    	if( iKeyInfo->Dimmed() )

			{			

			color = KRgbGray;	

			}	

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

    		{

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

    		}

    	else

    		{

    		textLayout.DrawText(*BitGc(), 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(AknsUtils::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(AknsUtils::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(); 

    }

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

// 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());

    if(aMask)

        {

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

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

        }

    else

        {

        gc->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(AknsUtils::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 );

        AknsDrawUtils::DrawFrame(AknsUtils::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();        

    }

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

// CVirtualKeyCtrl::DrawHighlightKey

// Draw key in highlight state

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

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

//                

void CVirtualKeyCtrl::DrawHighlightKey()

    {    

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

    TRect rect = Rect();

    TPoint bmpPos = rect.iTl;

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

    if(iVirtualKeyDrawInfo.iVKPressedLeftImgID.iMajor && 

       iVirtualKeyDrawInfo.iVKPressedMiddleImgID.iMajor &&

       iVirtualKeyDrawInfo.iVKPressedRightImgID.iMajor)

        {

        TRect innerRect = Rect();

		innerRect.Shrink( 4, 0 );

		AknPenInputDrawUtils::Draw3PiecesFrame(AknsUtils::SkinInstance(),

								   *gc,

								   Rect(),

								   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 );

        AknsDrawUtils::DrawFrame(AknsUtils::SkinInstance(), 

                                 *gc, 

                                 rect, 

                                 innerrect,

                                 iKeyboard->KeySkinId(EKeyBmpHighlight), 

                                 KAknsIIDDefault); 

        }

    else if( iKeyboard->NonIrregularKeyBitmap( EKeyBmpHighlight ) )

    	{

        TRect srcRect(TPoint(0,0), 

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

        DrawBmp(rect,

                srcRect,

                iKeyboard->NonIrregularKeyBitmap( EKeyBmpHighlight ),

                iKeyboard->NonIrregularKeyBitmap( EKeyBmpHighlightMask ),

                ETrue); 

    	}

    else if(iKeyInfo->HighlightBmpIndex() >= 0 && 

                 iKeyInfo->HighlightBmpIndex() < iKeyboard->iKeyHighLightBmpList.Count())

        {

        gc->DrawBitmap(rect,iKeyboard->iKeyHighLightBmpList[iKeyInfo->HighlightBmpIndex()]);

        }

    else //using fading

        {

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

        gc->SetFaded(ETrue);            

        if(iKeyboard->BackgroundBmp())//use keyboard background bitmap

            {

            gc->BitBlt(bmpPos, iKeyboard->BackgroundBmp(), iKeyInfo->Rect());                

            }

        else //draw background if not 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();    

    }

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

// CVirtualKeyCtrl::Draw

// Draw key

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

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

//                    

void CVirtualKeyCtrl::Draw()

    {

    if(!AbleToDraw())

    	return;    

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

    //mask bitmaps

  	DrawOpaqueMaskBackground();  

    // ----- draw bitmaps -----

    gc->Activate( BitmapDevice() );                

/*    if (iScanCode == -1 && !iKeyInfo->Dimmed() && iKeyboard)

    	{

    	iKeyboard->DimKey(iKeyInfo, ETrue);

    	}*/

    if(iKeyInfo->Dimmed())

        {

        DrawDimKey();

        return;

        }

    if(iKeyInfo->Latched()||(PointerDown()&&!iKeyInfo->IsLatchKey()))

        {        

        DrawHighlightKey();

// remove DrawBubble() into HandlePointerDownEventL()

// to avoid showing more than one bubble at the same time.        

//        iKeyboard->DrawBubble(iKeyInfo);

        }

    else

        {                

        DrawNormalStateKey();

        }

    }

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

// CVirtualKeyCtrl::HandlePointerDownEventL

// Handle pointer down event

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