/*

* 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 CFepUiLayoutRootCtrl

*

*/

#include "peninputlayoutrootctrl.h"

#include "peninputlayouthwrwnd.h"

#include "peninputlayoutbutton.h"

#include "peninputlayouteditareabase.h"

#include "peninputlayout.h"

#include "peninputlayoutcursor.h"

#include <peninputcmd.h>

#include <AknsConstants.h>

#include <AknsUtils.h>

const TInt KRootControlId = -1;

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

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

// CFepUiLayoutRootCtrl::NewL

// class factory function

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

//

CFepUiLayoutRootCtrl* CFepUiLayoutRootCtrl::NewL(CFepUiLayout* aUiLayout)

    {

    CFepUiLayoutRootCtrl* ctrl = new(ELeave) CFepUiLayoutRootCtrl(aUiLayout);

    CleanupStack::PushL(ctrl);

    ctrl->ConstructL();

    CleanupStack::Pop(ctrl);

    return ctrl;

    }

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

// CFepUiLayoutRootCtrl::ConstructL

// 2nd phase constructor

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

//

void CFepUiLayoutRootCtrl::ConstructL()

    {

    BaseConstructL(this);

    //set it not ready to avoid unnessary drawing. Ready is set afer InitControl

    SetReady(EFalse);

    }    

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

// CFepUiLayoutRootCtrl::~CFepUiLayoutRootCtrl

// Destructor

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

//

CFepUiLayoutRootCtrl::~CFepUiLayoutRootCtrl()

    {    

    //CFepUiBaseCtrl* ctrl;

    //free all control. iCtrlList keeps all controls for root control.

    /*for(TInt i = iCtrlList.Count()-1; i >= 0;i--)

        {

        ctrl = iCtrlList[i];

        delete ctrl;

        }

    iCtrlList.Reset();*/

    //No need to close others, CControlGroup will do that.    

    iCtrlRegionAwareList.Close();

    iCtrlOverlappingAwareList.Close();

    //iNonHwrStartPtRegion.Close();        

    delete iWindowGc;

    delete iCursor;

    }        

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

// CFepUiLayoutRootCtrl::CFepUiLayoutRootCtrl

// Constructor

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

//

CFepUiLayoutRootCtrl::CFepUiLayoutRootCtrl(CFepUiLayout* aUiLayout):

                            CControlGroup(aUiLayout,KRootControlId)

    {    

    SetControlType(ECtrlWndBasedCtrl|ControlType());

    SetMaskBkCol(KTransparentColor);

    }    

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

// CFepUiLayoutRootCtrl::HandleEventL

// handle event from window server

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

//

TBool CFepUiLayoutRootCtrl::HandleEventL(TEventType aType, const TAny* aData)

    {   

    CFepUiBaseCtrl* ctrl = NULL;    

    switch(aType)

        {

        case ERawEvent:

            {

            TRawEvent event=*((TRawEvent*)aData);

            switch(event.Type())                

                {

                case TRawEvent::EPointerMove:

                    {                        

                    TPoint point = event.Pos() - UiLayout()->Position (); 

                    //if captured

                    if(iPointerCaptureCtrl)

                        {                            

                        ctrl = iPointerCaptureCtrl->HandlePointerMoveEventL(point);

                        break;

                        }

                    //won't handle move event if no pointer down happens

                    if(!iCtrlWithPointerDown)

                        return EFalse;

                    ctrl = HandlePointerMoveEventL(point);

                    }

                    break;

                case TRawEvent::EButton1Down:

                    {                        

                    TPoint point1 = event.Pos() - UiLayout()->Position ();

                    //if captured

                    if(iPointerCaptureCtrl)

                        {                            

                        ctrl = iPointerCaptureCtrl->HandlePointerDownEventL(point1);

                        break;

                        }

                    ctrl = HandlePointerDownEventL(point1);

                    }

                    break;     

                case TRawEvent::EButton1Up:

                    {

                    TPoint point = event.Pos() - UiLayout()->Position ();

                    if(iPointerCaptureCtrl)

                        {                            

                        ctrl = iPointerCaptureCtrl->HandlePointerUpEventL(point);

                        }

                    else                        

                    ctrl = HandlePointerUpEventL(point);

                    iCtrlWithPointerDown = NULL;

                    }

                    break;

                default:

                    break;                    

                }                

            }        

            break;

        case EPointerEvent:

            {

            TPointerEvent pt= *((TPointerEvent*)aData);

            TPoint point = pt.iPosition;

            //same as raw event

            if(TPointerEvent::EButton1Down == pt.iType)

                {                

                if(iPointerCaptureCtrl)

                    {                            

                    ctrl = iPointerCaptureCtrl->HandlePointerDownEventL(point);

                    break;

                    }

                ctrl = HandlePointerDownEventL(point);                

                }

            else

                {                

                if(TPointerEvent::EButton1Up == pt.iType)

                    {

                    if(iPointerCaptureCtrl)

                        {                            

                        ctrl = iPointerCaptureCtrl->HandlePointerUpEventL(point);

                        iCtrlWithPointerDown = NULL;

                        break;

                        }                        

                    ctrl = HandlePointerUpEventL(point);                    

                    }

                else

                    {

                    if(TPointerEvent::EDrag == pt.iType ||

                            TPointerEvent::EMove == pt.iType)

                        {                        

                        //if captured

                        if(iPointerCaptureCtrl)

                            {                            

                            ctrl = iPointerCaptureCtrl->HandlePointerMoveEventL(point);

                            break;

                            }

                        //won't handle move event if no pointer down happens

                        if(!iCtrlWithPointerDown)

                            return NULL;

                        ctrl = HandlePointerMoveEventL(point);

                        }

                    }                    

                }                         

            }

            break;

        default:

            break;

        }         

    if(iPointerDownCanceled)

        {    

        iCtrlWithPointerDown = NULL;

        iPointerLeft = EFalse;

        }    

    return ctrl ? ETrue : EFalse;

    }

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

