/*

* Copyright (c) 2005-2006 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 control group

*

*/

#include "peninputlayoutbutton.h"

#include "peninputlayoutctrlgroup.h"

#include "peninputlayoutrootctrl.h"

#include "peninputlayout.h"

#include "coecntrl.h"

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

/******************************************************************************/

// Implementation to Class CControlGroup

//

/******************************************************************************/

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

// CControlGroup::NewL

// Factory function

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

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

//    

EXPORT_C CControlGroup* CControlGroup::NewL(CFepUiLayout* aUiLayout,

										    TInt aControlId,

										    TBool aRedrawBg /*= ETrue*/)

    {

    CControlGroup* ctrlGroup=new (ELeave)CControlGroup(aUiLayout,aControlId, aRedrawBg);   

    CleanupStack::PushL(ctrlGroup);

    ctrlGroup->ConstructL();

    CleanupStack::Pop(ctrlGroup);

    return ctrlGroup;

    }

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

// CControlGroup::NewL

// Factory function

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

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

//    

CControlGroup* CControlGroup::NewL(CFepUiLayout* aUiLayout,CCoeControl* aControl)

    {

    if(!aControl)

        return NULL;

    CControlGroup* ctrlGroup=new (ELeave)CControlGroup(aUiLayout,

                                                      aControl->UniqueHandle());

    ctrlGroup->iWndControl = aControl;

    CleanupStack::PushL(ctrlGroup);

    ctrlGroup->ConstructL();

    ctrlGroup->SetRect(aControl->Rect());    

    CleanupStack::Pop(ctrlGroup);

    return ctrlGroup;

    }

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

// CControlGroup::CControlGroup

// C++ default constructor

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

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

//        

EXPORT_C CControlGroup::CControlGroup(CFepUiLayout* aUiLayout,TInt aCtrlId)

                :CFepUiBaseCtrl(TRect(0,0,0,0),aUiLayout,aCtrlId)

    {

    iNeedRedrawBg = (TInt)ETrue;

    SetControlType(ECtrlControlGroup);

    }

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

// CControlGroup::CControlGroup

// C++ default constructor

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

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

//        

EXPORT_C CControlGroup::CControlGroup(CFepUiLayout* aUiLayout,

									  TInt aCtrlId,

									  TBool aRedrawBg)

                :CFepUiBaseCtrl(TRect(0,0,0,0),aUiLayout,aCtrlId)

    {

    iNeedRedrawBg = aRedrawBg;

    SetControlType(ECtrlControlGroup);

    }

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

// CControlGroup::ConstructL

// Second phrase constructor

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

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

//            

EXPORT_C void CControlGroup::ConstructL()

    {

    //do CFepUiBaseCtrl's base construction

    BaseConstructL();

    }

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

// CControlGroup::~CControlGroup

// Destructor

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

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

//            

EXPORT_C CControlGroup::~CControlGroup()

    {

    CFepUiBaseCtrl* ctrl;

    for(TInt i = iOwnedCtrlList.Count()-1;i >= 0;i--)

        {

        ctrl = iOwnedCtrlList[i];

        delete ctrl;

        }

    iOwnedCtrlList.Close();

    iCtrlList.Close();

    iPopCtrlList.Close();

    iNonHwrStartPtRegion.Close();    

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

        {

         delete iSubRegionArea[i];

        }*/

    iSubRegionArea.ResetAndDestroy();    

    iSubRegionArea.Close();

    iSubCtrlShowStateBeforeHiden.Close();

    }

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

// CControlGroup::AddControlL

// Add control to group

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

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

//        

EXPORT_C void CControlGroup::AddControlL(CFepUiBaseCtrl* aControl, TBool aOwnerFlag)

    {

    //do nothing if we already has the control.

    if(!aControl || KErrNotFound != iCtrlList.Find(aControl))

        return;

    CalculateClipRegion(aControl);

    if(aOwnerFlag)

        iOwnedCtrlList.AppendL(aControl);

    iCtrlList.AppendL(aControl);   

    aControl->SetParent(this);

    if(!aControl->Hiden() && !aControl->IsKindOfControl(ECtrlPopupWindow))

        {        

        //TRect rect = Rect();

        if(iCtrlList.Count() > 1)

            {

            iRect.BoundingRect(aControl->Rect());       

            }

        else

            iRect = aControl->Rect();

        //iRect = rect;

        /*RRegion region(8);

        region.Copy(Region());   

        region.AddRect(aControl->Rect());

        SetRegion(region);*/

        UpdateValidRegion(aControl,EFalse);

        }

    //since control may be added dynamically, we need draw it

//        aControl->Draw();

//        aControl->UpdateArea(aControl->Rect(),ETrue);

    TSubCtrlShownState state = {aControl,aControl->Hiden()};    

    iSubCtrlShowStateBeforeHiden.AppendL(state);

    }

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

