/*

* Copyright (c) 2005-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 <AknIconUtils.h>

#include <AknsUtils.h>

#include <AknUtils.h>

#include <AknsDrawUtils.h> 

#include "peninputlayout.h"

#include "peninputlayoutbubblectrl.h"

#include "peninputlayoutvirtualkeyctrl.h"

#include "peninputlayoutvkb.h"

#include "peninputpluginutils.h"

const TInt KFadingParamBlack = 128;

const TInt KFadingParamWhite = 192;

const TInt KDefaultBubbleSize = 50;

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

// Implementation of Class CVirtualKeyboard

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

// CVirtualKeyboard::NewL

// Factory function

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

//

EXPORT_C CVirtualKeyboard* CVirtualKeyboard::NewL(const TRect& aRect, 

                                     CFepUiLayout* aUiLayout,TInt aControlId,

                                     const TFontSpec& aFontSpec,

                                     TBool aIrregular)

    {

    CVirtualKeyboard* vkb = new(ELeave) CVirtualKeyboard(aRect,aUiLayout,

                                                        aControlId,aFontSpec,

                                                        aIrregular);

    CleanupStack::PushL(vkb);

    vkb->ConstructL();

    vkb->SetRect(aRect);

    CleanupStack::Pop();

    return vkb;

    }

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

// CVirtualKeyboard::NewL

// Factory function

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

//

EXPORT_C CVirtualKeyboard* CVirtualKeyboard::NewL(const TRect& aRect, 

                                      CFepUiLayout* aUiLayout,TInt aControlId,

                                      CFont* aFont,

                                      TBool aIrregular)

    {

    TFontSpec fontSpec;

    fontSpec.iHeight = 0;

    CVirtualKeyboard* vkb = new(ELeave) CVirtualKeyboard(aRect,aUiLayout,

                                                        aControlId,fontSpec,

                                                        aIrregular);

    vkb->SetFont(aFont);                                                        

    CleanupStack::PushL(vkb);

    vkb->ConstructL();

    vkb->SetRect(aRect);

    CleanupStack::Pop();

    return vkb;

    }

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

// CVirtualKeyboard::CVirtualKeyboard

// Default constructor

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

//

EXPORT_C CVirtualKeyboard::CVirtualKeyboard(const TRect& /*aRect*/,

                                CFepUiLayout* aUiLayout, TInt aControlId,

                                const TFontSpec& aFontSpec,

                                TBool aIrregular):

                                CControlGroup(aUiLayout,aControlId),

                                iFadingParamBlack(KFadingParamBlack),

                                iFadingParamWhite(KFadingParamWhite),

                                iKeyNormalSkinId(KAknsIIDNone),

                                iKeyHighlightSkinId(KAknsIIDNone),

                                iKeyDimSkinId(KAknsIIDNone),

                                iNeedDrawBackground(ETrue),

                                iIrregularKey(aIrregular),

                                iBubbleCtrl(NULL),

                                iBubbleVerticalMargin(0),                                

                                iKeyTextColorGroup(INVALID_COLOR_GROUP)

    {

    iFontSpec = aFontSpec;   

    SetControlType(ECtrlVirtualKeyboard);

    }

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

// CVirtualKeyboard::~CVirtualKeyboard

// Destructor

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

//

EXPORT_C CVirtualKeyboard::~CVirtualKeyboard()

    {

    if ( iBubbleCtrl )

        delete iBubbleCtrl;

    //free keys

    iKeyArray.ResetAndDestroy();

    iKeyArray.Close();

    //key highlight bitmap

    iKeyHighLightBmpList.ResetAndDestroy();

    iKeyHighLightBmpList.Close();

    iKeyHighLightMaskBmpList.ResetAndDestroy();

    iKeyHighLightMaskBmpList.Close();

    delete iDimKeyBmp;

    delete iDimKeyMaskBmp;

    //font

    if(iFontOwnership && iFont)

        {

        BitmapDevice()->ReleaseFont(iFont);

        iFont = NULL;    

        }

    iUnUsedRawKeyCtrlPool.ResetAndDestroy();

    iUnUsedRawKeyCtrlPool.Close();

    iUnUsedKeyCtrlPool.ResetAndDestroy();

    iUnUsedKeyCtrlPool.Close();    

    iTextLineLayout.Close();

    iTextLineSet.Close();

    iNonIrregularKeyBmpList.ResetAndDestroy();

    iNonIrregularKeyBmpList.Close();

    DestroyIrregularBmps();

    delete iShiftIcon;

    }

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