// CFepUiLayoutRootCtrl::SetPointerDownCtrl

// Set pointer down control. 

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

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

//        

void CFepUiLayoutRootCtrl::SetPointerDownCtrlL(CFepUiBaseCtrl* aCtrl)

    {    

    //set pointer down canceling flag

    iPointerDownCanceled = EFalse;

    if(!aCtrl) // Pointer down and up in different control

        {        

        if(iCtrlWithPointerDown) 

            {

            //cancel the pointer down event for the control which has pen down operation

            iCtrlWithPointerDown->CancelPointerDownL();

            iPointerDownCanceled = ETrue;            

            }        

        }

    else

        iCtrlWithPointerDown = aCtrl;

    }

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

// CFepUiLayoutRootCtrl::RequireRegionUpdateL

// Register the control to be region change awared

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

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

//           

EXPORT_C void CFepUiLayoutRootCtrl::RequireRegionUpdateL(CFepUiBaseCtrl* aCtrl,

                                             TBool aRequiredFlag)

    {

    TInt ctrlIdx = iCtrlRegionAwareList.Find(aCtrl);

    if(aRequiredFlag)

        {

        if(KErrNotFound != ctrlIdx)

            return; 	  //already there

        /*for(i =0; i < iCtrlRegionAwareList.Count(); i++)

            {

            if(aCtrl == iCtrlRegionAwareList[i])

                return;

            }*/

        iCtrlRegionAwareList.AppendL(aCtrl);

        if(aCtrl->Ready())

            {

            //calculate the region for the first time

            aCtrl->UpdateValidRegion(NULL,EFalse); 

            }

        //otherwise do this during layout initialization

        }        

    else

        {

        if(KErrNotFound == ctrlIdx)

            return; 

        iCtrlRegionAwareList.Remove(ctrlIdx);

        /*

        for(i =0; i < iCtrlRegionAwareList.Count(); i++)

            {

            if(aCtrl == iCtrlRegionAwareList[i])

                {

                iCtrlRegionAwareList.Remove(i);

                //TRect rect = aCtrl->Rect();

                //aCtrl->SetRect(rect); //restore the region

                }                

            }*/

        }

    }    

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

// CFepUiLayoutRootCtrl::DrawRect

// Draw layout content within a rect

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

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

//

void CFepUiLayoutRootCtrl::DrawRect(const TRect& aRect,TBool aDrawFrameFlag)

    {

    const TSize KFramePenSize(2,2);

    if(aDrawFrameFlag) //only draw frame

        {        

        DrawOpaqueMaskBackground();

        DrawBackground();

        }

    else

        {

        CControlGroup::ReDrawRect(aRect);

        }

    }

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

// CFepUiLayoutRootCtrl::RemoveControl

// Remove a control to layout

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

//

void CFepUiLayoutRootCtrl::RemoveControl(CFepUiBaseCtrl* aControl)

    {

    if(!aControl)

        return;

    /*

    TBool bFound = EFalse;

    if(aControl == iActiveCtrl)

        iActiveCtrl = NULL;

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

        {

        if(iCtrlList[i] == aControl)

            {

            bFound = ETrue;

            iCtrlList.Remove(i);            

            DoRegionUpdateForCtrls();                

            delete aControl;

            }

        }

    if(!bFound) //not found, the control must member of one control group

        {

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

            {

            if(iCtrlList[i]->IsKindOfControl(ECtrlControlGroup))

                {                

                static_cast<CControlGroup*>(iCtrlList[i])->

                                                RemoveControl(aControl);

                }        

            }

        }*/

    aControl->RemoveEventObserver(UiLayout());

    CControlGroup::RemoveControl(aControl);

    //DoRegionUpdateForCtrls();

        }

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

// CFepUiLayoutRootCtrl::RemoveControl

// Remove a control to layout

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

//

