--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/textinput/peninputarc/src/peninputlayoutcontrol/peninputlayoutcontrolgroup.cpp Tue Feb 02 01:02:04 2010 +0200
@@ -0,0 +1,1553 @@
+/*
+* 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;
+ }
+ }
+
+ if(bFound && !aControl->Hiden())
+ {
+ //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);
+ else
+ return NULL;
+ return this;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CControlGroup::Draw
+// Draw the control
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::Draw()
+ {
+ if(!AbleToDraw() || WholeHiden())
+ return;
+
+ if(iWndControl)
+ {
+ CFepUiBaseCtrl::Draw();
+ return;
+ }
+ //Clear();
+
+ for(TInt i=0; i<iCtrlList.Count();i++)
+ {
+ CFepUiBaseCtrl* ctrl = iCtrlList[i];
+ //not draw hiden control and pop up window. Active control is drawn later
+ if(!ctrl->Hiden() && !ctrl->IsKindOfControl(ECtrlPopupWindow)
+ && ctrl != iActiveCtrl)
+ ctrl->Draw();
+ }
+ //draw active controls
+ if(iActiveCtrl)
+ iActiveCtrl->Draw();
+
+ //draw pop control
+ for(TInt i=0; i<iPopCtrlList.Count();i++)
+ {
+ CFepUiBaseCtrl* ctrl = iPopCtrlList[i];
+ if(!ctrl->Hiden())
+ ctrl->Draw();
+ }
+ }
+
+void DoRedrawInCtrlList(const TRect& aRect, CFepUiBaseCtrl* aCtrl,
+ RPointerArray<CFepUiBaseCtrl>& aList)
+ {
+ for(TInt i = 0 ; i < aList.Count(); ++i)
+ {
+ if(aList[i] == aCtrl)
+ continue;
+ if(!aList[i]->Hiden() &&
+ aList[i]->IsOnTopOf(aCtrl) &&
+ aRect.Intersects(aList[i]->Rect()))
+ {
+ TRect r = aRect;
+ r.Intersection(aList[i]->Rect());
+ aList[i]->ReDrawRect(r);
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CControlGroup::RedrawRectIfNeeded
+// ReDraw the affected control in the rect if needed
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CControlGroup::RedrawRectIfNeeded(const TRect& aRect, CFepUiBaseCtrl* aCtrl)
+ {
+ if( aCtrl->Hiden() )
+ {
+ return;
+ }
+ if(!AbleToDraw() || WholeHiden())
+ return;
+
+ if(aRect.IsEmpty())
+ return;
+
+ //check all sub controls
+ DoRedrawInCtrlList(aRect,aCtrl,iCtrlList);
+ //check pop list
+ //check all sub controls
+ DoRedrawInCtrlList(aRect,aCtrl,iPopCtrlList);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CControlGroup::ReDrawRect
+// ReDraw the control in the rect
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::ReDrawRect(const TRect& aRect)
+ {
+ if(!AbleToDraw() || WholeHiden())
+ return;
+
+ if(aRect.IsEmpty())
+ return;
+ if(aRect == Rect())
+ {
+ Draw();
+ }
+ else
+ {
+ //find out the controls within the rect
+ if( iNeedRedrawBg )
+ DrawBackground( aRect );
+ //DrawControlGroupBackground( aRect );
+ TBool needDrawActiveCtrl = EFalse;
+ for(TInt i=0;i<iCtrlList.Count();i++)
+ {
+ CFepUiBaseCtrl* ctrl=iCtrlList[i];
+ if(!ctrl->Hiden() && aRect.Intersects(ctrl->Rect()))
+ {
+ if(iActiveCtrl == ctrl)
+ {
+ needDrawActiveCtrl = ETrue;
+ continue;
+ }
+ TRect r = aRect;
+ r.Intersection(ctrl->Rect());
+
+ ctrl->ReDrawRect(r);
+ }
+
+ }
+ if(needDrawActiveCtrl)
+ {
+ TRect r = aRect;
+ r.Intersection(iActiveCtrl->Rect());
+
+ iActiveCtrl->ReDrawRect(r);
+ }
+ }
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// CControlGroup::SetTempActiveCtrl
+// Set temparary active control in button down state
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+CFepUiBaseCtrl* CControlGroup::SetTempActiveCtrl(CFepUiBaseCtrl* aCtrl)
+ {
+ if( aCtrl &&
+ aCtrl != iTempActiveCtrl &&
+ !(aCtrl->ControlType() & ECtrlBackgroundCtrl) )
+ {
+ //iPrevActiveCtrl = iActiveCtrl;
+ CFepUiBaseCtrl* previous = iTempActiveCtrl;
+ iTempActiveCtrl = aCtrl;
+ iTempActiveCtrl->SetActive(ETrue);
+ //We need to check whether the control news status is successfully set.
+ if( iTempActiveCtrl->IsActive() )
+ {
+ if(previous)
+ previous->SetActive(EFalse);
+ }
+ else
+ {
+ return previous;
+ }
+ }
+ return iTempActiveCtrl;
+ }
+
+// -----------------------------------------------------------------------------
+// CControlGroup::SetActiveCtrl
+// Set active control
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CFepUiBaseCtrl* CControlGroup::SetActiveCtrl(CFepUiBaseCtrl* aCtrl)
+ {
+ if( aCtrl &&
+ aCtrl != iActiveCtrl &&
+ !(aCtrl->ControlType() & ECtrlBackgroundCtrl) )
+ {
+ CFepUiBaseCtrl* previous = iActiveCtrl;
+ iActiveCtrl = aCtrl;
+ //Change the previous control first, then current control
+ if(previous)
+ previous->SetActive(EFalse);
+
+ iActiveCtrl->SetActive(ETrue);
+ }
+ return iActiveCtrl;
+ }
+
+// -----------------------------------------------------------------------------
+// CControlGroup::SetActiveCtrl
+// Set active control
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CFepUiBaseCtrl* CControlGroup::SetActiveCtrl(TInt aIndex)
+ {
+ if(aIndex < 0 || aIndex >= iCtrlList.Count())
+ return NULL;
+ return SetActiveCtrl(iCtrlList[aIndex]);
+ }
+
+// -----------------------------------------------------------------------------
+// CControlGroup::ActiveControl
+// Get active control
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CFepUiBaseCtrl* CControlGroup::ActiveControl()
+ {
+ return iActiveCtrl;
+ }
+
+// -----------------------------------------------------------------------------
+// CControlGroup::NumOfControlss
+// get control numbers
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CControlGroup::NumOfControls()
+ {
+ return iCtrlList.Count();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CControlGroup::HideControl
+// Hide control
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::HideControl(TInt aIndex,TBool aFlag)
+ {
+ if(aIndex >=0 && aIndex < iCtrlList.Count())
+ {
+ HideControl(iCtrlList[aIndex],aFlag);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CControlGroup::HideControl
+// Hide control
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::HideControl(CFepUiBaseCtrl* aControl,TBool aFlag)
+ {
+ if(!aControl || aControl->Hiden() == aFlag)
+ return;
+
+ aControl->Hide(aFlag);
+
+ //recalculate the control group rect
+ if(aFlag) //hide
+ {
+ iRect.SetRect(0,0,0,0);
+ for(TInt j = 0; j < iCtrlList.Count(); j++)
+ {
+ if(aControl != iCtrlList[j] && ! iCtrlList[j]->Hiden())
+ {
+ if(iRect.IsEmpty())
+ {
+ iRect = iCtrlList[j]->Rect();
+ }
+ else
+ {
+ iRect.BoundingRect(iCtrlList[j]->Rect());
+ }
+ }
+ }
+ }
+ else //show
+ {
+ if(iRect.IsEmpty())
+ {
+ iRect = aControl->Rect();
+ }
+ else
+ {
+ iRect.BoundingRect(aControl->Rect());
+ }
+ }
+
+ UpdateValidRegion(aControl,ETrue);
+
+ /*
+ SetRect(rect);
+ RRegion region(8);
+ region.Copy(Region());
+
+ if(aFlag) //hide control
+ region.SubRect(aControl->Rect());
+ else
+ region.AddRect(aControl->Rect());
+ SetRegion(region);
+ RootControl()->UpdateValidRegion(NULL,EFalse);
+ */
+ }
+
+
+// -----------------------------------------------------------------------------
+// CControlGroup::Hide
+// Hide the control group and all it's controls
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::Hide(TBool aFlag)
+ {
+ if(Hiden() == aFlag)
+ return;
+ /* if(aFlag) //hide
+ {
+ SaveSubCtrlShownState();
+ }*/
+ DisableRegionUpdating(); //disable updating caused by sub controls
+ /*for (TInt i = 0; i < iCtrlList.Count(); ++i)
+ {
+ CFepUiBaseCtrl* ctrl = iCtrlList[i];
+ TBool hideFlag = aFlag;
+ if( i < iSubCtrlShowStateBeforeHiden.Count() &&
+ iSubCtrlShowStateBeforeHiden[i].iSubCtrl == ctrl)
+ {
+ hideFlag = hideFlag || iSubCtrlShowStateBeforeHiden[i].iHiden;
+ }
+ ctrl->Hide(hideFlag); //loop sub controls
+ }*/
+ EnableRegionUpdating();
+ CFepUiBaseCtrl::Hide(aFlag); //hide myself
+ /*if(!aFlag)
+ iSubCtrlShowStateBeforeHiden.Reset();
+*/
+ }
+
+// -----------------------------------------------------------------------------
+// CControlGroup::Move
+// Move control and component's rect
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::Move(const TPoint& aOffset)
+ {
+ //disable region update and re-calculate it after all sub-control moved.
+ DisableRegionUpdating();
+ CFepUiBaseCtrl::Move(aOffset);
+ //move components
+ for(TInt j = 0; j < iCtrlList.Count(); j++)
+ {
+ iCtrlList[j]->Move(aOffset);
+ }
+ EnableRegionUpdating();
+ UpdateValidRegion(NULL,ETrue); //recalculate valid region
+ }
+
+// -----------------------------------------------------------------------------
+// CControlGroup::ControlById
+// Get the sub control for given control Id.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CFepUiBaseCtrl* CControlGroup::ControlById(TInt aCtrlId)
+ {
+ CFepUiBaseCtrl* ctrl = NULL;
+
+ for(TInt i = 0; i < iCtrlList.Count(); i++)
+ {
+ ctrl = iCtrlList[i];
+ if(ctrl->ControlId() == aCtrlId)
+ {
+ return ctrl;
+ }
+ else
+ {
+ if(ctrl->IsKindOfControl(ECtrlControlGroup))
+ {
+ CFepUiBaseCtrl* subCtrl = static_cast<CControlGroup*>(ctrl)->
+ ControlById(aCtrlId);
+ if(subCtrl)
+ return subCtrl;
+ }
+ }
+ }
+
+ return NULL;
+
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::CancelPointerDownL
+// Cancel pointer down event
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::CancelPointerDownL()
+ {
+ //let the pointer downed control do the canceling
+ if(iCtrlWithPointerDown)
+ {
+ if (iCtrlWithPointerDown != iActiveCtrl)
+ {
+ iCtrlWithPointerDown->SetActive(EFalse);
+ if (iActiveCtrl)
+ {
+ iActiveCtrl->SetActive(ETrue);
+ }
+ }
+ iCtrlWithPointerDown->CancelPointerDownL();
+ iCtrlWithPointerDown = NULL;
+ ReportEvent(EEventButtonDownCanceled);
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::HandlePointerLeave
+// Handle pointer leave event
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::HandlePointerLeave(const TPoint& aPt)
+ {
+ SetPointerDown( EFalse );
+ iPointerLeft = ETrue;
+
+ if(iCtrlWithPointerDown)
+ {
+ if(iCtrlWithPointerDown != iActiveCtrl)
+ {
+ SetTempActiveCtrl(iActiveCtrl);
+ }
+ iCtrlWithPointerDown->HandlePointerLeave(aPt);
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::HandlePointerEnter
+// Handle pointer enter event
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::HandlePointerEnter(const TPoint& aPt)
+ {
+ SetPointerDown( ETrue );
+ iPointerLeft = EFalse;
+ if(iCtrlWithPointerDown)
+ {
+ //does the pointer really enter this control?
+ if(iCtrlWithPointerDown->Contains(aPt))
+ {
+ SetTempActiveCtrl(iCtrlWithPointerDown);
+ iCtrlWithPointerDown->HandlePointerEnter(aPt);
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::ControlByType
+// Get a control by type and index
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CFepUiBaseCtrl* CControlGroup::ControlByType(TControlType aType,TInt aIndex)
+ {
+ if(aIndex < 0)
+ return NULL;
+
+ CFepUiBaseCtrl* ctrl = NULL;
+ TInt ctrlIdx = 0;
+ for(TInt i = 0;i < iCtrlList.Count();i++)
+ {
+ if(iCtrlList[i]->ControlType() == aType)
+ {
+ if(ctrlIdx == aIndex)
+ return iCtrlList[i];
+ else
+ ctrlIdx++;
+ }
+ else
+ {
+ //If sub control is a control group, loop inside the control group
+ if(iCtrlList[i]->IsKindOfControl(ECtrlControlGroup))
+ {
+ CControlGroup* ctrlGroup = static_cast<CControlGroup*>(iCtrlList[i]);
+ ctrl = ctrlGroup->ControlByType(aType,aIndex - ctrlIdx);
+ if(ctrl)
+ return ctrl;
+ }
+ }
+ }
+
+ return ctrl;
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::ControlHasType
+// Get a control by type and index
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CFepUiBaseCtrl* CControlGroup::ControlForKindOfType(
+ TStockBaseCtrlType aType,TInt aIndex)
+ {
+
+ if(aIndex < 0 || aIndex >= iCtrlList.Count())
+ return NULL;
+
+ CFepUiBaseCtrl* ctrl = NULL;
+ TInt ctrlIdx = 0;
+ for(TInt i = 0;i < iCtrlList.Count();i++)
+ {
+ if(iCtrlList[i]->IsKindOfControl(aType))
+ {
+ if(ctrlIdx == aIndex)
+ return iCtrlList[i];
+ else
+ ctrlIdx++;
+ }
+ else
+ {
+ //If sub control is a control group, loop inside the control group
+ if(iCtrlList[i]->IsKindOfControl(ECtrlControlGroup))
+ {
+ CControlGroup* ctrlGroup = static_cast<CControlGroup*>(iCtrlList[i]);
+ ctrl = ctrlGroup->ControlForKindOfType(aType,aIndex - ctrlIdx);
+ if(ctrl)
+ return ctrl;
+ }
+ }
+ }
+
+ return ctrl;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CControlGroup::OnDeActivate
+// Response to layout de activation event
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::OnDeActivate()
+ {
+ TRAP_IGNORE(OnDeActivateL());
+ }
+
+void CControlGroup::OnDeActivateL()
+ {
+ if(iCtrlWithPointerDown)
+ {
+ TRAP_IGNORE(iCtrlWithPointerDown->CancelPointerDownL());
+ iCtrlWithPointerDown = NULL;
+ }
+ CFepUiBaseCtrl::OnDeActivate();
+ for(TInt i = 0;i < iCtrlList.Count();i++)
+ {
+ CFepUiBaseCtrl* ctrl = iCtrlList[i];
+
+ __ASSERT_DEBUG(ctrl,User::Leave(-1));
+
+ iCtrlList[i]->OnDeActivate();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::OnDctivate
+// Response to layout activation event
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::OnActivate()
+ {
+ CFepUiBaseCtrl::OnActivate();
+ for(TInt i = 0;i < iCtrlList.Count();i++)
+ {
+ iCtrlList[i]->OnActivate();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::OnLayoutDraggingStart
+// Response to layout dragging start event
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::OnLayoutDraggingStart()
+ {
+ //notify child controls
+ for(TInt i = 0; i < iCtrlList.Count(); i++)
+ {
+ iCtrlList[i]->OnLayoutDraggingStart();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::OnLayoutDraggingEnd
+// Response to layout dragging end event
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::OnLayoutDraggingEnd()
+ {
+ //notify child controls
+ for(TInt i = 0; i < iCtrlList.Count(); i++)
+ {
+ iCtrlList[i]->OnLayoutDraggingEnd();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::ConstructFromResourceL
+// Handle resource change
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::ConstructFromResourceL()
+ {
+ //let child control hanlde resource change.
+ for(TInt i = 0; i < iCtrlList.Count(); i++)
+ {
+ iCtrlList[i]->ConstructFromResourceL();
+ }
+ }
+
+const RRegion& CControlGroup::CalculateNonHwrStartPtArea()
+ {
+ RRegion r;
+ iNonHwrStartPtRegion.Clear();
+ for(TInt i = 0; i < iCtrlList.Count(); ++i)
+ {
+ CFepUiBaseCtrl* ctrl = iCtrlList[i];
+ if(ctrl->Hiden() || !ctrl->Ready())
+ continue;
+ if(ctrl->IsKindOfControl(ECtrlControlGroup))
+ {
+ iNonHwrStartPtRegion.Union(static_cast<CControlGroup*>(ctrl)->
+ CalculateNonHwrStartPtArea());
+ continue;
+ }
+ if(ctrl->IsKindOfControl(ECtrlTransparentHwrWnd))
+ {
+ r.Copy(ctrl->Region());
+ continue;
+ }
+
+ iNonHwrStartPtRegion.AddRect(ctrl->Rect());
+ }
+ r.Sort();
+
+ RRegion r2;
+ r2.AddRect(UiLayout()->Rect());
+ r2.SubRegion(iNonHwrStartPtRegion);
+ r2.Sort();
+ r2.Close();
+ r.Close();
+ return iNonHwrStartPtRegion;
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::UpdateValidRegion
+// Update control's valid region when other control show or hide.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::UpdateValidRegion(CFepUiBaseCtrl* aCtrl,TBool aRemoveFlag)
+ {
+ if(!iUpdateFlagEnabled) //do nothing if disabled.
+ return;
+
+ if(aCtrl) //update due to this control
+ {
+ TInt idx = FindSubRegion(aCtrl);
+ if(aRemoveFlag)
+ {
+ if(idx == KErrNotFound)
+ return;
+ RemoveSubRegion(idx);
+
+ delete iSubRegionArea[idx];
+ iSubRegionArea.Remove(idx);
+ CalculateClipRegion();
+ }
+ else
+ {
+ if(idx == KErrNotFound) //new one
+ {
+ //no need to check whether the control is hide as updating is done when
+ //control is hiden.
+ //CSubRegionArea area(aCtrl,aCtrl->Region());
+ //iSubRegionArea.Append(area);
+ TRAP_IGNORE(AddSubRegionL(aCtrl));
+ CalculateClipRegion(aCtrl);
+ }
+ else //replace the old one
+ {
+ RemoveSubRegion(idx);
+ iSubRegionArea[idx]->iSubRegion.Copy(aCtrl->Region());
+ CalculateClipRegion();
+ }
+ iValidRegion.Union(aCtrl->Region());
+ }
+ }
+ else //recalculate valid region
+ {
+ iSubRegionArea.ResetAndDestroy();
+ iValidRegion.Clear();
+ for(TInt i = 0 ; i < iCtrlList.Count(); ++i)
+ {
+ iValidRegion.Union(iCtrlList[i]->Region());
+ //CSubRegionArea area(aCtrl,aCtrl->Region());
+ //iSubRegionArea.Append(area);
+ TRAP_IGNORE(AddSubRegionL(iCtrlList[i]));
+ }
+
+ CalculateClipRegion();
+ }
+
+ if(iParentCtrl)
+ iParentCtrl->UpdateValidRegion(this,EFalse);
+ }
+
+TInt CControlGroup::FindSubRegion(CFepUiBaseCtrl* aCtrl)
+ {
+ for(TInt i = 0; i < iSubRegionArea.Count(); ++i)
+ {
+ if(aCtrl == iSubRegionArea[i]->iSubCtrl)
+ return i;
+ }
+
+ return KErrNotFound;
+ }
+
+void CControlGroup::RemoveCtrlFromSubCtrlInfoList(CFepUiBaseCtrl* aControl)
+ {
+ for(TInt i = 0 ; i < iSubCtrlShowStateBeforeHiden.Count(); ++i)
+ {
+ if(iSubCtrlShowStateBeforeHiden[i].iSubCtrl == aControl)
+ {
+ iSubCtrlShowStateBeforeHiden.Remove(i);
+ break;
+ }
+ }
+ }
+
+//record each sub control's current hide/show state
+void CControlGroup::SaveSubCtrlShownState()
+ {
+ iSubCtrlShowStateBeforeHiden.Reset();
+ for (TInt i = 0; i < iCtrlList.Count(); ++i)
+ {
+ TSubCtrlShownState state = {iCtrlList[i],iCtrlList[i]->Hiden()};
+
+ TRAP_IGNORE(iSubCtrlShowStateBeforeHiden.AppendL(state));
+ }
+ }
+
+void CControlGroup::AddSubRegionL(CFepUiBaseCtrl* aCtrl)
+ {
+ //no need to check aCtrl
+ CSubRegionArea* area = new (ELeave) CSubRegionArea(aCtrl,aCtrl->Region());
+ CleanupStack::PushL(area);
+ iSubRegionArea.AppendL(area);
+ CleanupStack::Pop(area);
+ }
+
+void CControlGroup::RemoveSubRegion(TInt aIdx)
+ {
+ //check whether this region is clipped with other region
+ RRegion overlappedReg;
+ for(TInt i = 0 ; i < iSubRegionArea.Count(); ++i)
+ {
+ if(i == aIdx)
+ continue;
+
+ RRegion r;
+ r.Intersection(iSubRegionArea[aIdx]->iSubRegion,
+ iSubRegionArea[i]->iSubRegion);
+ overlappedReg.Union(r);
+ r.Close();
+ }
+ iValidRegion.SubRegion(iSubRegionArea[aIdx]->iSubRegion);
+ iValidRegion.Union(overlappedReg);
+ overlappedReg.Close();
+
+ }
+
+// -----------------------------------------------------------------------------
+// CControlGroup::BringToTop
+// Bring and show a control in current group
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool CControlGroup::MoveSubCtrlToTop(CFepUiBaseCtrl* aCtrl,RPointerArray<CFepUiBaseCtrl>& aList)
+ {
+ TInt index = aList.Find(aCtrl);
+ if(KErrNotFound == index)
+ return EFalse;
+ //move the control to the end of the list
+ for(; index < aList.Count() -1; ++index)
+ {
+ aList[index] = aList[index + 1];
+ }
+ aList[index] = aCtrl;
+ return ETrue;
+ }
+
+TBool CControlGroup::MoveSubCtrlToBack(CFepUiBaseCtrl* aCtrl,RPointerArray<CFepUiBaseCtrl>& aList)
+ {
+ TInt index = aList.Find(aCtrl);
+ if(KErrNotFound == index)
+ return EFalse;
+ //move the control to the start of the list
+ for(; index > 0; --index)
+ {
+ //stop if found background control
+ if( iCtrlList[index-1]->IsKindOfControl(ECtrlBackgroundCtrl) ||
+ iCtrlList[index-1]->IsKindOfControl(ECtrlTransparentHwrWnd) )
+ {
+ break;
+ }
+
+ aList[index] = aList[index -1];
+ }
+ aList[index] = aCtrl;
+ return ETrue;
+ }
+
+EXPORT_C void CControlGroup::BringToTopInGroup(CFepUiBaseCtrl* aCtrl)
+ {
+ if(MoveSubCtrlToTop(aCtrl,iCtrlList)) //check in iCtrlList first
+ {
+ aCtrl->iClipRegion.Clear();
+ aCtrl->iClipRegion.AddRect(aCtrl->Rect());
+ UpdateValidRegion(aCtrl,EFalse);
+ //other control should update its valid/clip region
+ }
+ }
+
+EXPORT_C void CControlGroup::BringToBackInGroup(CFepUiBaseCtrl* aCtrl)
+ {
+ if(MoveSubCtrlToBack(aCtrl,iCtrlList)) //check in iCtrlList first
+ {
+ aCtrl->iClipRegion.Clear();
+ aCtrl->iClipRegion.AddRect(aCtrl->Rect());
+
+ UpdateValidRegion(aCtrl,EFalse);
+ //other control should update its valid/clip region
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CControlGroup::OnResourceChange
+// Handle system resource change
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::HandleResourceChange(TInt aType)
+ {
+ //let child control handle the resource change
+ for(TInt i = 0 ; i < iCtrlList.Count(); ++i)
+ {
+ iCtrlList[i]->HandleResourceChange(aType);
+ }
+ CFepUiBaseCtrl::HandleResourceChange(aType);
+ }
+// -----------------------------------------------------------------------------
+// CControlGroup::GraphicDeviceSizeChanged
+// Handle graphic device size change event
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::GraphicDeviceSizeChanged()
+ {
+ //let child control handle the resource change
+ for(TInt i = 0 ; i < iCtrlList.Count(); ++i)
+ {
+ iCtrlList[i]->GraphicDeviceSizeChanged();
+ }
+ CFepUiBaseCtrl::GraphicDeviceSizeChanged();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CControlGroup::UpdateArea
+// Update layout area
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CControlGroup::UpdateAreaInGrp(CFepUiBaseCtrl* aControl,const TRect& aRect,TBool aUpdateFlag)
+ {
+ RedrawRectInGrp( aControl, aRect );
+ UpdateArea(aRect,aUpdateFlag);
+ }
+
+//implementation for class CControlGroup::CSubRegionArea::CSubRegionArea
+CControlGroup::CSubRegionArea::CSubRegionArea(const CFepUiBaseCtrl* aCtrl,const RRegion &aRegion)
+ : iSubCtrl(aCtrl) //,iSubRegion(aRegion)
+ {
+ iSubRegion.Copy(aRegion);
+ //RRegion's copy constructor will make two region point to same data. !!!
+ }
+CControlGroup::CSubRegionArea::~CSubRegionArea()
+ {
+ iSubRegion.Close();
+ }
+
+TInt CControlGroup::GetNestedLevel()
+ {
+ TInt level = 1;
+ CFepUiBaseCtrl* parent = ParentCtrl();
+ if(!parent)
+ return 0; //This is the root control
+
+ while(parent && parent != RootControl())
+ {
+ parent = ParentCtrl();
+ level++;
+ }
+ return level;
+ }
+
+
+TInt CControlGroup::GetIdx(const CFepUiBaseCtrl* aCtrl)
+ {
+ for(TInt i = 0; i < iCtrlList.Count(); i++)
+ {
+ if(iCtrlList[i] == aCtrl)
+ {
+ return i;
+ }
+ }
+ return KErrNotFound;
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::DrawControlGroupBackground
+// Draw ControlGroup Background
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CControlGroup::DrawControlGroupBackground( const TRect& aUpdateRegion )
+ {
+ DrawBackground( aUpdateRegion );
+ }
+
+void CControlGroup::AdjustBkCtrlPos()
+ {
+ //No need to check the first control
+ TInt firstBkCtrlPos = 1;
+ for(TInt i = 1 ; i < iCtrlList.Count(); ++i)
+ {
+ if(iCtrlList[i]->IsKindOfControl(ECtrlBackgroundCtrl))
+ {
+ //move to first
+ CFepUiBaseCtrl* ctrl = iCtrlList[firstBkCtrlPos];
+ iCtrlList[firstBkCtrlPos++] = iCtrlList[i];
+
+ for(TInt j = i ; j < firstBkCtrlPos ; --j)
+ {
+ iCtrlList[j] = iCtrlList[j-1];
+ }
+ iCtrlList[firstBkCtrlPos] = ctrl;
+ }
+ else
+ {
+ if(iCtrlList[i]->IsKindOfControl(ECtrlControlGroup))
+ {
+ CControlGroup* ctrlGroup = static_cast<CControlGroup*>(iCtrlList[i]);
+ ctrlGroup->AdjustBkCtrlPos();
+ }
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CControlGroup::UpdateAreaInGrpImmed
+// Update layout area
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CControlGroup::UpdateAreaInGrpImmed(CFepUiBaseCtrl* aControl,const TRect& aRect,TBool aUpdateFlag)
+ {
+ RedrawRectInGrp( aControl, aRect );
+ UpdateAreaImmed(aRect,aUpdateFlag);
+ }
+
+
+// ---------------------------------------------------------------------------
+// CControlGroup::RedrawRectInGrp
+// Redraw rect
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CControlGroup::RedrawRectInGrp( CFepUiBaseCtrl* aControl,const TRect& aRect )
+ {
+ //check in ctrl list
+ TInt idx = 0;
+ for(; idx < iCtrlList.Count(); ++idx)
+ {
+ if(aControl == iCtrlList[idx])
+ {
+ ++idx;
+ break;
+ }
+ }
+
+ for(; idx < iCtrlList.Count(); ++idx)
+ {
+ if(aRect.Intersects(iCtrlList[idx]->Rect()) &&
+ !iCtrlList[idx]->Hiden())
+ {
+ iCtrlList[idx]->ReDrawRect(aRect);
+ }
+ }
+ //check the pop up list
+ for(idx = 0 ; idx < iPopCtrlList.Count(); ++idx)
+ {
+ if(aRect.Intersects(iPopCtrlList[idx]->Rect()) &&
+ !iPopCtrlList[idx]->Hiden())
+ {
+ if(aControl != iPopCtrlList[idx]) //not the same one
+ iPopCtrlList[idx]->ReDrawRect(aRect);
+ }
+ }
+ }
+//end of file