/*

* 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 base control

*

*/

#include <AknIconUtils.h>

#include "peninputlayouttimer.h"

#include "peninputlayoutbasecontrol.h"

#include "peninputlayoutbutton.h"

#include "peninputlayouthwrwnd.h"

#include "peninputlayoutcandidatewnd.h"

#include "peninputlayoutrootctrl.h"

#include "peninputlayout.h"

#include <coecntrl.h>

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

// Implementation of Class CFepUiBaseCtrl 

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

// CFepUiBaseCtrl::CFepUiBaseCtrl

// C++ default constructor

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

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

//

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

                        TInt aControlId):

                        iPointerLeft(EFalse),

                        iRect(aRect),

                        iShadowRect(TRect(0,0,0,0)),

                        iResourceId(-1),

                        iBorderColor(KRgbBlack),

                        iUpdateFlagEnabled(ETrue),

                        iControlId(aControlId),

                        iControlType( ECtrlBaseCtrl),

                        iBackgroundCol( KRgbWhite),

                        iMaskBkCol(KOpaqueColor),

                        iPenColor(KRgbBlack),

                        iHiden(EFalse),

                        iPointerDown(EFalse),

                        iReady( EFalse),

                        iIsActive(EFalse),

                        iAllowOverlap(EFalse),

                        iUiLayout(aUiLayout),

                        iOwnWndCtrl(ETrue),

                        iOrdinalPos(EOrderNomal)

    {

    iPenSize.SetSize(1,1);        

    iBorderSize.SetSize(KDefaultFrameWidth,KDefaultFrameWidth);

    iValidRegion.AddRect(iRect);

    iClipRegion.AddRect(iRect);

    }

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

// CFepUiBaseCtrl::CFepUiBaseCtrl

// C++  constructor

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

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

//

CFepUiBaseCtrl::CFepUiBaseCtrl(CCoeControl* aControl, CFepUiLayout* aUiLayout,

                                TBool aOwnership)

                  : iPointerLeft(EFalse),

                    //iRect(aRect),

                    iShadowRect(TRect(0,0,0,0)),

                    iWndControl(aControl),

                    iBorderColor(KRgbBlack),                    

                    //iControlId(aControlId),

                    iControlType( ECtrlBaseCtrl|ECtrlWndBasedCtrl),

                    iBackgroundCol( KRgbWhite),

                    iMaskBkCol(KOpaqueColor),

                    iPenColor(KRgbBlack),

                    iHiden(EFalse),

                    iPointerDown(EFalse),

                    iReady( EFalse),

                    iIsActive(EFalse),

                    iAllowOverlap(EFalse),

                    iUiLayout(aUiLayout),

                    iOwnWndCtrl(aOwnership)

    {

    iRect = aControl->Rect();

    iControlId = aControl->UniqueHandle();

    iValidRegion.AddRect(iRect);

    iClipRegion.AddRect(iRect);

    }

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

// CFepUiBaseCtrl::~CFepUiBaseCtrl

// C++  destructor

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

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

//

EXPORT_C CFepUiBaseCtrl::~CFepUiBaseCtrl()

    {

    iEventObserverList.Close();

    iValidRegion.Close();

    iClipRegion.Close();

    iClipRegionWithoutLockedArea.Clear();

    iClipRegionWithoutLockedArea.Close();

    delete iBackgroundBmp;

    delete iBkMaskBmp;

    //delete [] iEventData;

    for(TInt i = 0; i< 2*KShadowBitmapTotalNum; i++)

        delete iShadowBmp[i];    

    if(iOwnWndCtrl)    

        delete iWndControl;

#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 

    }

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

// CFepUiBaseCtrl::BaseConstructL

// Handle UI event

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

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

//

EXPORT_C void CFepUiBaseCtrl::BaseConstructL()

    {

    __ASSERT_DEBUG(iUiLayout,User::Leave(EUiLayoutNotReady));    

    iRootCtrl = iUiLayout->RootControl();

    iLayoutOwner = iUiLayout->LayoutOwner();

    //__ASSERT_DEBUG(iLayoutOwner,User::Leave(EUiLayoutOwnerNotReady));        

    iReady = ETrue;            

    for(TInt i = 0; i< 2*KShadowBitmapTotalNum; i++)

        iShadowBmp[i] = NULL;

    __ASSERT_DEBUG(iControlType != ECtrlBaseCtrl,

                                        User::Leave(EUiLayoutBadControlType));

    }

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

// CFepUiBaseCtrl::BaseConstructL

// Handle UI event

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

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

//

void CFepUiBaseCtrl::BaseConstructL(CFepUiLayoutRootCtrl* aRoot)

    {   

    iRootCtrl = aRoot;

    iLayoutOwner = iUiLayout->LayoutOwner();

    __ASSERT_DEBUG(iLayoutOwner,User::Leave(EUiLayoutOwnerNotReady));        

    iReady = ETrue;            

    for(TInt i = 0; i< 2*KShadowBitmapTotalNum; i++)

        iShadowBmp[i] = NULL;

    __ASSERT_DEBUG(iControlType != ECtrlBaseCtrl,

                                        User::Leave(EUiLayoutBadControlType));

    }

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