// CControlGroup::Find

// Find the control in a control group

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

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

//        

CFepUiBaseCtrl* CControlGroup::Find(CCoeControl* aCtrl)

    {

    if(!IsKindOfControl(ECtrlWndBasedCtrl))

        return NULL;

    if(aCtrl == iWndControl)

        return this;

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

        {

        CFepUiBaseCtrl* ctrl = iCtrlList[i];

        if(!ctrl->IsKindOfControl(ECtrlControlGroup))

            {

            if(aCtrl == ctrl->WndBasedControl())

                return ctrl;

            }

        else

            {

            /*

            bFound = static_cast<CControlGroup*>(ctrl)->Find(aCtrl);

            if(bFound)

                return bFound;

                */

            CControlGroup* ctrlGroup = static_cast<CControlGroup*>(ctrl);

            CFepUiBaseCtrl* foundedCtrl = ctrlGroup->Find(aCtrl);

            if(foundedCtrl)

                return foundedCtrl;

            }

        }

    return NULL;    

    }

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

// CControlGroup::AddControlL

// Add control to group

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

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

//        

EXPORT_C CFepUiBaseCtrl* CControlGroup::AddControlL(CCoeControl* aControl)

    {

    //do nothing if we already has the control.

    if(!IsKindOfControl(ECtrlWndBasedCtrl) || !aControl)

        return NULL;

    CFepUiBaseCtrl* ctrl = Find(aControl);

    if(ctrl)

        return ctrl;   

    //if it's a compound control, we need find out its sub-control one by one

    if(aControl->CountComponentControls())

        {

        //create a control group

        CControlGroup* group = CControlGroup::NewL(UiLayout(),aControl);

        ctrl = group;

        CleanupStack::PushL(ctrl);

        for(TInt i = 0; i < aControl->CountComponentControls(); i++)

            {

            group->AddControlL(aControl->ComponentControl(i));

            }        

        group->SetControlType(ECtrlWndBasedCtrl|ECtrlControlGroup);                

        }

    else

        {

        ctrl = new(ELeave) CFepUiBaseCtrl(aControl,UiLayout());

        ctrl->SetControlType(ECtrlWndBasedCtrl|ECtrlBaseCtrl);

        CleanupStack::PushL(ctrl);

        ctrl->BaseConstructL();

        }   

    AddControlL(ctrl,ETrue);

    CleanupStack::Pop(ctrl);            

    UpdateValidRegion(ctrl,EFalse);    

    return ctrl;

    }

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

// CControlGroup::RemoveOwnedControl

// Remove a control from group's owned control list

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

//

TBool CControlGroup::RemoveOwnedControl(CFepUiBaseCtrl* aControl)

    {

    TInt index = iOwnedCtrlList.Find(aControl);

    if(KErrNotFound != index)

        {

        iOwnedCtrlList.Remove(index);

        delete aControl;

        }

    return KErrNotFound != index;

    }

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

// CControlGroup::RemoveControl

// Remove a control from group

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

//

EXPORT_C TBool CControlGroup::RemoveControl(CFepUiBaseCtrl* aControl)

    {

    TInt i;

    TBool bFound = EFalse;

    //CControlGroup* parent = this;

    if(!aControl || iCtrlList.Count() <= 0)

        return EFalse;

    if(aControl == iActiveCtrl)

        iActiveCtrl = NULL;

    //iRect = iCtrlList[0]->Rect();    

    //find and remove the control

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

        {

        if(iCtrlList[i] == aControl)

            {

            iCtrlList.Remove(i);            

            RemoveOwnedControl(aControl);

            bFound = ETrue;            

            }

        }

        {

        //change iRect

        if(iCtrlList.Count())

            {

            iRect = iCtrlList[0]->Rect();

            }

        else

            iRect = TRect(0,0,0,0);

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

            {            

            iRect.BoundingRect(iCtrlList[i]->Rect());            

            }

        }

    else

        return EFalse;

    RemoveCtrlFromSubCtrlInfoList(aControl);

    UpdateValidRegion(aControl,ETrue);

    CalculateClipRegion();

    return bFound;

    }

void CControlGroup::CalculateClipRegion(CFepUiBaseCtrl* aControl)

    {

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

        {

        if(!aControl->Hiden())

            iCtrlList[i]->iClipRegion.SubRect(aControl->Rect());        

        }

    }

