1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/graphics/windowing/windowserver/nga/SERVER/openwfc/WINBASE.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,808 @@
1.4 +// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// Window virtual base class, windows and window groups are derived from this
1.18 +//
1.19 +//
1.20 +
1.21 +#include <e32std.h>
1.22 +#include "server.h"
1.23 +#include "winbase.h"
1.24 +#include "rootwin.h"
1.25 +#include "windowgroup.h"
1.26 +#include "walkwindowtree.h"
1.27 +#include "wstop.h"
1.28 +#include "EVQUEUE.H"
1.29 +#include "EVENT.H"
1.30 +#include "panics.h"
1.31 +#include "pointer.h"
1.32 +#include "windowelementset.h"
1.33 +
1.34 +CWsWindowBase::CWsWindowBase(CWsClient* aOwner,WH_HANDLES aType, CScreen* aScreen) : CWsScreenObject(aOwner,aType,aScreen)
1.35 + {
1.36 + }
1.37 +
1.38 +void CWsWindowBase::ConstructL(CWsWindowBase *aParent)
1.39 + {
1.40 + iParent=aParent;
1.41 + iSibling=aParent->iChild;
1.42 + aParent->iChild=this;
1.43 + CScreen* screen = aParent->Screen();
1.44 + WS_ASSERT_DEBUG(screen,EWsPanicNoScreen);
1.45 + MWsWindowTreeObserver* const windowTreeObserver = screen->WindowTreeObserver();
1.46 + if (windowTreeObserver)
1.47 + {
1.48 + windowTreeObserver->NodeCreated(*this, ParentNode());
1.49 + iBaseWinFlags |= EBaseWinNodeCreated;
1.50 + }
1.51 + SetOrdinalPosition(0);
1.52 + iFadeCount = iParent->iFadeCount;
1.53 + }
1.54 +
1.55 +CWsWindowBase *CWsWindowBase::GetPrevSibling() const
1.56 + {
1.57 + if(iParent == NULL) //RootWindow
1.58 + return(NULL);
1.59 +
1.60 + CWsWindowBase* prev=iParent->iChild;
1.61 + CWsWindowBase *ret=NULL;
1.62 + while (prev!=this)
1.63 + {
1.64 + ret=prev;
1.65 + prev=prev->iSibling;
1.66 + }
1.67 + return(ret);
1.68 + }
1.69 +
1.70 +CWsWindowBase *CWsWindowBase::LastSibling() const
1.71 + {
1.72 + const CWsWindowBase *win;
1.73 + for(win=this;win->iSibling;win=win->iSibling)
1.74 + {}
1.75 + return (CWsWindowBase*)win;
1.76 + }
1.77 +
1.78 +CWsWindowBase *CWsWindowBase::PrevSiblingMultiParent() const
1.79 + {
1.80 + CWsWindowBase *win=GetPrevSibling();
1.81 + if (win)
1.82 + return(win);
1.83 + for(CWsWindowBase *parent=iParent->GetPrevSibling();parent;parent=parent->GetPrevSibling())
1.84 + if ((win=parent->iChild)!=NULL)
1.85 + return(win->LastSibling());
1.86 + return(NULL);
1.87 + }
1.88 +
1.89 +CWsWindowBase *CWsWindowBase::NextSiblingMultiParent() const
1.90 + {
1.91 + if (iSibling)
1.92 + return(iSibling);
1.93 + for(CWsWindowBase *parent=iParent->iSibling;parent;parent=parent->iSibling)
1.94 + {
1.95 + if (parent->iChild!=NULL)
1.96 + return(parent->iChild);
1.97 + }
1.98 + return(NULL);
1.99 + }
1.100 +
1.101 +TInt CWsWindowBase::OrdinalPosition(TBool aFull) const
1.102 + {
1.103 + if (!iParent)
1.104 + {
1.105 + OwnerPanic(EWservPanicParentDeleted);
1.106 + }
1.107 + CWsWindowBase *win=iParent->iChild;
1.108 + if (!aFull)
1.109 + while(iOrdinalPriority<win->iOrdinalPriority)
1.110 + win=win->iSibling;
1.111 + TInt count;
1.112 + for(count=0;win!=this;count++)
1.113 + win=win->iSibling;
1.114 + return(count);
1.115 + }
1.116 +
1.117 +/** Removes a window from the list of siblings maintained by its parent window.
1.118 +
1.119 +The iSibling stored inside the window we remove is kept unchanged as it may be needed later.
1.120 +
1.121 +@internalComponent
1.122 +@released
1.123 +*/
1.124 +void CWsWindowBase::RemoveFromSiblingList()
1.125 + {
1.126 + if (iParent!=NULL)
1.127 + {
1.128 + CWsWindowBase **prev= &iParent->iChild;
1.129 + while ((*prev)!=this)
1.130 + prev= &(*prev)->iSibling;
1.131 + *prev=iSibling;
1.132 + }
1.133 + }
1.134 +
1.135 +CWsWindowGroup *CWsWindowBase::WinGroup() const
1.136 + {
1.137 + if (iWinType==EWinTypeClient)
1.138 + return(((CWsClientWindow *)this)->TopClientWindow()->Parent());
1.139 + if (iWinType==EWinTypeGroup)
1.140 + return((CWsWindowGroup *)this);
1.141 + return(NULL);
1.142 + }
1.143 +
1.144 +TBool CWsWindowBase::CheckOrdinalPositionChange(TInt aPos)
1.145 +//
1.146 +// This routine checks to see whether the specified new ordinal position
1.147 +// will causes a change, if so returns ETrue else EFalse.
1.148 +//
1.149 + {
1.150 + CWsWindowBase *win= iParent->iChild;
1.151 + CWsWindowBase *prev= NULL;
1.152 + while(win==this || (win!=NULL && iOrdinalPriority<win->iOrdinalPriority))
1.153 + {
1.154 + prev=win;
1.155 + win=win->iSibling;
1.156 + }
1.157 + if (prev==this)
1.158 + win=this;
1.159 + else if (win==NULL || (win->iSibling==this && iOrdinalPriority>win->iOrdinalPriority))
1.160 + return ETrue;
1.161 + while(aPos--!=0 && win->iSibling!=NULL && iOrdinalPriority==win->iSibling->iOrdinalPriority)
1.162 + win=win->iSibling;
1.163 + return(win!=this);
1.164 + }
1.165 +
1.166 +void CWsWindowBase::ChangeWindowPosition(TInt aPos,CWsWindowBase* aNewParent)
1.167 + {
1.168 + TBool changedWindowGroup = EFalse;
1.169 + WS_ASSERT_DEBUG(aNewParent,EWsPanicWindowNull);
1.170 + if (aNewParent != iParent)
1.171 + {
1.172 + iScreen->ScheduleRegionUpdate(NULL);
1.173 + TWalkWindowTreeScheduleRedraws wwt;
1.174 + WalkWindowTree(wwt, EWalkChildren);
1.175 + changedWindowGroup = ETrue;
1.176 + }
1.177 + else if (WinType() == EWinTypeClient)
1.178 + {
1.179 + CWsClientWindow * cliwin = static_cast<CWsClientWindow*>(this);
1.180 + if (cliwin->IsVisible())
1.181 + {
1.182 + iScreen->ScheduleRegionUpdate(NULL);
1.183 + if (cliwin->IsTranslucent())
1.184 + {
1.185 + // There is still room for optimization here. These redraws are only required if the window
1.186 + // moved through another window and BOTH of them were transparent, otherwise the visible
1.187 + // region change will sort out the redraws required.
1.188 + TWalkWindowTreeScheduleRedraws wwt;
1.189 + WalkWindowTree(wwt, EWalkChildren);
1.190 + }
1.191 + }
1.192 + }
1.193 + else if (WinType() == EWinTypeGroup)
1.194 + {
1.195 + iScreen->ScheduleRegionUpdate(NULL);
1.196 + if (static_cast<CWsWindowGroup*>(this)->HasVisibleTranslucentChild())
1.197 + {
1.198 + TWalkWindowTreeScheduleRedraws wwt;
1.199 + WalkWindowTree(wwt, EWalkChildren);
1.200 + }
1.201 + }
1.202 +
1.203 + RemoveFromSiblingList();
1.204 + CWsWindowBase **prevWinPtr= &aNewParent->iChild;
1.205 + while((*prevWinPtr)!=NULL && iOrdinalPriority<(*prevWinPtr)->iOrdinalPriority)
1.206 + {
1.207 + prevWinPtr= &(*prevWinPtr)->iSibling;
1.208 + }
1.209 + while(aPos--!=0 && *prevWinPtr!=NULL && iOrdinalPriority==(*prevWinPtr)->iOrdinalPriority)
1.210 + {
1.211 + prevWinPtr= &(*prevWinPtr)->iSibling;
1.212 + }
1.213 + iSibling=*prevWinPtr;
1.214 + iParent=aNewParent;
1.215 + *prevWinPtr=this;
1.216 +
1.217 + Screen()->WindowElements().SortByZOrder();
1.218 +
1.219 + MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
1.220 + if (windowTreeObserver)
1.221 + {
1.222 + if(changedWindowGroup && (WinType() == EWinTypeClient))
1.223 + {
1.224 + windowTreeObserver->MovedToWindowGroup(*this, *(this->WinGroup()));
1.225 + }
1.226 + else if(!changedWindowGroup)
1.227 + {
1.228 + windowTreeObserver->SiblingOrderChanged(*this, OrdinalPosition(ETrue));
1.229 + }
1.230 + else if(changedWindowGroup)
1.231 + {
1.232 + OwnerPanic(EWservPanicInvalidParameter); //Should be impossible to end up here as only WinType() EWinTypeClient
1.233 + } //and EWinTypeGroup can be moved to another windowgroup.
1.234 + } //@see RWindowBase::MoveToGroup
1.235 + }
1.236 +
1.237 +void CWsWindowBase::SetOrdinalPosition(TInt aPos)
1.238 + {
1.239 + if (CheckOrdinalPositionChange(aPos))
1.240 + ChangeWindowPosition(aPos,iParent);
1.241 + }
1.242 +
1.243 +TEventQueueWalkRet EventPurgeFunc(TAny *aPtr, TWsEvent *aEvent)
1.244 +//
1.245 +// Callback function for event queue walk
1.246 +//
1.247 + {
1.248 + return(((CWsWindowBase *)aPtr)->EventPurgeCheck(aEvent));
1.249 + }
1.250 +
1.251 +TEventQueueWalkRet CWsWindowBase::EventPurgeCheck(TWsEvent *aEvent)
1.252 + {
1.253 + if (aEvent->Handle()==ClientHandle())
1.254 + return(EEventQueueWalkDeleteEvent);
1.255 + return(EEventQueueWalkOk);
1.256 + }
1.257 +
1.258 +void CWsWindowBase::PurgeEvents()
1.259 + {
1.260 + iWsOwner->EventQueue()->WalkEventQueue(&EventPurgeFunc,this);
1.261 + }
1.262 +
1.263 +void CWsWindowBase::Shutdown()
1.264 +//
1.265 +// Destroy a window, disconnects from the window tree and destroys all it's child windows
1.266 +//
1.267 + {
1.268 + if (iWsOwner!=NULL)
1.269 + PurgeEvents();
1.270 + if (iParent!=NULL) // Check it's connected to something
1.271 + {
1.272 + CWsWindowBase *win;
1.273 + for(win=this;win && win->iParent!=(CWsWindowBase *)RootWindow();win=win->iParent)
1.274 + {}
1.275 + RemoveFromSiblingList();
1.276 + TWalkWindowTreeDisconnect wwt2(win ? ((CWsWindowGroup *)win)->TextCursor() : NULL);
1.277 + WalkWindowTree(wwt2,EWalkChildren); // Disconnect all child windows
1.278 + iChild=NULL;
1.279 + }
1.280 + TWindowServerEvent::RemoveFromSwitchOnEventList(*this);
1.281 + TWindowServerEvent::RemoveFromErrorMessageList(*this);
1.282 + TWindowServerEvent::RemoveFromGroupChangeEventEventList(*this);
1.283 + TWindowServerEvent::RemoveFromFocusChangeEventEventList(*this);
1.284 + TWindowServerEvent::RemoveFromGroupListChangeEventEventList(*this);
1.285 + TWindowServerEvent::RemoveFromModifierChangedEventList(*this);
1.286 + TWindowServerEvent::RemoveFromScreenDeviceChangeEventList(*this);
1.287 + CWsTop::StopWindowGettingOffEvents(this);
1.288 + }
1.289 +
1.290 +TBool CWsWindowBase::CommandL(TInt aOpcode, TWsWinCmdUnion &aCmd)
1.291 +//
1.292 +// If the command is supported by the window base class process it and return ETrue
1.293 +// if it is not supported return EFalse
1.294 +//
1.295 + {
1.296 + switch(aOpcode)
1.297 + {
1.298 + case EWsWinOpFree:
1.299 + {
1.300 + delete this;
1.301 + break;
1.302 + }
1.303 + case EWsWinOpSetOrdinalPosition:
1.304 + SetOrdinalPosition(*aCmd.Int);
1.305 + break;
1.306 + case EWsWinOpOrdinalPriority:
1.307 + SetReply(iOrdinalPriority);
1.308 + break;
1.309 + case EWsWinOpOrdinalPosition:
1.310 + SetReply(OrdinalPosition(EFalse));
1.311 + break;
1.312 + case EWsWinOpFullOrdinalPosition:
1.313 + SetReply(OrdinalPosition(ETrue));
1.314 + break;
1.315 + case EWsWinOpClientHandle:
1.316 + SetReply(iClientHandle);
1.317 + break;
1.318 + case EWsWinOpParent:
1.319 + if (!iParent)
1.320 + {
1.321 + OwnerPanic(EWservPanicParentDeleted);
1.322 + }
1.323 + SetReply(iParent->iClientHandle);
1.324 + break;
1.325 + case EWsWinOpPrevSibling:
1.326 + {
1.327 + if (!iParent)
1.328 + {
1.329 + OwnerPanic(EWservPanicParentDeleted);
1.330 + }
1.331 + TUint32 reply=NULL;
1.332 + for(CWsWindowBase *win=this->GetPrevSibling();win;win=win->GetPrevSibling())
1.333 + {
1.334 + if (win->iWsOwner==iWsOwner)
1.335 + {
1.336 + reply=win->iClientHandle;
1.337 + break;
1.338 + }
1.339 + }
1.340 + SetReply(reply);
1.341 + }
1.342 + break;
1.343 + case EWsWinOpNextSibling:
1.344 + {
1.345 + TUint32 reply=NULL;
1.346 + for(CWsWindowBase *win=this->iSibling;win;win=win->iSibling)
1.347 + {
1.348 + if (win->iWsOwner==iWsOwner)
1.349 + {
1.350 + reply=win->iClientHandle;
1.351 + break;
1.352 + }
1.353 + }
1.354 + SetReply(reply);
1.355 + }
1.356 + break;
1.357 + case EWsWinOpChild:
1.358 + SetReply(iChild==NULL ? NULL : iChild->iClientHandle);
1.359 + break;
1.360 + case EWsWinOpScreenNumber:
1.361 + SetReply(Screen()->ScreenNumber());
1.362 + break;
1.363 + case EWsWinOpWindowGroupId:
1.364 + {
1.365 + TUint32 reply=NULL;
1.366 + CWsWindowGroup *wg=WinGroup();
1.367 + if (wg)
1.368 + {
1.369 + reply=wg->Identifier();
1.370 + }
1.371 + SetReply(reply);
1.372 + }
1.373 + break;
1.374 + case EWsWinOpEnableOnEvents:
1.375 + {
1.376 + const TEventControl circumstances = *aCmd.EventControl;
1.377 + TWindowServerEvent::AddToSwitchOnEventListL(*this, circumstances);
1.378 + if (iScreen->ChangeTracking())
1.379 + {
1.380 + if(circumstances & EEventControlOnlyWhenVisible)
1.381 + {
1.382 + TWalkWindowTreeSetupVisibleRegionTracking wwt(ETrue);
1.383 + WalkWindowTree(wwt, EWalkChildren);
1.384 + }
1.385 + }
1.386 + break;
1.387 + }
1.388 + case EWsWinOpDisableOnEvents:
1.389 + {
1.390 + TWindowServerEvent::RemoveFromSwitchOnEventList(*this);
1.391 + if (iScreen->ChangeTracking())
1.392 + {
1.393 + TWalkWindowTreeSetupVisibleRegionTracking wwt(EFalse);
1.394 + WalkWindowTree(wwt, EWalkChildren);
1.395 + }
1.396 + break;
1.397 + }
1.398 + case EWsWinOpEnableErrorMessages:
1.399 + {
1.400 + const TEventControl circumstances = *aCmd.EventControl;
1.401 + TWindowServerEvent::AddToErrorMessageListL(*this, circumstances);
1.402 + if (iScreen->ChangeTracking())
1.403 + {
1.404 + if(circumstances & EEventControlOnlyWhenVisible)
1.405 + {
1.406 + TWalkWindowTreeSetupVisibleRegionTracking wwt(ETrue);
1.407 + WalkWindowTree(wwt, EWalkChildren);
1.408 + }
1.409 + }
1.410 + break;
1.411 + }
1.412 + case EWsWinOpDisableErrorMessages:
1.413 + {
1.414 + TWindowServerEvent::RemoveFromErrorMessageList(*this);
1.415 + if (iScreen->ChangeTracking())
1.416 + {
1.417 + TWalkWindowTreeSetupVisibleRegionTracking wwt(EFalse);
1.418 + WalkWindowTree(wwt, EWalkChildren);
1.419 + }
1.420 + break;
1.421 + }
1.422 + case EWsWinOpEnableModifierChangedEvents:
1.423 + {
1.424 + const TInt modifierMask = aCmd.EnableModifierChangedEvents->modifierMask;
1.425 + const TEventControl circumstances = aCmd.EnableModifierChangedEvents->circumstances;
1.426 + TWindowServerEvent::AddToModifierChangedEventListL(*this, modifierMask, circumstances);
1.427 + if (iScreen->ChangeTracking())
1.428 + {
1.429 + if(circumstances & EEventControlOnlyWhenVisible)
1.430 + {
1.431 + TWalkWindowTreeSetupVisibleRegionTracking wwt(ETrue);
1.432 + WalkWindowTree(wwt, EWalkChildren);
1.433 + }
1.434 + }
1.435 + break;
1.436 + }
1.437 + case EWsWinOpDisableModifierChangedEvents:
1.438 + {
1.439 + TWindowServerEvent::RemoveFromModifierChangedEventList(*this);
1.440 + if (iScreen->ChangeTracking())
1.441 + {
1.442 + TWalkWindowTreeSetupVisibleRegionTracking wwt(EFalse);
1.443 + WalkWindowTree(wwt, EWalkChildren);
1.444 + }
1.445 + break;
1.446 + }
1.447 + case EWsWinOpEnableGroupChangeEvents:
1.448 + TWindowServerEvent::AddToGroupChangeEventListL(*this);
1.449 + break;
1.450 + case EWsWinOpDisableGroupChangeEvents:
1.451 + TWindowServerEvent::RemoveFromGroupChangeEventEventList(*this);
1.452 + break;
1.453 + case EWsWinOpEnableFocusChangeEvents:
1.454 + TWindowServerEvent::AddToFocusChangeEventListL(*this);
1.455 + break;
1.456 + case EWsWinOpDisableFocusChangeEvents:
1.457 + TWindowServerEvent::RemoveFromFocusChangeEventEventList(*this);
1.458 + break;
1.459 + case EWsWinOpEnableGroupListChangeEvents:
1.460 + TWindowServerEvent::AddToGroupListChangeEventListL(*this);
1.461 + break;
1.462 + case EWsWinOpDisableGroupListChangeEvents:
1.463 + TWindowServerEvent::RemoveFromGroupListChangeEventEventList(*this);
1.464 + break;
1.465 + case EWsWinOpSetCustomPointerCursor:
1.466 + CWsObject *pointercursor;
1.467 + if ((pointercursor=iWsOwner->HandleToObj(*aCmd.Int, WS_HANDLE_POINTER_CURSOR))==NULL)
1.468 + OwnerPanic(EWservPanicSprite);
1.469 + SetPointerCursor((CWsPointerCursor *)pointercursor);
1.470 + break;
1.471 + case EWsWinOpSetPointerCursor:
1.472 + SetPointerCursorByIndex(*aCmd.UInt);
1.473 + break;
1.474 + case EWsWinOpClearPointerCursor:
1.475 + SetPointerCursor(NULL);
1.476 + break;
1.477 + case EWsWinOpSetNonFading:
1.478 + {
1.479 + WS_ASSERT_DEBUG(iScreen, EWsPanicNoScreen);
1.480 + // No fading will occur from a graphical perspective, but the fade counts
1.481 + // are maintained for BC reasons.
1.482 + TWalkWindowTreeSetNonFading wwt(*aCmd.Bool);
1.483 + WalkWindowTree(wwt,EWalkChildren);
1.484 + }
1.485 + break;
1.486 + case EWsWinOpSetFade:
1.487 + {
1.488 + WS_ASSERT_DEBUG(iScreen, EWsPanicNoScreen);
1.489 +
1.490 + TUint8 blackMap;
1.491 + TUint8 whiteMap;
1.492 + if (aCmd.SetFaded->UseDefaultMap())
1.493 + {
1.494 + iScreen->GetFadingParams(blackMap,whiteMap);
1.495 + }
1.496 + else
1.497 + {
1.498 + aCmd.SetFaded->GetFadingParams(blackMap,whiteMap);
1.499 + }
1.500 +
1.501 + if (aCmd.SetFaded->IncludeChildren())
1.502 + {
1.503 + TWalkWindowTreeSetFaded wwt(aCmd.SetFaded->Faded(),this,blackMap,whiteMap);
1.504 + WalkWindowTree(wwt,EWalkChildren);
1.505 + }
1.506 + else
1.507 + {
1.508 + if (iWinType==EWinTypeGroup)
1.509 + OwnerPanic(EWservPanicOpcode);
1.510 +
1.511 + const TBool KNotifyObserver = ETrue; //yes please
1.512 + const TBool KFaded = aCmd.SetFaded->Faded();
1.513 + static_cast<CWsClientWindow*>(this)->SetFaded(KFaded, blackMap, whiteMap, KNotifyObserver);
1.514 + }
1.515 + }
1.516 + break;
1.517 + case EWsWinOpEnableAdvancedPointers:
1.518 + if(!IsActivated())
1.519 + {
1.520 + // Must call this BEFORE activating the window.
1.521 + iBaseWinFlags |= EBaseWinAdvancedPointersEnabled;
1.522 + }
1.523 + else
1.524 + {
1.525 + // Called after activation, so panic the client.
1.526 + OwnerPanic(EWservPanicUnableToEnableAdvPointer);
1.527 + }
1.528 + break;
1.529 + case EWsWinOpSetSurfaceTransparency:
1.530 + RDebug::Printf("[Bug 3343] OpCode EWsWinOpSetSurfaceTransparency not supported.");
1.531 + break;
1.532 + default:
1.533 + return(EFalse);
1.534 + }
1.535 + return(ETrue);
1.536 + }
1.537 +
1.538 +/** @see MWsWindowTreeNode */
1.539 +MWsWindowTreeNode::TType CWsWindowBase::NodeType() const
1.540 + {
1.541 + return static_cast<MWsWindowTreeNode::TType>(iWinType); //TWinType is a subset of MWsWindowTreeNode::TType
1.542 + }
1.543 +
1.544 +/** @see MWsWindowTreeNode */
1.545 +const MWsWindow* CWsWindowBase::Window() const
1.546 + {
1.547 + return (iWinType!=EWinTypeGroup) ? (static_cast<const CWsWindow*>(this)) : NULL;
1.548 + }
1.549 +
1.550 +/** @see MWsWindowTreeNode */
1.551 +const MWsSprite* CWsWindowBase::Sprite() const
1.552 + {
1.553 + return NULL;
1.554 + }
1.555 +
1.556 +/** @see MWsWindowTreeNode */
1.557 +const MWsStandardTextCursor* CWsWindowBase::StandardTextCursor() const
1.558 + {
1.559 + return NULL;
1.560 + }
1.561 +
1.562 +/** @see MWsWindowTreeNode */
1.563 +const MWsWindowGroup* CWsWindowBase::WindowGroup() const
1.564 + {
1.565 + return static_cast<MWsWindowGroup*>(WinGroup());
1.566 + }
1.567 +
1.568 +/** @see MWsWindowTreeNode */
1.569 +const MWsWindowTreeNode* CWsWindowBase::ParentNode() const
1.570 + {
1.571 + return iParent;
1.572 + }
1.573 +
1.574 +TBool CWsWindowBase::QueueEvent(TInt aEvent, TInt aIntVal) const
1.575 + {
1.576 + if (WsOwner())
1.577 + return(WsOwner()->EventQueue()->QueueEvent(iClientHandle, aEvent, aIntVal));
1.578 + return(EFalse);
1.579 + }
1.580 +
1.581 +void CWsWindowBase::SetPointerCursorByIndex(TInt aIndex)
1.582 + {
1.583 + SetPointerCursor(CWsClient::SystemPointerCursor(aIndex));
1.584 + }
1.585 +
1.586 +void CWsWindowBase::SetPointerCursor(CWsPointerCursor *aCursor)
1.587 + {
1.588 + CWsPointerCursor *old=iPointerCursor;
1.589 + iPointerCursor=aCursor;
1.590 + if (iPointerCursor)
1.591 + iPointerCursor->Open();
1.592 + TWsPointer::UpdatePointerCursor();
1.593 + if (old)
1.594 + old->Close();
1.595 + }
1.596 +
1.597 +TBool CWsWindowBase::TreeIsObscured() const
1.598 + {
1.599 + TBool result;
1.600 + TWalkWindowTreeIsObscured wwt(result);
1.601 + CONST_CAST(CWsWindowBase *,this)->WalkWindowTree(wwt,EWalkChildren);
1.602 + return(result);
1.603 + }
1.604 +
1.605 +CEventQueue *CWsWindowBase::EventQueue() const
1.606 + {
1.607 + CEventQueue* eventQueue = NULL;
1.608 + if (iWsOwner)
1.609 + eventQueue = iWsOwner->EventQueue();
1.610 + return eventQueue;
1.611 + }
1.612 +
1.613 +TInt CWsWindowBase::Depth() const
1.614 + {
1.615 + TInt count=0;
1.616 + const CWsWindowBase *win=this;
1.617 + while (win->WinType()!=EWinTypeRoot)
1.618 + {
1.619 + ++count;
1.620 + win=win->iParent;
1.621 + }
1.622 + return(count);
1.623 + }
1.624 +
1.625 +void CWsWindowBase::WalkWindowTree(TWalkWindowTreeBase &aWalkClass,TWalkMode aMode)
1.626 +//
1.627 +// Walks windows in a front to back order
1.628 +//
1.629 +// If mode is EWalkBehind
1.630 +// call DoIt for all windows that are behind 'this'
1.631 +// else if mode is EWalkChildren
1.632 +// call DoIt for all descendents
1.633 +// else if mode is EWalkChildrenAndBehind
1.634 +// call DoIt for for all descendents and windows behind
1.635 +//
1.636 + {
1.637 + if (this!=NULL)
1.638 + {
1.639 + CWsWindowBase *win=this;
1.640 + CWsWindowBase *end=RootWindow();
1.641 + CWsWindowBase *sibling=win->iSibling;
1.642 + CWsWindowBase *parent=win->iParent;
1.643 + if (aMode!=EWalkBehind)
1.644 + {
1.645 + if (aMode==EWalkChildren)
1.646 + end=win;
1.647 + goto start;
1.648 + }
1.649 + do
1.650 + {
1.651 + if (sibling!=NULL)
1.652 + {
1.653 + win=sibling;
1.654 +start: while(win->iChild!=NULL)
1.655 + win=win->iChild;
1.656 + }
1.657 + else
1.658 + win=parent;
1.659 + sibling=win->iSibling; // De-reference win so it can be destroyed by 'DoIt'
1.660 + parent=win->iParent;
1.661 + if (win->iWinType!=EWinTypeGroup && aWalkClass.DoIt((CWsWindow *)win))
1.662 + return;
1.663 + } while(win!=end);
1.664 + }
1.665 + }
1.666 +
1.667 +/* Walks windows in a front to back order
1.668 +
1.669 + If aResume is EFalse the walk is identical to above.
1.670 + Otherwise iWin is taken as the restart point, (any child windows will have been
1.671 + walked previously).
1.672 + */
1.673 +void CWsWindowBase::WalkWindowTree(TResumableWalkWindowTreeBase& aWalkClass, TWalkMode aMode, TBool aResume)
1.674 + {
1.675 + if (this != NULL)
1.676 + { // init
1.677 + if (!aResume)
1.678 + {
1.679 + aWalkClass.iWin = this;
1.680 + aWalkClass.iEnd = (aMode == EWalkChildren) ? this : RootWindow();
1.681 + aWalkClass.iParent = aWalkClass.iWin->iParent;
1.682 + if (aMode == EWalkBehind)
1.683 + {
1.684 + aWalkClass.iNextChild = aWalkClass.iWin->iSibling;
1.685 + }
1.686 + else
1.687 + { // ensure walk includes this and its child windows
1.688 + aWalkClass.iNextChild = this;
1.689 + }
1.690 + }
1.691 + else if (aWalkClass.iWin == aWalkClass.iEnd)
1.692 + {
1.693 + return; // walk had already reached end
1.694 + }
1.695 +
1.696 + do
1.697 + {
1.698 + if (aWalkClass.iNextChild != NULL)
1.699 + { // walk down tree to a leaf window
1.700 + aWalkClass.iWin = aWalkClass.iNextChild;
1.701 + while (aWalkClass.iWin->iChild != NULL)
1.702 + {
1.703 + aWalkClass.iWin = aWalkClass.iWin->iChild;
1.704 + }
1.705 + }
1.706 + else
1.707 + { // walk up tree
1.708 + aWalkClass.iWin = aWalkClass.iParent;
1.709 + }
1.710 + // De-reference iWin so it can be destroyed by 'DoIt'
1.711 + aWalkClass.iNextChild = aWalkClass.iWin->iSibling;
1.712 + aWalkClass.iParent = aWalkClass.iWin->iParent;
1.713 + if ( ( aWalkClass.iWin->iWinType != EWinTypeGroup ) && aWalkClass.DoIt(static_cast<CWsWindow *>(aWalkClass.iWin)) )
1.714 + {
1.715 + return;
1.716 + }
1.717 + }
1.718 + while (aWalkClass.iWin != aWalkClass.iEnd);
1.719 + }
1.720 + }
1.721 +
1.722 +void CWsWindowBase::WalkWindowTreeBackToFront(TWalkWindowTreeBase &aWalkClass, TWalkModeBackToFront aMode)
1.723 + {
1.724 + // Walks windows in a back to front order
1.725 + //
1.726 + // If mode is EVisitParentNodesFirst
1.727 + // call DoIt() on each node before walking their child windows.
1.728 +
1.729 + if(iSibling)
1.730 + iSibling->WalkWindowTreeBackToFront(aWalkClass,aMode);
1.731 +
1.732 + if(aMode == EVisitParentNodesFirst)
1.733 + aWalkClass.DoIt(static_cast<CWsWindow *>(this));
1.734 +
1.735 + if(iChild)
1.736 + iChild->WalkWindowTreeBackToFront(aWalkClass,aMode);
1.737 +
1.738 + }
1.739 +
1.740 +TBool CWsWindowBase::IsDSAHost() const
1.741 + {
1.742 + return EFalse;
1.743 + }
1.744 +
1.745 +TBool CWsWindowBase::IsActivated() const
1.746 + {
1.747 + return EFalse;
1.748 + }
1.749 +
1.750 +void CWsWindowBase::AddSprite(CWsSpriteBase * aSprite)
1.751 + {
1.752 + aSprite->SetNext(iSpriteList);
1.753 + iSpriteList = aSprite;
1.754 + }
1.755 +
1.756 +void CWsWindowBase::RemoveSprite(CWsSpriteBase * aSprite)
1.757 + {
1.758 + if (aSprite == iSpriteList)
1.759 + {
1.760 + iSpriteList = aSprite->Next();
1.761 + }
1.762 + else
1.763 + {
1.764 + for (CWsSpriteBase * sprite = iSpriteList; sprite; sprite = sprite->Next())
1.765 + {
1.766 + if (sprite->Next() == aSprite)
1.767 + {
1.768 + sprite->SetNext(aSprite->Next());
1.769 + }
1.770 + }
1.771 + }
1.772 + aSprite->SetNext(0);
1.773 + }
1.774 +
1.775 +void CWsWindowBase::SendState(MWsWindowTreeObserver& aWindowTreeObserver) const
1.776 + {
1.777 + //Sprites
1.778 + if(iSpriteList)
1.779 + iSpriteList->SendState(aWindowTreeObserver);
1.780 + }
1.781 +
1.782 +#if defined(_DEBUG)
1.783 +
1.784 +void CWsWindowBase::CheckTree()
1.785 + {
1.786 + TWalkWindowTreeCheck wwt1;
1.787 + WalkWindowTree(wwt1,EWalkChildren);
1.788 + }
1.789 +
1.790 +enum {ENullWsHandle=0xFFFFFFFF}; // Events delivered to this handle are thrown away
1.791 +TBool CWsWindowBase::IsClientHandleInUse(TUint32 aHandle)
1.792 + {
1.793 + if (aHandle==static_cast<TUint>(ENullWsHandle)) //This value has a special meaning in test code
1.794 + return EFalse;
1.795 + CWsObjectIx* index=iWsOwner->ObjectIndex();
1.796 + const CWsObject* obj;
1.797 + TInt length=index->Length();
1.798 + TInt ii;
1.799 + for (ii=0;ii<length;++ii)
1.800 + {
1.801 + obj=index->At(ii);
1.802 + if (obj && (obj->Type()==WS_HANDLE_WINDOW || obj->Type()==WS_HANDLE_GROUP_WINDOW))
1.803 + {
1.804 + if (STATIC_CAST(const CWsWindowBase*,obj)->ClientHandle()==aHandle)
1.805 + return ETrue;
1.806 + }
1.807 + }
1.808 + return EFalse;
1.809 + }
1.810 +
1.811 +#endif