// Set tactile feedback type

// Advanced Tactile feedback REQ417-47932

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

//

EXPORT_C void CFepUiBaseCtrl::SetTactileFeedbackType(TInt aTactileType)

	{

#ifdef RD_TACTILE_FEEDBACK

#endif // RD_TACTILE_FEEDBACK 

	}

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

// CFepUiBaseCtrl::CapturePointer

// Capture or release the pointer

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

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

//    

EXPORT_C CFepUiBaseCtrl* CFepUiBaseCtrl::CapturePointer(TBool aFlag)

    {

    return RootControl()->CapturePointer(this,aFlag);

    }

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

// CFepUiBaseCtrl::Clear

// Clear the whole control area

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

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

//

EXPORT_C void CFepUiBaseCtrl::Clear()

    {

    if(iShadowRect.Size().iWidth > iRect.Size().iWidth ||

            iShadowRect.Size().iHeight > iRect.Size().iHeight)

        ClearRect(iShadowRect);

    else               

        ClearRect(iRect);

    }

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

// CFepUiBaseCtrl::DrawBackgroundToDevice

// Draw background to a device

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

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

//    

void CFepUiBaseCtrl::DrawBackgroundToDevice(const TRect aRect,CFbsDevice *aDevice, 

                                            CFbsBitmap* aBmp, const TRgb& aBrushCol,

                                            const TRgb& aPenCol,TBool aBmpStretchFlag)

	{

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

	gc->Activate( aDevice);

	if(aBmp)

		{

		DrawBitmap(aRect,aBmp,aBmpStretchFlag);

		}

	else

		{

        gc->SetBrushStyle( CGraphicsContext::ESolidBrush );

        gc->SetBrushColor( aBrushCol);

        gc->SetPenSize(iBorderSize);

        gc->SetPenColor( aPenCol);

        gc->SetPenStyle(CGraphicsContext::ESolidPen);

        gc->DrawRect(aRect);

	    }

	}

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

// CFepUiBaseCtrl::DrawBackground

// Draw background

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

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

//    

EXPORT_C void CFepUiBaseCtrl::DrawBackground(TBool aBmpStretchFlag)

	{

	DrawBackgroundToDevice(iRect,BitmapDevice(), iBackgroundBmp, iBackgroundCol,

	                       iBorderColor, aBmpStretchFlag);

	}

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

// CFepUiBaseCtrl::DrawBackground

// Draw background

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

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

//    

EXPORT_C void CFepUiBaseCtrl::DrawBackground(const TRect aRect, TBool /*aBmpStretchFlag*/)

	{

	if( !AbleToDraw() )

	    {

	    return;

	    }

	TRect rtDraw = Rect();

	rtDraw.Intersection( aRect );

	if( rtDraw.IsEmpty() )

	    {

	    return;

	    }

	//draw mask    

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

	gc->Activate( MaskBitmapDevice() );

	gc->SetClippingRect( rtDraw );

    gc->SetBrushStyle( CGraphicsContext::ESolidBrush );

    gc->SetBrushColor( iMaskBkCol);

    gc->SetPenSize(iBorderSize);

    gc->SetPenColor( iMaskBkCol);

    gc->SetPenStyle(CGraphicsContext::ESolidPen);

    gc->DrawRect(rtDraw);

    //draw foreground

    gc->Activate( BitmapDevice() );

    gc->SetClippingRect( rtDraw );

    if(!BackgroundBmp())

        {

        gc->SetBrushColor( iBackgroundCol );

        gc->SetPenColor( iPenColor );

        gc->SetPenSize(iBorderSize);

        gc->SetPenStyle(CGraphicsContext::ESolidPen);

        gc->DrawRect( Rect() );

        }

    else

        {

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

        if(BkMaskBmp())

            {

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

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

            }

        else        

            {

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

            }

        }    

	}

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

// CFepUiBaseCtrl::DrawMaskBackground

// Draw mask background

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

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

//    	

EXPORT_C void CFepUiBaseCtrl::DrawMaskBackground(TBool aBmpStretchFlag)

	{

	                       iBorderColor,aBmpStretchFlag);

	}

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

// CFepUiBaseCtrl::DrawOpaqueMaskBackground

// Draw opaque mask background

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

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

//    		

EXPORT_C void CFepUiBaseCtrl::DrawOpaqueMaskBackground(TBool aBmpStretchFlag)

	{

	const TRgb KOpaqueMask = TRgb(KOpaqueColor);

	                       KOpaqueMask,aBmpStretchFlag);

	}

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

// CFepUiBaseCtrl::DrawOpaqueMaskBackground

// Draw opaque mask background

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

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

//    		