// CVirtualKeyboard::ConstructL

// 2nd phase constructor

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

//

EXPORT_C void CVirtualKeyboard::ConstructL ()

    {

    CControlGroup::ConstructL();

    if(BitmapDevice() && iFontSpec.iHeight)

        {

        if (KErrNone != BitmapDevice()->GetNearestFontInPixels(iFont,iFontSpec))

            {

            iFont = NULL;

            }

        else

            {

            iFontOwnership =  ETrue;

            }

        }

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

        {

        iTextLineLayout.AppendL(TAknTextLineLayout());

        iTextLineSet.AppendL(EFalse);

        }

    if (iIrregularKey)

        {

        ConstructIrregularBmps();    

        }        

    }

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

// CVirtualKeyboard::AddKeyL

// Add a key to key board

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

//

EXPORT_C void CVirtualKeyboard::AddKeyL(CVirtualKey* aKey)

    {

    if(aKey)

        {

        iKeyArray.AppendL(aKey);

        //create key control

        CVirtualKeyCtrl* ctrl = CreateKeyCtrlL(aKey,EFalse);//CVirtualKeyCtrl::NewL(this,aKey);

#ifdef RD_TACTILE_FEEDBACK 

        //Advanced Tactile feedback REQ417-47932

        ctrl->SetTactileFeedbackType(ETouchFeedbackSensitiveKeypad);

        UiLayout()->RegisterFeedbackArea(reinterpret_cast<TInt>(ctrl),ctrl->Rect(),ETouchFeedbackSensitiveKeypad);

#endif	  

        CleanupStack::PushL(ctrl);

        AddKeyControlL(ctrl);

        CleanupStack::Pop();

        if (aKey->ScanCode() == -1)

            {

            DimKey(aKey, ETrue);

            }

        }        

    }

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

// CVirtualKeyboard::AddRawKeyL

// Add a raw key to key board

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

//

EXPORT_C void CVirtualKeyboard::AddRawKeyL(CVirtualKey* aKey)

    {

    if(aKey)

        {

        iKeyArray.AppendL(aKey);

        //create key control

        //CVirtualRawKeyCtrl* ctrl = CVirtualRawKeyCtrl::NewL(this,aKey);

        CVirtualRawKeyCtrl* ctrl = static_cast<CVirtualRawKeyCtrl*>(CreateKeyCtrlL(aKey,ETrue));

#ifdef RD_TACTILE_FEEDBACK 

        //Advanced Tactile feedback REQ417-47932

        ctrl->SetTactileFeedbackType(ETouchFeedbackSensitiveKeypad);

        UiLayout()->RegisterFeedbackArea(reinterpret_cast<TInt>(ctrl),ctrl->Rect(),ETouchFeedbackSensitiveKeypad);            

#endif	        

        CleanupStack::PushL(ctrl);

        AddKeyControlL(ctrl);

        CleanupStack::Pop();

        if (aKey->ScanCode() == -1)

            {

            DimKey(aKey, ETrue);

            }        

        }        

    }

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

// CVirtualKeyboard::RemoveKey

// Remove a key from keyboard

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

//

EXPORT_C void CVirtualKeyboard::RemoveKey(CVirtualKey* aKey)

    {

    if(!aKey)

        return;

    TInt idx = iKeyArray.Find(aKey);

    if(KErrNotFound != idx)

        {				

        iKeyArray.Remove(idx);

		CVirtualKeyCtrl* ctrl = FindCtrlForKey(aKey);

#ifdef RD_TACTILE_FEEDBACK 

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

#endif		

        if(iActiveCtrl == ctrl)

            iActiveCtrl = 0;            

        RemoveKeyControl(ctrl);

        aKey->iKeyCtrl = 0;

        }

    }

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

// CVirtualKeyboard::FindCtrlForKey

// Find the key control which has the virtual key information.

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

//    

CVirtualKeyCtrl* CVirtualKeyboard::FindCtrlForKey(const CVirtualKey* aKey)

    { 

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

        {

        CVirtualKeyCtrl* keyCtrl = static_cast<CVirtualKeyCtrl*>(ControlList()[i]);

        if(keyCtrl->iKeyInfo == aKey)

            return keyCtrl;

        }	      

    return 0;

    }

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

