/*

* Copyright (c) 2006-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 button base and dragbar

*

*/

#include <featmgr.h>

#include <AknFepGlobalEnums.h>

#include "peninputlayoutbutton.h"

#include "peninputlayouttimer.h"

#include "peninputlayout.h"

#ifdef __WINS__

const TInt KSpriteMoveDrawInterval    = 10000; // 1/100 second

#else

const TInt KSpriteMoveDrawInterval    = 1000; // 1/1000 second

#endif

#define __USING_MOVING_FRAME__	//flag to use the moving frame when dragging the layout

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

/******************** start of CButtonBase **********************************/

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

// CButtonBase::NewL

// factory function

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

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

//

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

                                        CFepUiLayout* aUiLayout,TInt aCtrlId)

    {

    CButtonBase* btn=new (ELeave)CButtonBase(aRect,aUiLayout,aCtrlId);

    CleanupStack::PushL(btn);

    btn->BaseConstructL();

    CleanupStack::Pop(btn);

    return btn;    

    }

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

// CButtonBase::BaseConstructL

// Do base contruction

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

//

EXPORT_C void CButtonBase::BaseConstructL()

    {

    CFepUiBaseCtrl::BaseConstructL();

    //tap accuracy enhancement

    if( FeatureManager::FeatureSupported( KFeatureIdFfCapacitiveDisplay ))

        {

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

        }

    }

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

// CButtonBase::CButtonBase

// C++ default constructor

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

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

//

EXPORT_C CButtonBase::CButtonBase(const TRect& aRect,CFepUiLayout* aUiLayout,

                                                                TInt aCtrlId)

                        :CFepUiBaseCtrl(aRect,aUiLayout,aCtrlId),

                         iPressed(EFalse),

                         iStretchable(ETrue),

                         iBaseline(-1),

                         iCaptionColor(KRgbWhite), //white caption

                         iCaptionShadowColor(KRgbBlack) //black caption shadow

    {

    SetControlType(ECtrlButton | ECtrlTactileFeedback);

    iDimmed = EFalse;

#ifdef __ALPHA_TRANCEPARENCY__

    const TRgb KDefaultButtonBackCol = TRgb(30,30,30);

#else

    const TRgb KDefaultButtonBackCol = TRgb(230,230,230);

#endif

    SetBkColor(KDefaultButtonBackCol);

    //todo code refactoring needed, move to BaseConstructL

#ifdef RD_TACTILE_FEEDBACK     

    //Advanced Tactile feedback REQ417-47932

    if(aUiLayout)

    	{

    	if (aUiLayout->PenInputType() == EPluginInputModeFSQ||

    		aUiLayout->PenInputType() == EPluginInputModeVkb)

    		{

    		SetTactileFeedbackType(ETouchFeedbackBasicButton);

    		aUiLayout->RegisterFeedbackArea(reinterpret_cast<TInt>(this),aRect,ETouchFeedbackBasicButton);

    		}

    	else

    		{

    		SetTactileFeedbackType(ETouchFeedbackSensitiveInput);

    		aUiLayout->RegisterFeedbackArea(reinterpret_cast<TInt>(this),aRect,ETouchFeedbackSensitiveInput);

    		}

    	}       

#endif //RD_TACTILE_FEEDBACK     

    }

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

// CButtonBase::~CButtonBase

// Destructor

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

//

EXPORT_C CButtonBase::~CButtonBase()

    {  

    delete iCaption;

    //only free the bitmaps in the pool

    iBmpPool.ResetAndDestroy();    

    //must reset the background bmp otherwise CFepUiBaseCtrl will re-delete it.    

    SetBackgroundBmp(NULL);

    SetBackgroundMaskBmp(NULL);    

    //font

    if(iFontOwnership && iFont)

        {

        BitmapDevice()->ReleaseFont(iFont);

        iFont = NULL;    

        }        

    delete iNoUsedBkbmp;

    delete iNoUsedMaskBkbmp;      

#ifdef RD_TACTILE_FEEDBACK     

    //de-register the area for tactile feedback

    //if(aUiLayout) //there must be aUiLayout

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

#endif // RD_TACTILE_FEEDBACK     

    }

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

// CButtonBase::Draw

// Draw the control

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

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

//    