EXPORT_C void CFepUiBaseCtrl::DrawOpaqueMaskBackground(const TRect aRect, TBool aBmpStretchFlag)

	{

	const TRgb KOpaqueMask = TRgb(KOpaqueColor);

	                       KOpaqueMask, KOpaqueMask, aBmpStretchFlag);

	}

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

// CFepUiBaseCtrl::DrawTransparentMaskBackground

// Draw transparent mask background

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

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

//    		

EXPORT_C void CFepUiBaseCtrl::DrawTransparentMaskBackground(const TRect& aRect,

                                                            TBool aBmpStretchFlag)

	{

	const TRgb KOpaqueMask = TRgb(KTransparentColor);

	                       KTransparentColor, aBmpStretchFlag);

	}

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

// CFepUiBaseCtrl::ClearRect

// Clear a rect in control

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

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

//   

EXPORT_C void CFepUiBaseCtrl::ClearRect(const TRect& aRect)    

    {

    if(!AbleToDraw())

        return;

    TRect r = iRect;

    r.BoundingRect(iShadowRect);

    r.Intersection(aRect);

    //only clears the rect belongs to this control

    if(!r.IsEmpty())

        {            

        DrawBackgroundToDevice(r,BitmapDevice(),NULL,KRgbWhite,KRgbWhite,EFalse);

        DrawTransparentMaskBackground(r);        

        return;

        }    

    }

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

// CFepUiBaseCtrl::BringToTop

// Show the control and brings to top most in current control group

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

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

//    

EXPORT_C void CFepUiBaseCtrl::BringToTop()

    {

    CControlGroup* grp = RootControl(); 

    if(ParentCtrl()) 

        grp = static_cast<CControlGroup*>(ParentCtrl());

    grp->BringToTopInGroup(this);        

    }

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

// CFepUiBaseCtrl::BringToBack

// Bring the control to the back

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

//    

EXPORT_C void CFepUiBaseCtrl::BringToBack()

    {

    CControlGroup* grp = RootControl(); 

    if(ParentCtrl())

        grp = static_cast<CControlGroup*>(ParentCtrl());

    grp->BringToBackInGroup(this);        

    }

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

// CFepUiBaseCtrl::Hide

// Hide the control

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

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

//    

EXPORT_C void CFepUiBaseCtrl::Hide(TBool aFlag)

    {

    if(iHiden == aFlag)

        return;

    iHiden = aFlag;

    if(!iReady)

        return;

    if(iHiden)

        {            

        TBool needClear;

        if(!iParentCtrl)

            {

            needClear = ETrue;

            }

        else 

            {

            //no need to clear again if group is alreay hiden. There won't be the case

            // that a group is hiden but sub control is shown.            

            needClear = iParentCtrl->Hiden() ? EFalse : ETrue; 

            }

        if(needClear)

            { 

            /*Hide a control should remove its old image, however in fact, the clear sounds reduntant, as each  

              control inside one group, and the background will be redrawn when ReDrawRect() is called, so in  

              order to ensure performance, comments it now*/

            /*iHiden = EFalse;           

            Clear();

            iHiden = ETrue;

            */

            //must redraw the cleared rect as it may clear overlapped control also.

            iUiLayout->RootControl()->ReDrawRect(Rect());            

            UpdateArea(iRect, EFalse); 

            }

        }

    else

        {

        if(!iParentCtrl || !iParentCtrl->Hiden())        

            {            

            Draw();

            UpdateArea(iRect,EFalse);          

            }

        }

    //rect in layout might be changed, update it.

    //RootControl()->UpdateValidRegion(this,aFlag);

    if(iParentCtrl)

        iParentCtrl->UpdateValidRegion(this,aFlag);

    //report size chage event

    ReportEvent(EEventSizeChanged);    

#ifdef RD_TACTILE_FEEDBACK   

    if(IsKindOfControl(ECtrlTactileFeedback))

        {        

        if(aFlag)

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

        else if (iReady)

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

        }

#endif    

    }

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

// CFepUiBaseCtrl::SetBackgroundBitmapL

// Set back ground bitmap

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

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

//       

EXPORT_C void CFepUiBaseCtrl::SetBackgroundBitmapL(CFbsBitmap* aBmp)

    {

    if(!aBmp)

        return;

/*    

    if(IsKindOfControl(ECtrlButton))

        {

        //special handling to button as button does not use iBackgroundBmp directly.        

        return;

        }

        */

    delete iBackgroundBmp;

    iBackgroundBmp = aBmp;             

    }

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

// CFepUiBaseCtrl::SetBackgroundMaskBitmapL

// Set back ground mask bitmap

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

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

//           

EXPORT_C void CFepUiBaseCtrl::SetBackgroundMaskBitmapL(CFbsBitmap* aBmp)

    {

    if(!aBmp)

        return;    

/*    

    if(IsKindOfControl(ECtrlButton))

        {

        //special handling to button as button does not use iBackgroundBmp directly.

        return;

        }*/