// CVirtualKeyboard::CreateKeyL

// Add a key to keyboard

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

//

EXPORT_C void CVirtualKeyboard::CreateKeyL(TUint aCode, TUint aScanCode, 

                    const TRect& aRect, const TRect& aDrawRect, TInt aBaseline,

                    TInt aHighlightBmpIdx,TInt aHighlightMaskBmpId)

    {

    CVirtualKey* key = CVirtualKey::NewL(aCode,aScanCode,aRect,aDrawRect,

                                aBaseline,aHighlightBmpIdx,aHighlightMaskBmpId);

    CleanupStack::PushL(key);

    AddKeyL(key);

    CleanupStack::Pop(key);  

    }

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

// CVirtualKeyboard::CreateKeyL

// Add a key to keyboard

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

//

EXPORT_C void CVirtualKeyboard::CreateKeyL(const TDesC& aCode, TUint aScanCode, 

                    const TRect& aRect, const TRect& aDrawRect, TInt aBaseline,

                    TInt aHighlightBmpIdx,TInt aHighlightMaskBmpId)

    {

    CVirtualKey* key = CVirtualKey::NewL(aCode,aScanCode,aRect,aDrawRect,

                                aBaseline,aHighlightBmpIdx,aHighlightMaskBmpId);

    CleanupStack::PushL(key);

    AddKeyL(key);    

    //key->SetKeyboard(this);  

    //key->iKeyboard = this;

    CleanupStack::Pop(key);  

    }

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

// CVirtualKeyboard::CreateRawKeyL

// Add a key to keyboard

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

//

EXPORT_C void CVirtualKeyboard::CreateRawKeyL(TUint aCode, TUint aScanCode, 

                    const TRect& aRect, const TRect& aDrawRect, TInt aBaseline,

                    TInt aHighlightBmpIdx,TInt aHighlightMaskBmpId)

    {

    CVirtualKey* key = CVirtualKey::NewL(aCode,aScanCode,aRect,aDrawRect,

                                aBaseline,aHighlightBmpIdx,aHighlightMaskBmpId);

    CleanupStack::PushL(key);

    AddRawKeyL(key);

    CleanupStack::Pop(key);  

    }

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

// CVirtualKeyboard::CreateRawKeyL

// Add a key to keyboard

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

//

EXPORT_C void CVirtualKeyboard::CreateRawKeyL(const TDesC& aCode, TUint aScanCode, 

                    const TRect& aRect, const TRect& aDrawRect, TInt aBaseline,

                    TInt aHighlightBmpIdx,TInt aHighlightMaskBmpId)

    {

    CVirtualKey* key = CVirtualKey::NewL(aCode,aScanCode,aRect,aDrawRect,

                                aBaseline,aHighlightBmpIdx,aHighlightMaskBmpId);

    CleanupStack::PushL(key);

    AddRawKeyL(key);    

    CleanupStack::Pop(key);

    }

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

// CVirtualKeyboard::CreateRawKeyL

// Add a key to keyboard

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

//

EXPORT_C void CVirtualKeyboard::CreateRawKeyL(RPointerArray<HBufC>& aUnicodesList,

                                              TInt aScanCode,

                                              const TRect& aRect)

    {

    CVirtualKey* key = CVirtualKey::NewL(aUnicodesList,

                                         aScanCode,

                                         aRect);

    CleanupStack::PushL(key);

    AddRawKeyL(key);    

    CleanupStack::Pop(key);

    }

// CVirtualKeyboard::Draw

// Draw virtual keyboard

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

// 