EXPORT_C void CButtonBase::Draw()

    {

    if(!AbleToDraw())

    	return;    

    if(iWndControl)

        {

        CFepUiBaseCtrl::Draw();

        return;

        }

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

	DrawOpaqueMaskBackground(iStretchable);

        //mask bitmaps

		DrawBackground();            

        //draw caption if there is

    //gc->SetClippingRegion(&ValidClipRegion());  //this cause crash in generic vkb

        if(iCaption && iFont)

            {

            //use font

            gc->UseFont(iFont);

            gc->SetBrushStyle( CGraphicsContext::ENullBrush ); 

            gc->SetPenStyle(CGraphicsContext::ESolidPen);                        

            TRect rect(iRect);

            //draw text shadow first

            rect.Move(1,1);

            TInt baseLine = iBaseline > 0 ? iBaseline : 

                                rect.Height()*KDEFAULTBASELINERATIO;      

            //set pen color for text shadow

            gc->SetPenColor(iCaptionShadowColor);                                      

            gc->DrawText(*iCaption,rect,baseLine,CGraphicsContext::ECenter );

            //Now draw caption on top of the shadow

            //re-cal the baseline

            baseLine = iBaseline > 0 ? iBaseline : 

                                iRect.Height()*KDEFAULTBASELINERATIO;

            gc->SetPenColor(iCaptionColor);              

            gc->DrawText(*iCaption,iRect,baseLine,CGraphicsContext::ECenter );

        gc->DiscardFont();

        }

    gc->CancelClipping();

    }

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

// CButtonBase::HandleButtonDown

// Handle button down event

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

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

//    

EXPORT_C CFepUiBaseCtrl* CButtonBase::HandlePointerDownEventL(const TPoint& aPt)

    {    

    if(iDimmed)

        return NULL;

    CFepUiBaseCtrl::HandlePointerDownEventL(aPt);

    if(IsActive())

        {

        SetBackgroundBmp(iActiveBmpPressed);

        SetBackgroundMaskBmp(iActiveMaskBmpPressed);

        }        

    else

        {

        SetBackgroundBmp(iNonActiveBkBmpPressed);

        SetBackgroundMaskBmp(iNonActiveBkMaskBmpPressed);

        }        

    Draw();

    UpdateArea(Rect(), EFalse);

    ReportEvent(EEventButtonDown);

    return this;

    }

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

// CButtonBase::HandlePointerLeave

// Handle pointer leave event

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

//           

EXPORT_C void CButtonBase::HandlePointerLeave(const TPoint& aPt)

    {

    if(iDimmed)

        return;

    if(IsActive())

        {

        SetBackgroundBmp(iActiveBmp);

        SetBackgroundMaskBmp(iActiveMaskBmp);

        }

    else

        {

        SetBackgroundBmp(iNonActiveBkBmp);

        SetBackgroundMaskBmp(iNonActiveBkMaskBmp);

        }

    Draw();

    UpdateArea(Rect(), EFalse);   

    CFepUiBaseCtrl::HandlePointerLeave(aPt);

    return ;

    }

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

// CButtonBase::HandlePointerEnter

// Handle pointer enter event

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

//           

EXPORT_C void CButtonBase::HandlePointerEnter(const TPoint& aPt)

    {

    if(iDimmed)

        return;

    if(IsActive())

        {

        SetBackgroundBmp(iActiveBmpPressed);

        SetBackgroundMaskBmp(iActiveMaskBmpPressed);

        }        

    else

        {

        SetBackgroundBmp(iNonActiveBkBmpPressed);

        SetBackgroundMaskBmp(iNonActiveBkMaskBmpPressed);

        }

    Draw();

    UpdateArea(Rect(), EFalse);   

    CFepUiBaseCtrl::HandlePointerEnter(aPt);

    }

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

// CButtonBase::HandleButtonUpEventL

// Handle button up event

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

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

//        

EXPORT_C CFepUiBaseCtrl* CButtonBase::HandlePointerUpEventL(const TPoint& /*aPt*/)        

    {

    if(iDimmed)

        return NULL;

    if(IsActive())

        {

        SetBackgroundBmp(iActiveBmp);

        SetBackgroundMaskBmp(iActiveMaskBmp);

        }        

    else

        {

        SetBackgroundBmp(iNonActiveBkBmp);

        SetBackgroundMaskBmp(iNonActiveBkMaskBmp);

        }

    SetActive(ETrue);

    Draw();

    UpdateArea(Rect(), EFalse);    

    ReportEvent(EEventButtonUp);

    return this;

    }

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

// CButtonBase::HandleButtonMoveEventL

// Handle button move event

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

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

//

EXPORT_C CFepUiBaseCtrl* CButtonBase::HandlePointerMoveEventL(const TPoint& /*aPt*/)

    {

    //do nothing

    return this;

    }

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

// CButtonBase::SetActive

// Set button active

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

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

//

