diff -r 000000000000 -r eb1f2e154e89 textinput/peninputarc/src/peninputlayoutcontrol/peninputlayoutrootctrl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/textinput/peninputarc/src/peninputlayoutcontrol/peninputlayoutrootctrl.cpp Tue Feb 02 01:02:04 2010 +0200 @@ -0,0 +1,1174 @@ +/* +* 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 +#include +#include +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(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); + } + } + //The layout shadow rect starts from TPoint(0,0); + iShadowRect.Move(-iLayoutPos); + + s = iShadowRect.Size(); + } + else + { + iLayoutPos = iRect.iTl; + iRect.Move(-iLayoutPos); + } + + iNonHwrStartPtRegion.Clear(); + /* + iNonHwrStartPtRegion.AddRect(iRect); + + //find HWR window and remove it from the region + CFepUiBaseCtrl* hwrWnd = ControlForKindOfType(ECtrlTransparentHwrWnd); + TInt index = 0; + while(hwrWnd) + { + iNonHwrStartPtRegion.SubRegion(hwrWnd->Region()); + //find next hwr window + hwrWnd = ControlForKindOfType(ECtrlTransparentHwrWnd,++index); + } + */ + + CalculateNonHwrStartPtArea(); + const TRegion& t = RootControl()->NonHwrStartingPtRegion(); + TInt n = t.Count(); + const TRect* r =t.RectangleList(); + + RegisterICFEditor(); + //check each control group, whether there is background control, + //adjust pos if necessary + AdjustBkCtrlPos(); + //now it's ready to be drawn + SetReady(ETrue); + + UpdateValidRegion(NULL,EFalse); + return TRect(iLayoutPos,s); + } + +// --------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::CapturePointer +// Capture pointer +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +CFepUiBaseCtrl* CFepUiLayoutRootCtrl::CapturePointer(CFepUiBaseCtrl* aCtrl, + TBool aFlag) + { + CFepUiBaseCtrl* ctrl = iPointerCaptureCtrl; + if(aFlag) + { + if( iPointerCaptureCtrl && aCtrl && + iPointerCaptureCtrl->ControlId() == aCtrl->ControlId() ) + { + return ctrl; + } + + iPointerCaptureCtrl = aCtrl; + if(iCtrlWithPointerDown && ! aCtrl->PointerDown()) + { + //if someone else has pointer down, we must cancel the down event. + TRAP_IGNORE(iCtrlWithPointerDown->CancelPointerDownL()); + iCtrlWithPointerDown = NULL; + } + } + else + { + if(!iPointerCaptureCtrl && !aFlag) + return NULL; + if (aCtrl == iPointerCaptureCtrl) + { + iPointerCaptureCtrl = NULL; + } + } + //signal the owner that pointer needs be captured + TInt captureCtrl = (TInt)(iPointerCaptureCtrl); + + TBuf<8> buf; + buf.Append((const TUint16 *)(&aFlag), sizeof(TBool)/sizeof(TUint16)); + buf.Append((const TUint16 *)(&captureCtrl), sizeof(TInt)/sizeof(TUint16)); + UiLayout()->SignalOwner(ESignalCapturePointer,buf); + + + return ctrl; + } + + +// --------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::HandleControlEvent +// Handle control event. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CFepUiLayoutRootCtrl::HandleControlEvent(TInt aEventType, CFepUiBaseCtrl* aCtrl, + const TDesC& /*aEventData*/) + { + CFepUiBaseCtrl* ctrl; + switch(aEventType) + { + case EEventDraggingStart: + { + for(TInt i = 0; i < iCtrlList.Count(); i++) + { + iCtrlList[i]->OnLayoutDraggingStart(); + } + } + break; + case EEventDraggingEnd: + { + for(TInt i = 0; i < iCtrlList.Count(); i++) + { + iCtrlList[i]->OnLayoutDraggingEnd(); + } + } + break; + case EEventRegionUpdated: + { + //now find the hwr wwindow + for(TInt i = 0; i < iCtrlList.Count(); i++) + { + ctrl = iCtrlList[i]; + if(ctrl->IsKindOfControl(ECtrlHwrWnd)) + { + static_cast(ctrl)->UpdateRegion(aCtrl); + } + } + } + break; + + default: + break; + } + } + +// --------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::HandlePositionChange +// Handle layout position change +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CFepUiLayoutRootCtrl::HandlePositionChange(const TPoint& aOffset) + { + const TPoint KZeroOffset(0,0); + if(aOffset != KZeroOffset) + { + TPoint pos = UiLayout()->Position() + aOffset; + UiLayout()->SetLayoutPos(pos); + } + return ETrue; //if layout process the event, the no control will process it. + } + +// --------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::GetInputContextFieldMaxLen +// Get the max editor length of the input context field +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CFepUiLayoutRootCtrl::GetInputContextFieldMaxLen() + { + TInt len = 0; + //find the input context area control. At any time there is only one editor + //area control in the layout. + CFepUiBaseCtrl* ctrl = ControlForKindOfType(ECtrlEditAreaBase); + if(ctrl) + { + len = static_cast(ctrl)-> + GetEditorFieldMaxLen(); + } + + return len; + } + +// --------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::IsValidDestination +// Test whether the rect conflicts with other controls +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CFepUiLayoutRootCtrl::IsValidDestination(const TRect& aRect, + CDragBar* aDragBar, + TBool& aVInfo, + TBool& aHInfo) + { + aVInfo = EFalse; + aHInfo = EFalse; + if(!Rect().Contains(aRect.iTl) || !Rect().Contains(aRect.iBr)) //outside of the ui layout + return EFalse; + + CFepUiBaseCtrl* ctrl; + + for(TInt i = iCtrlList.Count()-1; i >= 0;i--) + { + ctrl = iCtrlList[i]; + TBool bIsDragingComponent = EFalse; + if(aDragBar) + { + if(aDragBar->IsDraggingComponent(ctrl)) + bIsDragingComponent = ETrue; + } + + + if(!bIsDragingComponent && aRect.Intersects(ctrl->Rect())) //conflicts with others + { + //is the control one of the dragbar component. + + if(!ctrl->AllowOverlap()) + { + //if the control not allow overlapping, then it's invalid pos + return EFalse; + } + + } + } + + return ETrue; +} +// --------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::HandlePointerDownEventL +// Handle pointer down event +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +CFepUiBaseCtrl* CFepUiLayoutRootCtrl::HandlePointerDownEventL( + const TPoint& aPoint) + { + return CControlGroup::HandlePointerDownEventL(aPoint); + } + +// --------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::HandlePointerUpEventL +// Handle pointer up event +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +CFepUiBaseCtrl* CFepUiLayoutRootCtrl::HandlePointerUpEventL( + const TPoint& aPoint) + { + CFepUiBaseCtrl* ctrl = CControlGroup::HandlePointerUpEventL(aPoint); + if(!ctrl && iCtrlWithPointerDown) + { + iCtrlWithPointerDown->CancelPointerDownL(); + iCtrlWithPointerDown = NULL; + } + + return ctrl; + } + +// --------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::HandlePointerMoveEventL +// Handle pointer move event +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +CFepUiBaseCtrl* CFepUiLayoutRootCtrl::HandlePointerMoveEventL( + const TPoint& aPoint) + { + CFepUiBaseCtrl* ctrl = CControlGroup::HandlePointerMoveEventL(aPoint); + //Moving outside of layout + if(!ctrl && iCtrlWithPointerDown && !iPointerLeft) + { + iCtrlWithPointerDown->HandlePointerLeave(aPoint); + iPointerLeft = ETrue; + } + // Moving back from outside of layout to current control + if(ctrl == iCtrlWithPointerDown && iPointerLeft && iCtrlWithPointerDown) + { + iCtrlWithPointerDown->HandlePointerEnter(aPoint); + iPointerLeft = EFalse; + } + + return ctrl; + } + +// ----------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::Draw +// Draw the control +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CFepUiLayoutRootCtrl::Draw() + { + + if(!AbleToDraw()) + return; + + CControlGroup::Draw(); + + if(!iShadowRect.IsEmpty()) + { + iShadowShown = ETrue; + DrawShadow(); + } + + UpdateArea(iRect, EFalse); + } + +// --------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::DrawFrame +// Draw moving frame +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TRect CFepUiLayoutRootCtrl::DrawFrame(const TRect& aFrameRect, TBool aDrawFlag) + { + + //clear shadow when moving + TBool updateShadowArea = EFalse; + TRect dirtyRect; + if(iShadowShown) + { + ClearRect(iShadowRect); + iShadowShown = EFalse; + updateShadowArea = ETrue; + } + + + TRect bmpRect; + TPoint bmpPos; + + CFbsBitGc* gc = static_cast(BitGc()); + + //draw mask background + TRgb maskPenCol = aDrawFlag ? TRgb(KOpaqueColor) : TRgb(KTransparentColor); + DrawBackgroundToDevice(aFrameRect,MaskBitmapDevice(), 0, + //TRgb(KTransparentColor), TRgb(KOpaqueColor),EFalse); + TRgb(KTransparentColor), maskPenCol,EFalse); + + //draw background + TRgb penCor = aDrawFlag ? KRgbBlack : KRgbWhite; + TAknsQsnOtherColorsIndex clrIndex; + clrIndex = EAknsCIQsnOtherColorsCG9; + + if ( AknsUtils::AvkonSkinEnabled() ) + { + AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), + penCor, KAknsIIDQsnTextColors, clrIndex ); + } + + DrawBackgroundToDevice(aFrameRect,BitmapDevice(),0,TRgb(KRgbWhite),penCor,EFalse); + + gc->RectDrawnTo(dirtyRect); + + if(updateShadowArea) + return iShadowRect; + else + return dirtyRect; + } + +// --------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::OnDeActivate +// Response to layout de activation event +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C void CFepUiLayoutRootCtrl::OnDeActivate() + { + if ( iPointerCaptureCtrl ) + { + if(iPointerCaptureCtrl->PointerDown()) + { + TRAP_IGNORE(iPointerCaptureCtrl->CancelPointerDownL()); + } + + //CFepLayoutMultiLineIcf::CancelPointerDownL may set iPointerCaptureCtrl to be NULL + if ( iPointerCaptureCtrl ) + { + iPointerCaptureCtrl->CapturePointer(EFalse); + iPointerCaptureCtrl = NULL; + } + } + iPointerDownCanceled = EFalse; + CControlGroup::OnDeActivate(); + } + +// --------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::OnActivate +// Response to layout activation event +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C void CFepUiLayoutRootCtrl::OnActivate() + { + CControlGroup::OnActivate(); + } +void CFepUiLayoutRootCtrl::DoRegionUpdateForCtrls() + { + CFepUiBaseCtrl* ctrl; + for(TInt i = 0; i< iCtrlRegionAwareList.Count(); i++) + { + ctrl = iCtrlRegionAwareList[i]; + if(ctrl->Ready()) + ctrl->UpdateValidRegion(NULL,EFalse); + } + + } + +void CFepUiLayoutRootCtrl::RegisterICFEditor() + { + TInt index = 0; + while(ETrue) + { + CFepUiBaseCtrl* ctrl = ControlForKindOfType(ECtrlEditAreaBase,index++); + if(!ctrl) + break; + iCtrlOverlappingAwareList.Append(ctrl); + } + } + +CWindowToBitmapMappingGc* CFepUiLayoutRootCtrl::GetRWindowGcL() + { + if(!iWindowGc) + { + CWsScreenDevice *screenDevice = CCoeEnv::Static()->ScreenDevice(); + CFbsBitGc* gc = static_cast(UiLayout()->LayoutOwner()->BitmapContext()); + iWindowGc = CWindowToBitmapMappingGc::NewL(*screenDevice,*gc); + } + return iWindowGc; + } + +// ----------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::OnResourceChange +// Handle system resource change +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CFepUiLayoutRootCtrl::HandleResourceChange(TInt aType) + { + CControlGroup::HandleResourceChange(aType); + } + +// ----------------------------------------------------------------------------- +// CFepUiLayoutRootCtrl::GraphicDeviceSizeChanged +// Handle graphic device size change event +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CFepUiLayoutRootCtrl::GraphicDeviceSizeChanged() + { + CControlGroup::GraphicDeviceSizeChanged(); + } + +CFepUiCursor* CFepUiLayoutRootCtrl::CreateCursor() + { + CFepUiCursor* cursor = NULL; + TRAP_IGNORE(cursor = CreateCursorL()); + return cursor; + } + +CFepUiCursor* CFepUiLayoutRootCtrl::CreateCursorL() + { + if(!iCursor) + { + const TInt KCursorId = -1; + iCursor = CFepUiCursor::NewL(TRect(0,0,0,0),UiLayout(),KCursorId); + } + + return iCursor; + } + +void CFepUiLayoutRootCtrl::InsertToPopList(CFepUiBaseCtrl* aCtrl) + { + TInt idx = iPopCtrlList.Find(aCtrl); + if(idx == KErrNotFound) + { + iPopCtrlList.Insert(aCtrl,0); + idx = 0; + } + //move to desired position + + for(TInt i = idx + 1; i < iPopCtrlList.Count(); ++i) + { + if(aCtrl->OrderPos() <= iPopCtrlList[i]->OrderPos()) + { + iPopCtrlList[i - 1] = iPopCtrlList[i]; + } + else + { + iPopCtrlList[i - 1] = aCtrl; + break; + } + } + } + +TBool CFepUiLayoutRootCtrl::ClipCursorForCtrlNeeded(CFepUiBaseCtrl* aCtrl, + const TBool aBringToTopFlag, + TInt& aCursorIndex) + { + TBool bNeedClip = EFalse; + TBool bNeedClipBack = EFalse; + + if(aCtrl->IsOnTopOf(iCursor)) + { + if(aBringToTopFlag) + { + bNeedClip = ETrue; + } + else + { + bNeedClipBack = ETrue; + } + } + else + { + //otherwise, we need to find the index in the same control group. + CFepUiBaseCtrl* cursor = iCursor->iEditor; + CFepUiBaseCtrl* overlapCtrl = aCtrl; + CControlGroup* cursorParent = static_cast(cursor->ParentCtrl()); + CControlGroup* overlapCtrlParent = static_cast(overlapCtrl->ParentCtrl()); + + if(cursorParent != overlapCtrlParent) + { + //find out the nest level counting starts from root control + TInt cursorLev = cursorParent->GetNestedLevel(); + //find out the nest level counting starts from root control + TInt overlapCtrlLev = overlapCtrlParent->GetNestedLevel(); + + if(cursorLev > overlapCtrlLev) + { + for(TInt i = 0 ; i < cursorLev - overlapCtrlLev; ++i) + { + cursor = cursorParent; + cursorParent = static_cast(cursor->ParentCtrl()); + } + } + + if(overlapCtrlLev > cursorLev) + { + for(TInt i = 0 ; i < overlapCtrlLev - cursorLev; ++i) + { + overlapCtrl = overlapCtrlParent; + overlapCtrlParent = static_cast(overlapCtrl->ParentCtrl()); + } + } + + //now we are in the same nest level, loop until parent is the same + while(cursorParent != overlapCtrlParent) + { + cursor = cursorParent; + overlapCtrl = overlapCtrlParent; + cursorParent = static_cast(cursor->ParentCtrl()); + overlapCtrlParent = static_cast(overlapCtrl->ParentCtrl()); + } + + } + + aCursorIndex = cursorParent->GetIdx(cursor); + TInt overlapCtrlInd= overlapCtrlParent->GetIdx(overlapCtrl); + if(aBringToTopFlag && overlapCtrlInd > aCursorIndex ) + { + bNeedClip = ETrue; + } + else if(!aBringToTopFlag && overlapCtrlInd < aCursorIndex) + { + bNeedClipBack = ETrue; + } + } + + if(aBringToTopFlag) + { + return bNeedClip; + } + else + { + return bNeedClipBack; + } + } + +void CFepUiLayoutRootCtrl::BringToTopInGroup(CFepUiBaseCtrl* aCtrl) + { + if(aCtrl->ParentCtrl() == this) + CControlGroup::BringToTopInGroup(aCtrl); + else + { + //If a control has no parent, it's added to the pop list. + if(aCtrl->OrderPos() != EOrderFront) + { + aCtrl->SetOrdinalPos(EOrderFront); + } + InsertToPopList(aCtrl); + } + + + if(iCursor) + { + //set cursor valid/clip region + TInt cursorIndex = 0; + if(aCtrl->Overlapped(iCursor) && ClipCursorForCtrlNeeded(aCtrl, ETrue, cursorIndex)) + { + iCursor->ResetValidClipRegion(); + iCursor->UpdateValidRegion(aCtrl,EFalse); + } + } + } + +void CFepUiLayoutRootCtrl::BringToBackInGroup(CFepUiBaseCtrl* aCtrl) + { + if(aCtrl->ParentCtrl() == this) + { + CControlGroup::BringToBackInGroup(aCtrl); + } + else + { + TInt idx = iPopCtrlList.Find(aCtrl); + if(idx == KErrNotFound) + return; + + //move to desired position + for(TInt i = idx -1 ; i >= 0 ; --i) + { + if(aCtrl->OrderPos() >= iPopCtrlList[i]->OrderPos()) + { + iPopCtrlList[i+1] = iPopCtrlList[i]; + } + else + { + iPopCtrlList[i+1] = aCtrl; + break; + } + } + + } + + if(iCursor) + { + TInt cursorIndex = 0; + if(aCtrl->Overlapped(iCursor) && ClipCursorForCtrlNeeded(aCtrl, EFalse, cursorIndex)) + { + // Reset the clip region, which overlap the cursor + iCursor->ResetValidClipRegion(); + for(TInt i = cursorIndex + 1; i < iCtrlList.Count(); i++) + { + if(!iCtrlList[i]->Hiden()) + iCursor->UpdateValidRegion(iCtrlList[i],EFalse); + } + for(TInt j = 0 ; j < iPopCtrlList.Count(); ++j) + { + if(!iPopCtrlList[j]->Hiden()) + iCursor->UpdateValidRegion(iPopCtrlList[j],EFalse); + } + } + } + }