EXPORT_C void CVirtualKeyboard::Draw()

    {

    if(!AbleToDraw())

    	return;    

    const TRect& keyboardRect = Rect();

    if (iNeedDrawBackground)

        {

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

        //mask bitmaps

      if (!iIrregularKey)

	      {

	      DrawOpaqueMaskBackground();  	

	      }

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

        gc->Activate( BitmapDevice() );

        if(!BackgroundBmp())

            {

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

            gc->SetBrushColor( BkColor());

            gc->SetPenColor( KRgbBlack );

            gc->SetPenStyle(CGraphicsContext::ESolidPen);

           if (!iIrregularKey)

      	      {

              gc->DrawRect(keyboardRect);

              }

            }

        else

            {

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

            if(BkMaskBmp())

                {

                TRect bmpRect(TPoint(0,0),BkMaskBmp()->SizeInPixels());

                if (!iIrregularKey)

	         	    {

	                gc->DrawBitmapMasked(keyboardRect,BackgroundBmp(),bmpRect,BkMaskBmp(),EFalse);

	                }

                }

            else        

                {

         	    if (!iIrregularKey)

	        	    {

	                gc->DrawBitmap(keyboardRect,BackgroundBmp());

	                }

                }

            }    

        gc->SetBrushStyle( CGraphicsContext::ENullBrush );       

        }

    //draw each key control

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

        {

        CVirtualKeyCtrl* ctrl = static_cast<CVirtualKeyCtrl*>(ControlList()[i]);

        ctrl->Draw();

        }

    }

void CVirtualKeyboard::ClearBubble(TBool /*aSetZeroSize*/)

    {

    if ( iBubbleCtrl )

        {

        iBubbleCtrl->Close();

        }

    }

void CVirtualKeyboard::DrawBubble(CVirtualKey* aKey)

    {

    if ( aKey && !aKey->Dimmed() && iBubbleCtrl && iIsShowBubble)

        {

        TRect rect = iBubbleCtrl->Rect();

        TRect parentWndRect = Rect();       

        TInt x1 = aKey->Rect().iTl.iX - ( iBubbleSize.iWidth - aKey->Rect().Width() ) / 2;

        TInt x2 = aKey->Rect().iBr.iX + ( iBubbleSize.iWidth - aKey->Rect().Width() ) / 2;

        if ( x1 < 0 )

            {

            rect.iTl.iX = parentWndRect.iTl.iX;     

            rect.iBr.iX = iBubbleSize.iWidth; 

            }

        else if ( x2 > parentWndRect.iBr.iX )

            {

            rect.iTl.iX = parentWndRect.iBr.iX - iBubbleSize.iWidth;     

            rect.iBr.iX = parentWndRect.iBr.iX;                 

            }

        else

            {

            rect.iTl.iX = x1;     

            rect.iBr.iX = x2;                 

            }

        rect.iTl.iY = iBubbleVerticalMargin + aKey->Rect().iTl.iY - 

                      iBubbleSize.iHeight + Rect().iTl.iY;

        rect.iBr.iY = iBubbleVerticalMargin + aKey->Rect().iTl.iY + Rect().iTl.iY;

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

			{

			TRAP_IGNORE(iBubbleCtrl->SetTextL(*aKey->DisplayUnicode()));		

			}

        else

        	{

        	TRAP_IGNORE(iBubbleCtrl->SetTextL(aKey->KeyUnicodes()));			

        	}

        iBubbleCtrl->Popup(rect);

        }

    }

EXPORT_C void CVirtualKeyboard::ShowBubble(TBool aFlag)

    {  

    TBool flag = iBubbleCtrl ? ETrue : EFalse;

    iIsShowBubble = aFlag;

    if ( flag != aFlag )

        {

        if(!flag)

            {

            TRAP_IGNORE(iBubbleCtrl = CBubbleCtrl::NewL(TRect(0,0,0,0),UiLayout(),-0xFFFF));

            iBubbleSize = TSize(KDefaultBubbleSize,KDefaultBubbleSize);

            }

        }

    }

EXPORT_C TBool CVirtualKeyboard::GowithPointerDown()

    {

    return iGowithPointerDown;

    }

EXPORT_C void CVirtualKeyboard::SetGowithPointerDown(TBool aFlag)

    {

    iGowithPointerDown = aFlag;

    }

EXPORT_C void CVirtualKeyboard::SetBubbleBitmapParam(CFbsBitmap* aBmpId,

                                                     CFbsBitmap* aMaskBmpId ,

                                                     TAknsItemID aBgSkinId )

    {

    if ( iBubbleCtrl )

        {

        iBubbleCtrl->SetBitmapParam(aBmpId,aMaskBmpId,aBgSkinId);

        }

    }

EXPORT_C void CVirtualKeyboard::SetBubbleSize(const TSize& aSize)

    {

    iBubbleSize = aSize;

    }

EXPORT_C void CVirtualKeyboard::SetBubbleVerticalMargin(TInt aMargin)

    {

    iBubbleVerticalMargin = aMargin;