EXPORT_C void CButtonBase::SetActive(TBool aActiveFlag)

    {

    if(iDimmed)

        return;

    if(IsActive() != aActiveFlag)

        {

        CFepUiBaseCtrl::SetActive(aActiveFlag);

        if(aActiveFlag)

            {               

            SetBackgroundBmp(iActiveBmp);

            SetBackgroundMaskBmp(iActiveMaskBmp);

            }

        else

            {

            SetBackgroundBmp(iNonActiveBkBmp);

            SetBackgroundMaskBmp(iNonActiveBkMaskBmp);

            }

        if(BitGc())

            {       

            Draw();

            UpdateArea(Rect(),EFalse);

            }

        }

    }

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

// CButtonBase::SetDimmed

// Dim button

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

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

//

EXPORT_C void CButtonBase::SetDimmed(TBool aDimFlag)

    {

    //Remove its active flag if dim an active button.

    if(aDimFlag && IsActive())

        SetActive(EFalse);

    iDimmed = aDimFlag;

    if(iDimmed)

        {        

        SetBackgroundBmp(iDimmedBmp);

        SetBackgroundMaskBmp(iDimmedMaskBmp);

        }

    else

        {        

        // set the bmp according to current status

        if(IsActive())

            {               

            SetBackgroundBmp(iActiveBmp);

            SetBackgroundMaskBmp(iActiveMaskBmp);

            }

        else

            {

            SetBackgroundBmp(iNonActiveBkBmp);

            SetBackgroundMaskBmp(iNonActiveBkMaskBmp);

            }        

        }

    if(BitGc())

        {       

        Draw();

        UpdateArea(Rect(), EFalse);

        }

#ifdef RD_TACTILE_FEEDBACK 

    if(IsKindOfControl(ECtrlTactileFeedback))

        {        

        //if(aDimFlag)

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

        if(!aDimFlag && !Hiden())

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

        }

#endif        

    }

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

// CButtonBase::SetBitmapL

// Set bitmap for given status

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

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

//    

EXPORT_C void CButtonBase::SetBitmapL(CFbsBitmap* aBitmap, TButtonBmpType aType)

    {

    CFbsBitmap* bmp = aBitmap;

    if(!aBitmap)

        return;   

    AddBmpToPool(aBitmap);

    switch(aType)

        {

        case EBtnBmpNonActive :

            {            

            iNonActiveBkBmp = bmp;        

            if(!IsActive())

                SetBackgroundBmp(iNonActiveBkBmp);

            }

            break;

        case EBtnBmpNonActivePressed :

            iNonActiveBkBmpPressed = bmp;

            break;

        case EBtnBmpActive :

            iActiveBmp = bmp;    

            if(IsActive())

                SetBackgroundBmp(iActiveBmp);

            break;

        case EBtnBmpActivePressed :

            iActiveBmpPressed = bmp;        

            break;

        case EBtnBmpDimmed :

            iDimmedBmp = bmp;

            break;

        default:

            break;

        }

    }  

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

// CButtonBase::Bitmap

// get bitmap for given type

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

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

//    

EXPORT_C CFbsBitmap* CButtonBase::Bitmap(TButtonBmpType aType, TBool aMaskFlag)

    {

    CFbsBitmap* bmp = NULL;

    if(!aMaskFlag)

        {

        switch(aType)

            {

            case EBtnBmpNonActive :

                {            

                bmp = iNonActiveBkBmp;

                }

                break;

            case EBtnBmpNonActivePressed :

                bmp = iNonActiveBkBmpPressed;

                break;

            case EBtnBmpActive :

                bmp = iActiveBmp ;

                break;

            case EBtnBmpActivePressed :

                bmp = iActiveBmpPressed;

                break;

            case EBtnBmpDimmed :

                bmp = iDimmedBmp;

                break;

            default:

                break;

            }

        }

    else //get mask bitmap

        {

        switch(aType)

            {

            case EBtnBmpNonActive :

                bmp = iNonActiveBkMaskBmp;

                break;

            case EBtnBmpNonActivePressed :

                bmp = iNonActiveBkMaskBmpPressed;

                break;

            case EBtnBmpActive :

                bmp = iActiveMaskBmp;

                break;

            case EBtnBmpActivePressed :

                bmp = iActiveMaskBmpPressed;

                break;

            case EBtnBmpDimmed :

                bmp = iDimmedMaskBmp;

                break;

            default:

                break;

            }        

        }

    return bmp;

    }  

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

// CButtonBase::SetMaskBitmapL

// Set mask bitmap for given status

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

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

//    

EXPORT_C void CButtonBase::SetMaskBitmapL(CFbsBitmap* aBmp, TButtonBmpType aType)

    {   

    if (!aBmp)

        return;

    AddBmpToPool(aBmp);

    switch(aType)

        {

        case EBtnBmpNonActive :

            iNonActiveBkMaskBmp = aBmp;