void CControlGroup::CalculateClipRegion()

    {

    //restore each control's rect first.

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

        {

        CFepUiBaseCtrl* ctrl = iCtrlList[i];

        if(ctrl->IsKindOfControl(ECtrlControlGroup))

            static_cast<CControlGroup*>(ctrl)->CalculateClipRegion();

        ctrl->iClipRegion.Clear();

        ctrl->iClipRegion.AddRect(ctrl->Rect());

        }

    //re calulate clip region

    for(TInt curCtrlIdx = iCtrlList.Count() - 1 ; curCtrlIdx >= 0 ; --curCtrlIdx)

        {

        CFepUiBaseCtrl* curCtrl = iCtrlList[curCtrlIdx];

        for(TInt upperCtrlIdx = curCtrlIdx + 1 ;  upperCtrlIdx < iCtrlList.Count(); ++upperCtrlIdx)

            {

            if(!iCtrlList[upperCtrlIdx]->Hiden())

                curCtrl->iClipRegion.SubRect(iCtrlList[upperCtrlIdx]->Rect());

            }

        }

    }

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

// CControlGroup::At

// Return control in given position

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

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

//

EXPORT_C CFepUiBaseCtrl* CControlGroup::At(TInt aIndex)

    {

    if(aIndex >=0 && aIndex < iCtrlList.Count())

        return iCtrlList[aIndex];

    else

        return NULL;

    }

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

// CControlGroup::ControlForPoints()

// Find the control which contains the point

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

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

//    

CFepUiBaseCtrl* CControlGroup::ControlForPoints(const TPoint& aPt)

    {

    CFepUiBaseCtrl* ctrl = NULL;

    if(iActiveCtrl && !iActiveCtrl->Hiden() && iActiveCtrl->Contains(aPt))

        {

        return iActiveCtrl;        

        }

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

        {

        ctrl = iCtrlList[i];

        if(!ctrl->Hiden() && ctrl->Contains(aPt))

            {

            return ctrl;

            }

        }

    return NULL;

    }

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

// CControlGroup::HandlePointerUpEventL()

// Handle pointer up event

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

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

//    

EXPORT_C CFepUiBaseCtrl* CControlGroup::HandlePointerUpEventL(const TPoint& aPt)

    {

    if(iWndControl)

        {

        return CFepUiBaseCtrl::HandlePointerUpEventL(aPt);

        }

    CFepUiBaseCtrl* ctrl = ControlForPoints(aPt);

    if(!ctrl && !iRect.Contains(aPt)) // not belong our group

        return NULL;

    if(!PointerDown())

        {    

        return this;

        }

    SetPointerDown(EFalse);    

    if(ctrl != iCtrlWithPointerDown)

        {

        if(iCtrlWithPointerDown)

            iCtrlWithPointerDown->CancelPointerDownL();

        }

    else

        {        

        if(ctrl)

            {          // modify by vv for temp  

            if(ctrl->HandlePointerUpEventL(aPt))

                {

                if( !ctrl->Hiden() && ctrl->Ready() )

                    {

                    SetActiveCtrl(ctrl);

                    }

                }

            ctrl->SetPointerDown(EFalse);

            }

        }

    iCtrlWithPointerDown = NULL;

    return this;

    }

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

// CControlGroup::HandlePointerDownEventL()

// Handle pointer down event

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

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

//    

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

    {

    if(iWndControl)

        {

        return CFepUiBaseCtrl::HandlePointerDownEventL(aPt);

        }

    CFepUiBaseCtrl* ctrl = ControlForPoints(aPt);

    iCtrlWithPointerDown = ctrl;

    if(ctrl)

        {

        SetPointerDown(ETrue);

        iPointerLeft = EFalse;

        iTempActiveCtrl = iActiveCtrl;

        SetTempActiveCtrl(ctrl);

        ctrl->HandlePointerDownEventL(aPt);

        return this;

        }

    return NULL;

    }

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

// CControlGroup::HandlePointerMoveEvent()

// Handle pointer move event

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

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

//    

EXPORT_C CFepUiBaseCtrl* CControlGroup::HandlePointerMoveEventL(const TPoint& aPt)

    {

    if(iWndControl)

        {

        return CFepUiBaseCtrl::HandlePointerMoveEventL(aPt);

        }

    CFepUiBaseCtrl* ctrl = ControlForPoints(aPt);

    if(!ctrl && !iRect.Contains(aPt)) // not belong our group

        return NULL; // Check: This will not happen!

    if(!iCtrlWithPointerDown) // does not's process move event if no pointer down

        return this;

    if(ctrl != iCtrlWithPointerDown) 

    //pointer just move out the control for the first time

        {

        //Inform the control that pointer is out for first time

        if(!iPointerLeft)

            {

            iPointerLeft = ETrue;            

            iCtrlWithPointerDown->HandlePointerLeave(aPt);

            }

        }

    else

        {

        //Inform the control that pointer is in

        if(iPointerLeft)

            {                                    

            iCtrlWithPointerDown->HandlePointerEnter(aPt);

            iPointerLeft = EFalse; //reset the flag

            }

        }

    if(ctrl)

        ctrl->HandlePointerMoveEventL(aPt);