void CFepUiLayoutRootCtrl::RemoveControl(CCoeControl* aControl)

    {

    CFepUiBaseCtrl* foundedCtrl = Find(aControl);    

    RemoveControl(foundedCtrl);    

    }

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

// CFepUiLayoutRootCtrl::SetRect

// Set layout rect

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

//

void CFepUiLayoutRootCtrl::SetRect(const TRect& aRect)

    {

    iRect = aRect;

    DoRegionUpdateForCtrls();

/*    for(TInt i =0; i < iCtrlRegionAwareList.Count(); i++)

        {

        //re-calculate the valid region

        iCtrlRegionAwareList[i]->UpdateValidRegion(NULL,EFalse);

        }    */

    }

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

// CFepUiLayoutRootCtrl::UpdateValidRegion

// Update control's valid region after one control Hiden or shown.

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

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

//       

void CFepUiLayoutRootCtrl::UpdateValidRegion(CFepUiBaseCtrl* aCtrl,

                                                             TBool aRemoveFlag)

    {

    //CControlGroup::UpdateValidRegion(aCtrl,aRemoveFlag);

    //if(!aCtrl)

    if(Ready())

        {

        //ask all region aware control to update the region

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

            {

            //re-calculate the valid region

            iCtrlRegionAwareList[i]->UpdateValidRegion(NULL,EFalse);

            }            

        }

     //only check shadow rect when aCtrl is not NULL

    if(aCtrl)

        {

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

            {            

            iCtrlOverlappingAwareList[i]->UpdateValidRegion(aCtrl,aRemoveFlag);

            }

        //pop up window will be handled dynamically

        if(!aCtrl->IsKindOfControl(ECtrlPopupWindow) && 

                                        !aCtrl->ShadowRect().IsEmpty())

            {

            TSize s(iShadowRect.Size());

            if(aCtrl->ShadowRect().Width() > s.iWidth)

                s.iWidth = aCtrl->ShadowRect().Width();

            if(aCtrl->ShadowRect().Height() > s.iHeight)

                s.iHeight = aCtrl->ShadowRect().Height();

            if(s != iShadowRect.Size())

                {

                UiLayout()->LayoutOwner()->LayoutSizeChanged(s);

                }                    

            }

        //update iNonHwrStartPtRegion for full screen hwr  

        if(!aCtrl->IsKindOfControl(ECtrlTransparentHwrWnd))

            {            

            CalculateNonHwrStartPtArea();  

            }

        } 

    else

        {

        CalculateNonHwrStartPtArea();        

        }

    CalculateClipRegion();

    }

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

// CFepUiLayoutRootCtrl::InitControl

// Initialize the layout

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

//

TRect CFepUiLayoutRootCtrl::InitControl()

    {

    TInt i=0;

    TInt count = iCtrlList.Count();

    CFepUiBaseCtrl* ctrl;

    //check whether there is pop up window, move it to last

    //if pop up window is encapsulated by some control group, it can't be found here.

    for(i = 0; i < count; i++)

        {        

        if(iCtrlList[i]->IsKindOfControl(ECtrlPopupWindow))

            {

            ctrl = iCtrlList[i];

            iCtrlList.Remove(i);

            iCtrlList.Append(ctrl);

            i--;

            count--;//The last one is pop wnd, no need to check.            

            }

        }

    //check and calc the shadow rect

    TBool bHasShadow = EFalse;

    if(iShadowRect.IsEmpty())

        {

        for(i = 0; i < iCtrlList.Count(); i++)

            {

            //pop up window doesn't affect our layout rect, ignore it.

            if(!iCtrlList[i]->IsKindOfControl(ECtrlPopupWindow))

                {                

                iShadowRect = iCtrlList[i]->ShadowRect();            

                bHasShadow = ETrue;

                break;

                }

            }

        }

    bHasShadow = !iShadowRect.IsEmpty();

    TSize s(iRect.Size());

    if(bHasShadow)

        {

        for(i = 0; i < iCtrlList.Count(); i++)

            {

            if(!iCtrlList[i]->IsKindOfControl(ECtrlPopupWindow) &&

                !iCtrlList[i]->ShadowRect().IsEmpty())

                {

                iShadowRect.BoundingRect(iCtrlList[i]->ShadowRect());

                }

            }

        if(iRect.Width() < iShadowRect.Width())

            s.iWidth = iShadowRect.Width();

        if(iRect.Height() < iShadowRect.Height())

            s.iHeight = iShadowRect.Height();  

        iRect.SetRect(TPoint(0,0),s);

        iLayoutPos = iShadowRect.iTl;

        //move iShadowAreaRect if needed

        //iShadowRect need be kept as SetShadowAreaRect will change iShadowRect

        if(ShadowAreaRect(KShadowBmpTl).iTl != TPoint(0,0))

            {

            TPoint offset = -ShadowAreaRect(KShadowBmpTl).iTl;

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

                {

                iShadowAreaRect[i].Move(offset);

                }