1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/graphics/windowing/windowserver/nga/SERVER/openwfc/cliwin.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1482 @@
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 +// Client window functions
1.18 +//
1.19 +//
1.20 +
1.21 +#include "W32CLICK.H"
1.22 +#include <graphics/wselement.h>
1.23 +#include "server.h"
1.24 +#include "cliwin.h"
1.25 +#include "gc.h"
1.26 +#include "rootwin.h"
1.27 +#include "windowgroup.h"
1.28 +#include "walkwindowtree.h"
1.29 +#include "ScrDev.H"
1.30 +#include "wstop.h"
1.31 +#include "EVQUEUE.H"
1.32 +#include "KEYCLICK.H"
1.33 +#include "panics.h"
1.34 +#include "password.h"
1.35 +#include "pointer.h"
1.36 +#include "EVENT.H"
1.37 +#include "backedupwindow.h"
1.38 +#include "redrawmsgwindow.h"
1.39 +#include "ANIM.H"
1.40 +
1.41 +#include "windowelementset.h"
1.42 +
1.43 +
1.44 +
1.45 +
1.46 +TBool CWsClientWindow::iAbsoluteFading = EFalse;
1.47 +
1.48 +const TPoint corner1[1]={TPoint(1,1)};
1.49 +const TPoint corner2[2]={TPoint(2,1),TPoint(1,1)};
1.50 +const TPoint corner3[2]={TPoint(3,1),TPoint(1,2)};
1.51 +const TPoint corner5[4]={TPoint(5,1),TPoint(3,1),TPoint(2,1),TPoint(1,2)};
1.52 +
1.53 +/*CWsClientWindow*/
1.54 +
1.55 +CWsClientWindow::CWsClientWindow(CWsClient* aOwner, CScreen* aScreen) : CWsWindow(aOwner,WS_HANDLE_WINDOW,aScreen)
1.56 + {
1.57 + iWinType=EWinTypeClient;
1.58 + }
1.59 +
1.60 +void CWsClientWindow::ConstructL(const TWsClCmdCreateWindow &aCmd, CWsWindowBase *aParent, TBool aScreenDeviceIsInvalid)
1.61 + {
1.62 + CWsWindow::Construct();
1.63 + NewObjL();
1.64 + if (aCmd.clientHandle==NULL)
1.65 + OwnerPanic(EWservPanicNullHandle);
1.66 +#if defined(_DEBUG)
1.67 + if (IsClientHandleInUse(aCmd.clientHandle))
1.68 + OwnerPanic(EWservPanicDuplicateHandle);
1.69 +#endif
1.70 + iPointerFilter=EPointerFilterEnterExit|EPointerFilterMove|EPointerFilterDrag;
1.71 + iClientHandle=aCmd.clientHandle;
1.72 + CWsWindow* inherit=static_cast<CWsWindow *>(aParent);
1.73 + if (aParent->WinType()==EWinTypeGroup)
1.74 + inherit=RootWindow();
1.75 + SetPointerCursor(aParent->PointerCursor());
1.76 + iAbs=inherit->Abs();
1.77 + iOrigin=aParent->Origin();
1.78 + iRel.iBr.iX=inherit->Rel().iBr.iX-inherit->Rel().iTl.iX;
1.79 + iRel.iBr.iY=inherit->Rel().iBr.iY-inherit->Rel().iTl.iY;
1.80 + switch(aCmd.type)
1.81 + {
1.82 + case EWinRedraw:
1.83 + iRedraw=new(ELeave) CWsRedrawMsgWindow(this);
1.84 + break;
1.85 + case EWinBackedUp:
1.86 + iRedraw=new(ELeave) CWsBackedUpWindow(this, aCmd.displayMode);
1.87 + iAbs.iBr=iAbs.iTl;
1.88 + iRel.iBr=iRel.iTl;
1.89 + break;
1.90 + case EWinBlank:
1.91 + iRedraw=new(ELeave) CWsBlankWindow(this);
1.92 + break;
1.93 + default:
1.94 + OwnerPanic(EWservPanicRedrawType);
1.95 + }
1.96 + ResetHiddenFlag();
1.97 + SetCornerTypeL(EWindowCornerSquare,0,NULL,EFalse);
1.98 + CWsWindowBase::ConstructL(aParent);
1.99 + if (aScreenDeviceIsInvalid)
1.100 + {
1.101 + iFlags|=EFlagScreenDeviceInvalid;
1.102 + ResetHiddenFlag();
1.103 + }
1.104 + iRedraw->ConstructL();
1.105 + }
1.106 +
1.107 +void CWsClientWindow::GetBaseAreaOfNode(RWsRegion &aRegion) const
1.108 + {
1.109 + if (iBaseArea)
1.110 + {
1.111 + aRegion.Copy(*iBaseArea);
1.112 + }
1.113 + aRegion.ClipRect(iAbs);
1.114 + }
1.115 +
1.116 +void CWsClientWindow::ClipRegionToBaseArea(RWsRegion &aRegion) const
1.117 + {
1.118 + if (iBaseArea)
1.119 + {
1.120 + aRegion.Intersect(*iBaseArea);
1.121 + }
1.122 + aRegion.ClipRect(iAbs);
1.123 + }
1.124 +
1.125 +void CWsClientWindow::GetClippedBaseArea(RWsRegion &aRegion) const
1.126 + {
1.127 + const CWsWindowBase* ancestor = BaseParent();
1.128 + GetBaseAreaOfNode(aRegion);
1.129 + while (ancestor && ancestor->WinType() == EWinTypeClient)
1.130 + {
1.131 + static_cast<const CWsClientWindow*>(ancestor)->ClipRegionToBaseArea(aRegion);
1.132 + ancestor = ancestor->BaseParent();
1.133 + }
1.134 + }
1.135 +
1.136 +void CWsClientWindow::GetOpaqueBaseAreaOfNode(RWsRegion &aRegion) const
1.137 + {
1.138 + if (IsTranslucent())
1.139 + {
1.140 + if (iUserDefinedOpaqueRegion)
1.141 + {
1.142 + aRegion.Copy(*iUserDefinedOpaqueRegion);
1.143 + aRegion.ClipRect(iAbs);
1.144 + }
1.145 + else
1.146 + {
1.147 + aRegion.Clear();
1.148 + }
1.149 + }
1.150 + else
1.151 + {
1.152 + GetBaseAreaOfNode(aRegion);
1.153 + }
1.154 + }
1.155 +
1.156 +void CWsClientWindow::ClipRegionToOpaqueBaseArea(RWsRegion& aRegion) const
1.157 + {
1.158 + if (IsTranslucent())
1.159 + {
1.160 + if (iUserDefinedOpaqueRegion)
1.161 + {
1.162 + aRegion.Intersect(*iUserDefinedOpaqueRegion);
1.163 + aRegion.ClipRect(iAbs);
1.164 + }
1.165 + else
1.166 + {
1.167 + aRegion.Clear();
1.168 + }
1.169 + }
1.170 + else
1.171 + {
1.172 + ClipRegionToBaseArea(aRegion);
1.173 + }
1.174 + }
1.175 +
1.176 +void CWsClientWindow::GetOpaqueClippedBaseArea(RWsRegion &aRegion) const
1.177 + {
1.178 + const CWsWindowBase* ancestor = BaseParent();
1.179 + GetOpaqueBaseAreaOfNode(aRegion);
1.180 + while (ancestor && ancestor->WinType() == EWinTypeClient)
1.181 + {
1.182 + static_cast<const CWsClientWindow*>(ancestor)->ClipRegionToOpaqueBaseArea(aRegion);
1.183 + ancestor = ancestor->BaseParent();
1.184 + }
1.185 + }
1.186 +
1.187 +TInt CWsClientWindow::GetNonOpaqueBaseAreaOfNode(RWsRegion &aRegion) const
1.188 + {
1.189 + aRegion.Clear();
1.190 + if (IsTranslucent())
1.191 + {
1.192 + if(iUserDefinedTransparentRegion)
1.193 + {
1.194 + aRegion.Copy(*iUserDefinedTransparentRegion);
1.195 + aRegion.ClipRect(iAbs);
1.196 + return KErrNone;
1.197 + }
1.198 + }
1.199 + return KErrNotFound;
1.200 + }
1.201 +
1.202 +void CWsClientWindow::ResetHiddenFlag()
1.203 +//
1.204 +// Reset the status of the hidden flag based on the current states of the active and invisible flags
1.205 +//
1.206 + {
1.207 + CWsClientWindow *parent=static_cast<CWsClientWindow*>(iParent);
1.208 +
1.209 + TBool wasHidden = iFlags&EFlagHidden;
1.210 + TBool nowHidden = (parent==NULL ||
1.211 + (parent->WinType()==EWinTypeClient && !parent->IsVisible()) ||
1.212 + !(iFlags&EFlagActive) ||
1.213 + (iFlags&EFlagInvisible) ||
1.214 + (iFlags&EFlagScreenDeviceInvalid));
1.215 +
1.216 + if (nowHidden)
1.217 + {
1.218 + iFlags|=EFlagHidden;
1.219 + iFlags&=~EFlagDrawnToScreen;
1.220 + }
1.221 + else
1.222 + {
1.223 + iFlags&=~EFlagHidden;
1.224 + }
1.225 + if ((!nowHidden) != (!wasHidden))
1.226 + {
1.227 + // intentionally call the screen directly
1.228 + iScreen->ScheduleRegionUpdate(&iVisibleRegion);
1.229 +
1.230 + WS_ASSERT_DEBUG(!iDirtyWindowRegion.CheckError(),EWsPanicErrorInRegion);
1.231 + WS_ASSERT_DEBUG(!iDirtySpriteRegion.CheckError(),EWsPanicErrorInRegion);
1.232 + // WS_ASSERT_DEBUG(!InvalidArea().CheckError(),EWsPanicErrorInRegion); //error flag in invalid area may be set in OOM cases
1.233 + //thus the assert statement is caused to fail
1.234 + if (wasHidden && iScreen->ChangeTracking() &&
1.235 + (!iDirtyWindowRegion.IsEmpty() || !iDirtySpriteRegion.IsEmpty() || !InvalidArea().IsEmpty()))
1.236 + {
1.237 + // Window has just become visible, schedule it
1.238 + iScreen->ScheduleWindow(this);
1.239 + }
1.240 + }
1.241 + }
1.242 +
1.243 +void CWsClientWindow::ResetHiddenFlags()
1.244 + {
1.245 + CWsClientWindow *win=this;
1.246 + FOREVER
1.247 + {
1.248 + TUint oldHiddenFlag=win->iFlags&EFlagHidden;
1.249 + win->ResetHiddenFlag();
1.250 + if ((win->iFlags&EFlagHidden)!=oldHiddenFlag) // If hidden status hasn't changed nothing to do
1.251 + {
1.252 + win->SetElementOpacity(IsVisible() ? 0xFF : 0x00); // Update element visibility
1.253 + if (win->Child())
1.254 + {
1.255 + win=win->Child();
1.256 + continue;
1.257 + }
1.258 + }
1.259 + if (win==this)
1.260 + return;
1.261 + while(!win->NextSibling())
1.262 + {
1.263 + win=(CWsClientWindow *)win->BaseParent();
1.264 + if (win==this)
1.265 + return;
1.266 + }
1.267 + win=win->NextSibling();
1.268 + } // for loop ends
1.269 + }
1.270 +
1.271 +void CWsClientWindow::OffsetBaseArea(const TPoint &aOffset)
1.272 + {
1.273 + iBaseArea->Offset(aOffset);
1.274 + //If the given window's position changes, then update.
1.275 + if (aOffset.iX || aOffset.iY)
1.276 + {
1.277 + UpdateElementExtent(&aOffset);
1.278 + }
1.279 + }
1.280 +
1.281 +void CWsClientWindow::CalcBaseArea()
1.282 +//
1.283 +// The windows basic area before any clipping is done
1.284 +//
1.285 + {
1.286 + TInt cornerType=iCornerData&ECornerTypeMask;
1.287 + if (cornerType==EWindowCornerRegion)
1.288 + iBaseArea->ClipRect(FullRect());
1.289 + else
1.290 + {
1.291 + TSize size=Size();
1.292 + iBaseArea->Clear();
1.293 + const TPoint *corners=NULL;
1.294 + TInt count=0;
1.295 + switch(cornerType)
1.296 + {
1.297 + case EWindowCorner1:
1.298 + count=sizeof(corner1)/sizeof(TPoint);
1.299 + corners=corner1;
1.300 + break;
1.301 + case EWindowCorner2:
1.302 + count=sizeof(corner2)/sizeof(TPoint);
1.303 + corners=corner2;
1.304 + break;
1.305 + case EWindowCorner3:
1.306 + count=sizeof(corner3)/sizeof(TPoint);
1.307 + corners=corner3;
1.308 + break;
1.309 + case EWindowCorner5:
1.310 + count=sizeof(corner5)/sizeof(TPoint);
1.311 + corners=corner5;
1.312 + break;
1.313 + default:
1.314 + break;
1.315 + }
1.316 + TInt top=0;
1.317 + TInt bot=size.iHeight;
1.318 + for(TInt index=0;index<count;index++)
1.319 + {
1.320 + TInt xadjust=corners[index].iX;
1.321 + TInt yadjust=corners[index].iY;
1.322 + if ((iCornerData&(EWindowCornerNotTL|EWindowCornerNotTR))!=(EWindowCornerNotTL|EWindowCornerNotTR))
1.323 + {
1.324 + iBaseArea->AddRect(TRect(iCornerData&EWindowCornerNotTL?0:xadjust,top,
1.325 + size.iWidth-(iCornerData&EWindowCornerNotTR?0:xadjust),top+yadjust));
1.326 + top+=yadjust;
1.327 + }
1.328 + if ((iCornerData&(EWindowCornerNotBL|EWindowCornerNotBR))!=(EWindowCornerNotBL|EWindowCornerNotBR))
1.329 + {
1.330 + iBaseArea->AddRect(TRect(iCornerData&EWindowCornerNotBL?0:xadjust,bot-yadjust,
1.331 + size.iWidth-(iCornerData&EWindowCornerNotBR?0:xadjust),bot));
1.332 + bot-=yadjust;
1.333 + }
1.334 + }
1.335 + iBaseArea->AddRect(TRect(0,top,size.iWidth,bot));
1.336 + iBaseArea->Offset(Origin());
1.337 + iBaseArea->ClipRect(FullRect());
1.338 + iBaseArea->Sort();
1.339 + }
1.340 + }
1.341 +
1.342 +void CWsClientWindow::GenerateArea(RWsRegion &aArea, TBool aClipTranslucent) const
1.343 +//
1.344 +// Create the window area list.
1.345 +//
1.346 + {
1.347 + aArea.Clear();
1.348 + if (IsVisible())
1.349 + {
1.350 + aArea.Copy(*iBaseArea);
1.351 + aArea.ClipRect(iAbs);
1.352 + const CWsClientWindow *win=this;
1.353 + FOREVER
1.354 + {
1.355 + if (win->IsTopClientWindow())
1.356 + break;
1.357 + ClipWindows(aArea,(CWsClientWindow *)win->BaseParent()->BaseChild(),win,aClipTranslucent);
1.358 + win=(CWsClientWindow *)win->iParent;
1.359 + }
1.360 + TInt tidyCount=0;
1.361 + for(const CWsTopClientWindow *cwin=RootWindow()->FirstTopClientWindow();aArea.Count() && cwin!=win;cwin=cwin->NextSiblingMultiParent())
1.362 + {
1.363 + if (!tidyCount--)
1.364 + {
1.365 + aArea.Tidy();
1.366 + tidyCount=ETidyCountSetting; // Tidy every ETidyCountSetting times around
1.367 + }
1.368 + if (cwin->IsVisible())
1.369 + {
1.370 + if (cwin->IsTranslucent() && !aClipTranslucent)
1.371 + {
1.372 + if (cwin->iUserDefinedOpaqueRegion)
1.373 + {
1.374 + aArea.SubRegion(*cwin->iUserDefinedOpaqueRegion);
1.375 + }
1.376 + }
1.377 + else
1.378 + {
1.379 + aArea.SubRegion(*cwin->iBaseArea);
1.380 + }
1.381 + }
1.382 + }
1.383 + aArea.Tidy();
1.384 + }
1.385 + }
1.386 +
1.387 +void CWsClientWindow::ClipWindows(TRegion ®ion,const CWsClientWindow *start, const CWsClientWindow *end, TBool aClipTranslucent)
1.388 +//
1.389 +// Remove out of the region the opaque part of the abs rect of all the windows starting from 'start'
1.390 +// along the sibling list to (and not including) the end window.
1.391 +//
1.392 + {
1.393 + for(const CWsClientWindow *win=start;region.Count() && win!=end;win=win->NextSibling())
1.394 + {
1.395 + if (win->IsVisible())
1.396 + {
1.397 + if (win->IsTranslucent() && !aClipTranslucent)
1.398 + {
1.399 + if (win->iUserDefinedOpaqueRegion)
1.400 + {
1.401 + region.SubRegion(*win->iUserDefinedOpaqueRegion);
1.402 + }
1.403 + }
1.404 + else
1.405 + {
1.406 + region.SubRegion(*win->iBaseArea);
1.407 + }
1.408 + }
1.409 + }
1.410 + }
1.411 +
1.412 +void CWsClientWindow::GenerateTopRegion(RWsRegion& aRegion) const
1.413 + {
1.414 + GenerateArea(aRegion,ETrue);
1.415 + if (iChild)
1.416 + ClipWindows(aRegion,Child(),NULL,ETrue);
1.417 + }
1.418 +
1.419 +void CWsClientWindow::GenerateWindowRegion(RWsRegion &aRegion) const
1.420 +//
1.421 +// Calculate the windows clipping region without using the usual stored iArea or iRegion fields
1.422 +// this function is used by the screen backup code to calculate "what if" regions to work out
1.423 +// whether something would be visible if the backed up window didn't exist, on this basis we
1.424 +// don't want to modify the existing copies of iArea & iRegion.
1.425 +//
1.426 + {
1.427 + GenerateArea(aRegion,EFalse);
1.428 + if (iChild)
1.429 + ClipWindows(aRegion,Child(),NULL,EFalse);
1.430 + }
1.431 +
1.432 +const TRegion *CWsClientWindow::DrawingRegion()
1.433 + {
1.434 + return (&iRedraw->BaseDrawRegion());
1.435 + }
1.436 +
1.437 +void CWsClientWindow::RecalcChildAbs(const TPoint *aOffset)
1.438 + {
1.439 + CWsClientWindow *win=this;
1.440 + FOREVER
1.441 + {
1.442 + FOREVER
1.443 + {
1.444 + win->SetAbsFromRel();
1.445 + if (aOffset)
1.446 + win->OffsetBaseArea(*aOffset);
1.447 + if (win->Child()==NULL)
1.448 + break;
1.449 + win=win->Child();
1.450 + }
1.451 + FOREVER
1.452 + {
1.453 + if (win==this)
1.454 + return;
1.455 + if (win->NextSibling()!=NULL)
1.456 + {
1.457 + win=win->NextSibling();
1.458 + break;
1.459 + }
1.460 + win=(CWsClientWindow *)win->iParent; // The cast is safe as the loop is aborted when win==this
1.461 + }
1.462 + }
1.463 + }
1.464 +
1.465 +void CWsClientWindow::SetAbsFromRel()
1.466 + {
1.467 + iOrigin=iRel.iTl+iParent->Origin();
1.468 + iAbs=iRel;
1.469 + iAbs.Move(iParent->Origin());
1.470 + iAbs.Intersection(iParent->AbsRect());
1.471 + }
1.472 +
1.473 +void CWsClientWindow::SetExtentL(const TPoint *aPos,const TSize *aSize)
1.474 + {
1.475 + if (iParent==NULL)
1.476 + OwnerPanic(EWservPanicParentDeleted);
1.477 + TPoint offset = TPoint(0,0);
1.478 + TSize oldSize;
1.479 + TSize newSize;
1.480 + TBool sizeChanged = EFalse;
1.481 + TBool posChanged = EFalse;
1.482 +
1.483 + if (aPos)
1.484 + {
1.485 + offset = *aPos+iParent->Origin()-iOrigin;
1.486 + if (offset.iX != 0 || offset.iY != 0)
1.487 + {
1.488 + posChanged = ETrue;
1.489 + }
1.490 + }
1.491 +
1.492 + if (posChanged)
1.493 + {
1.494 + TWalkWindowTreeScheduleRedraws wwt;
1.495 + WalkWindowTree(wwt, EWalkChildren);
1.496 + }
1.497 +
1.498 + if (aSize)
1.499 + {
1.500 + newSize=*aSize;
1.501 + if (newSize.iWidth<0)
1.502 + newSize.iWidth=0;
1.503 + if (newSize.iHeight<0)
1.504 + newSize.iHeight=0;
1.505 + // This should be the only part of resizing that can fail
1.506 + // and it can only fail for backedup windows.
1.507 + iRedraw->PrepareForResizeL(newSize,oldSize);
1.508 + sizeChanged = *aSize != iRel.Size();
1.509 + }
1.510 +
1.511 + if (posChanged)
1.512 + {
1.513 + iRel.Move(offset);
1.514 + RecalcChildAbs(&offset); // Also calls UpdateElementExtent(offset)
1.515 + TWalkWindowTreeOffsetTransparentRegions offsetTransparent(offset);
1.516 + WalkWindowTree(offsetTransparent, EWalkChildren);
1.517 + }
1.518 +
1.519 + if (sizeChanged)
1.520 + {
1.521 + iRel.SetSize(newSize);
1.522 + RecalcChildAbs(NULL);
1.523 + CalcBaseArea();
1.524 + iRedraw->Resize(newSize,oldSize);
1.525 + if (Redraw()->HasElement())
1.526 + UpdateElementExtent();
1.527 + }
1.528 +
1.529 + if ((posChanged || sizeChanged) && Redraw()->HasElement())
1.530 + {
1.531 + TRect interSection(iParent->Origin(), iParent->Size());
1.532 + interSection.Intersection(FullRect());
1.533 + if (interSection == FullRect())
1.534 + {
1.535 + // There is no any clipping in this case
1.536 + interSection = TRect();
1.537 + }
1.538 + // Get the corresponding source rectangle for the element
1.539 + if (!iOriginalSrcElementRect.IsEmpty() && !iOriginalDestElementRect.IsEmpty() && !iAbs.IsEmpty())
1.540 + {
1.541 + MWsElement* element = Screen()->WindowElements().GetElementFromWindow(*this);
1.542 + if (element)
1.543 + {
1.544 + element->SetDestinationClippingRect(interSection);
1.545 + }
1.546 + }
1.547 + }
1.548 +
1.549 + if (posChanged || sizeChanged)
1.550 + {
1.551 + iRedraw->ClipInvalidRegion(TRect(iRel.Size()));
1.552 + iRedraw->Moved();
1.553 + ScheduleRegionUpdate(NULL);
1.554 + TWalkWindowTreeRecalcOpaque recalcOpaque;
1.555 + WalkWindowTree(recalcOpaque, EWalkChildren);
1.556 +
1.557 + MWsWindowTreeObserver* windowTreeObserver = Screen()->WindowTreeObserver();
1.558 + if (windowTreeObserver)
1.559 + {
1.560 + TRect rect = FullRect();
1.561 + windowTreeObserver->NodeExtentChanged(*this, rect);
1.562 +
1.563 + for (CWsAnim* anim = iAnimList; anim; anim = anim->Next())
1.564 + {
1.565 + windowTreeObserver->NodeExtentChanged(*anim, rect);
1.566 + }
1.567 + }
1.568 + }
1.569 + }
1.570 +
1.571 +
1.572 +void CWsClientWindow::GetElementFlipAndRotation(TBool& aElemetFlip, MWsElement::TElementRotation& aElemenetRotation)
1.573 + {
1.574 + MWsElement* element = Screen()->WindowElements().GetElementFromWindow(*this);
1.575 + if (element)
1.576 + {
1.577 + aElemetFlip = element->SourceFlipping();
1.578 + aElemenetRotation = element->SourceRotation();
1.579 + }
1.580 + }
1.581 +
1.582 +void CWsClientWindow::Scroll(const TRect &aClipRect, const TPoint &aOffset, const TRect &aRect)
1.583 + {
1.584 + if (iParent==NULL)
1.585 + OwnerPanic(EWservPanicParentDeleted);
1.586 +
1.587 +//
1.588 + iRedraw->Scroll(aClipRect, aOffset,aRect);
1.589 +//
1.590 + CWsTop::TriggerRedraws(RootWindow());
1.591 + }
1.592 +
1.593 +void CWsClientWindow::DeleteBaseArea()
1.594 + {
1.595 + WS_ASSERT_DEBUG(iBaseArea!=&nullRegion, EWsPanicRegionNull);
1.596 + if ((iCornerData&ECornerTypeMask)==EWindowCornerRegion)
1.597 + ((RWsRegion *)iBaseArea)->Destroy();
1.598 + else
1.599 + {
1.600 + delete iBaseArea;
1.601 + }
1.602 + iBaseArea=NULL;
1.603 + }
1.604 +
1.605 +CWsClientWindow::~CWsClientWindow()
1.606 + {
1.607 + while(iVisibleRegionTrackingCounter>0)
1.608 + {
1.609 + SetupVisibleRegionTracking(EFalse);
1.610 + }
1.611 + if (iBaseWinFlags&EBaseWinNodeCreated)
1.612 + {
1.613 + MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
1.614 + if (windowTreeObserver)
1.615 + {
1.616 + windowTreeObserver->NodeReleased(*this);
1.617 + iBaseWinFlags &= ~EBaseWinNodeCreated;
1.618 + }
1.619 + }
1.620 + Shutdown();
1.621 + SetUserTransparentRegion(0);
1.622 + CWsPassword::WindowDestroyed(this);
1.623 + }
1.624 +
1.625 +void CWsClientWindow::Shutdown()
1.626 +//
1.627 +// Destroy a window, disconnects from the window tree and destroys all it's child windows
1.628 +//
1.629 + {
1.630 + iFlags|=EFlagShutDownInProgress;
1.631 + if (CClick::IsHandler())
1.632 + {
1.633 + TWindowCloseData params;
1.634 + params.iClientHandle=iClientHandle;
1.635 + //if parent already shutdown (or disconnected) send 0
1.636 + params.iWindowGroupId = (iParent) ? WinGroup()->Identifier() : 0;
1.637 + CClick::OtherEvent(EEventWindowClose,¶ms);
1.638 + }
1.639 +
1.640 + RemoveAllKeyRects();
1.641 + while(iWinGcList)
1.642 + iWinGcList->Deactivate();
1.643 +//
1.644 + iFlags|=EFlagInvisible; // First make it invisble
1.645 + if (iParent) // In case window wasn't fully constructed
1.646 + ResetHiddenFlags();
1.647 +//
1.648 + CWsWindow::Shutdown();
1.649 + DeleteBaseArea();
1.650 + CWsPointerBuffer::Disconnect(this);
1.651 + iFlags&=~EFlagShutDownInProgress;
1.652 + }
1.653 +
1.654 +void CWsClientWindow::Activate()
1.655 + {
1.656 + if (iFlags&EFlagActive)
1.657 + OwnerPanic(EWservPanicWindowActive);
1.658 + iFlags|=EFlagActive;
1.659 +
1.660 + ResetHiddenFlags();
1.661 +
1.662 + MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
1.663 + if (windowTreeObserver)
1.664 + {
1.665 + windowTreeObserver->NodeExtentChanged(*this, FullRect());
1.666 + windowTreeObserver->NodeActivated(*this);
1.667 + }
1.668 + }
1.669 +
1.670 +TBool CWsClientWindow::IsActivated() const
1.671 + {
1.672 + return (iFlags&EFlagActive)!=EFalse;
1.673 + }
1.674 +
1.675 +void CWsClientWindow::SetCornerTypeL(TCornerType aCornerType, TInt aCornerFlags, TRegion *aNewBaseArea, TBool aNotifyShapeChanged)
1.676 + {
1.677 + TRegion *baseArea=NULL;
1.678 + if (aCornerFlags&ECornerTypeMask)
1.679 + OwnerPanic(EWservPanicCornerParams);
1.680 +
1.681 + switch (aCornerType)
1.682 + {
1.683 + case EWindowCornerSquare:
1.684 + baseArea=new(ELeave) TRegionFix<1>();
1.685 + break;
1.686 + case EWindowCorner1:
1.687 + baseArea=new(ELeave) TRegionFix<3>();
1.688 + break;
1.689 + case EWindowCorner2:
1.690 + case EWindowCorner3:
1.691 + baseArea=new(ELeave) TRegionFix<5>();
1.692 + break;
1.693 + case EWindowCorner5:
1.694 + baseArea=new(ELeave) TRegionFix<9>();
1.695 + break;
1.696 + case EWindowCornerRegion:
1.697 + User::LeaveIfNull(baseArea=aNewBaseArea);
1.698 + baseArea->Offset(Origin());
1.699 + break;
1.700 + default:
1.701 + OwnerPanic(EWservPanicCornerParams);
1.702 + }
1.703 + DeleteBaseArea();
1.704 + iCornerData=aCornerType;
1.705 + iCornerData|=aCornerFlags;
1.706 + iBaseArea=baseArea;
1.707 + CalcBaseArea();
1.708 + ScheduleRegionUpdate(NULL);
1.709 +
1.710 + if ( aNotifyShapeChanged )
1.711 + {
1.712 + MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
1.713 + if (windowTreeObserver)
1.714 + {
1.715 + windowTreeObserver->AttributeChanged(*this, MWsWindowTreeObserver::EWindowShape);
1.716 + }
1.717 + }
1.718 + }
1.719 +
1.720 +void CWsClientWindow::SetVisible(TBool aState)
1.721 + {
1.722 + if (aState)
1.723 + {
1.724 + if (iParent==NULL)
1.725 + OwnerPanic(EWservPanicParentDeleted);
1.726 + if (!(iFlags&EFlagInvisible)) // Already visible
1.727 + return;
1.728 + iFlags&=~EFlagInvisible;
1.729 + ResetHiddenFlags();
1.730 + }
1.731 + else
1.732 + {
1.733 + if (iFlags&EFlagInvisible || !iParent) // Already invisible or parent has been deleted
1.734 + return;
1.735 + TWalkWindowTreePurgeEvents wwt;
1.736 + WalkWindowTree(wwt,EWalkChildren); // Destroy all events on this and all children
1.737 + iFlags|=EFlagInvisible;
1.738 + ResetHiddenFlags();
1.739 + }
1.740 +
1.741 + MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
1.742 + if (windowTreeObserver)
1.743 + {
1.744 + windowTreeObserver->FlagChanged(*this, MWsWindowTreeObserver::EVisible, aState);
1.745 + }
1.746 + }
1.747 +
1.748 +void CWsClientWindow::CommandL(TInt aOpcode, const TAny *aCmdData)
1.749 + {
1.750 +#ifdef _DEBUG
1.751 + // Save root window for performing CheckTree at the end of this func.
1.752 + // When aOpcode is EWsWinOpFree, this object would've been destroyed
1.753 + // and a call to RootWindow() in that case would be impossible
1.754 + CWsRootWindow* rootWindow=RootWindow();
1.755 +#endif
1.756 + TWsWinCmdUnion pData;
1.757 + pData.any=aCmdData;
1.758 + if (CWsWindowBase::CommandL(aOpcode,pData)==EFalse)
1.759 + {
1.760 + switch(aOpcode)
1.761 + {
1.762 + case EWsWinOpActivate:
1.763 + Activate();
1.764 + break;
1.765 + case EWsWinOpSetPos:
1.766 + SetExtentL(pData.pos,NULL);
1.767 + break;
1.768 + case EWsWinOpSetExtent:
1.769 + case EWsWinOpSetExtentErr:
1.770 + SetExtentL(&pData.SetEx->pos,&pData.SetEx->size);
1.771 + break;
1.772 + case EWsWinOpSetSize:
1.773 + case EWsWinOpSetSizeErr:
1.774 + SetExtentL(NULL,pData.size);
1.775 + break;
1.776 + case EWsWinOpInquireOffset:
1.777 + CWsClient::ReplyPoint(InquireOffset(*pData.UInt));
1.778 + break;
1.779 + case EWsWinOpPosition:
1.780 + CWsClient::ReplyPoint(iRel.iTl);
1.781 + break;
1.782 + case EWsWinOpAbsPosition:
1.783 + CWsClient::ReplyPoint(iOrigin);
1.784 + break;
1.785 + case EWsWinOpSize:
1.786 + CWsClient::ReplySize(iRel.Size());
1.787 + break;
1.788 + case EWsWinOpTestInvariant:
1.789 + SetReply(EFalse);
1.790 + break;
1.791 + case EWsWinOpPointerFilter:
1.792 + {
1.793 + TUint old=iPointerFilter;
1.794 + iPointerFilter&=~pData.PointerFilter->mask;
1.795 + iPointerFilter|=pData.PointerFilter->mask&pData.PointerFilter->flags;
1.796 + if (old&EPointerFilterEnterExit)
1.797 + TWsPointer::ReLogWindow(this);
1.798 + }
1.799 + break;
1.800 + case EWsWinOpSetPointerGrab:
1.801 + if (*pData.Bool==EFalse)
1.802 + iFlags&=~EFlagPointerGrab;
1.803 + else
1.804 + iFlags|=EFlagPointerGrab;
1.805 + break;
1.806 + case EWsWinOpClaimPointerGrab:
1.807 + {
1.808 + if (!iParent)
1.809 + OwnerPanic(EWservPanicParentDeleted);
1.810 +
1.811 + TInt errNo = TWsPointer::ClaimGrab(this,*pData.GrabControl);
1.812 + if(TWsWinCmdGrabControl::ESendReply & pData.GrabControl->flags)
1.813 + {
1.814 + // To avoid the reply-generated-flush, only do this for the new APIs, not the old ones.
1.815 + SetReply(errNo);
1.816 + }
1.817 + }
1.818 + break;
1.819 + case EWsWinOpSetPointerCapture:
1.820 + iFlags&=~(EFlagPointerCaptured|EFlagPointerCaptureDragDrop|EFlagPointerCaptureAllGroups);
1.821 + if ((*pData.UInt)&RWindowBase::TCaptureFlagEnabled)
1.822 + {
1.823 + iFlags|=EFlagPointerCaptured;
1.824 + if ((*pData.UInt)&RWindowBase::TCaptureFlagDragDrop)
1.825 + iFlags|=EFlagPointerCaptureDragDrop;
1.826 + if ((*pData.UInt)&RWindowBase::TCaptureFlagAllGroups)
1.827 + iFlags|=EFlagPointerCaptureAllGroups;
1.828 +
1.829 + }
1.830 + TWsPointer::ReLogPointersCurrentWindows();
1.831 + break;
1.832 + case EWsWinOpSetPointerCapturePriority:
1.833 + iPointerCapturePriority=*pData.Int;
1.834 + break;
1.835 + case EWsWinOpGetPointerCapturePriority:
1.836 + SetReply(iPointerCapturePriority);
1.837 + break;
1.838 + case EWsWinOpSetVisible:
1.839 + SetVisible(*pData.Bool);
1.840 + break;
1.841 + case EWsWinOpScroll:
1.842 + {
1.843 + TPoint origin(0,0);
1.844 + TRect src(TRect(origin,iRel.Size()));
1.845 + src.Move(-pData.ScrollRect->offset);
1.846 + Scroll(TRect(origin,iRel.Size()),pData.ScrollRect->offset,src);
1.847 + }
1.848 + break;
1.849 + case EWsWinOpScrollClip:
1.850 + {
1.851 + TPoint origin(0,0);
1.852 + TRect src(TRect(origin,iRel.Size()));
1.853 + src.Move(-pData.ScrollRect->offset);
1.854 + TRect clip(pData.ScrollRect->clip);
1.855 + Scroll(clip,pData.ScrollRect->offset,src);
1.856 + }
1.857 + break;
1.858 + case EWsWinOpScrollRect:
1.859 + {
1.860 + TRect src(pData.ScrollRect->rect);
1.861 + Scroll(TRect(TPoint(0,0),iRel.Size()),pData.ScrollRect->offset,src);
1.862 + }
1.863 + break;
1.864 + case EWsWinOpScrollClipRect:
1.865 + {
1.866 + TRect src(pData.ScrollRect->rect);
1.867 + TRect clip(pData.ScrollRect->clip);
1.868 + Scroll(clip, pData.ScrollRect->offset,src);
1.869 + }
1.870 + break;
1.871 + case EWsWinOpSetOrdinalPositionPri:
1.872 + iOrdinalPriority=pData.OrdinalPos->ordinalPriority;
1.873 + SetOrdinalPosition(pData.OrdinalPos->pos);
1.874 + break;
1.875 + case EWsWinOpSetShadowHeight:
1.876 + OwnerPanic(EWservPanicOpcode); //this op code is deprecated, should never be generated by the client
1.877 + break;
1.878 + case EWsWinOpShadowDisabled:
1.879 + OwnerPanic(EWservPanicOpcode); //this op code is deprecated, should never be generated by the client
1.880 + break;
1.881 + case EWsWinOpRequiredDisplayMode:
1.882 + if (Backup()!=NULL)
1.883 + OwnerPanic(EWservPanicBackupDisplayMode);
1.884 + SetReply(SetRequiredDisplayModeL(*pData.DisplayMode));
1.885 + break;
1.886 + case EWsWinOpGetDisplayMode:
1.887 + SetReply(DisplayMode());
1.888 + break;
1.889 + case EWsWinOpRequestPointerRepeatEvent:
1.890 + {
1.891 + if (!iParent)
1.892 + OwnerPanic(EWservPanicParentDeleted);
1.893 + TInt errNo = TWsPointer::RequestPointerRepeatEvent(this,*pData.RequestPointerRepeatEvent);
1.894 + if(TWsWinCmdRequestPointerRepeatEvent::ERepeatFlagsSendReply & pData.RequestPointerRepeatEvent->repeatFlags)
1.895 + {
1.896 + SetReply(errNo);
1.897 + }
1.898 + }
1.899 + break;
1.900 + case EWsWinOpCancelPointerRepeatEventRequest:
1.901 + {
1.902 + TInt errNo = TWsPointer::CancelPointerRepeatEventRequest(*pData.CancelPointerRepeatEventRequest);
1.903 + if(TWsWinCmdCancelPointerRepeatEventRequest::ECancelRepeatFlagsSendReply & pData.RequestPointerRepeatEvent->repeatFlags)
1.904 + {
1.905 + SetReply(errNo);
1.906 + }
1.907 + }
1.908 + break;
1.909 + case EWsWinOpAllocPointerMoveBuffer:
1.910 + CWsPointerBuffer::ConnectL(this,pData.AllocPointerMoveBuffer->maxNumPoints,pData.AllocPointerMoveBuffer->flags);
1.911 + iFlags|=EFlagUsingPointerBuffer|EFlagHasPointerBuffer;
1.912 + break;
1.913 + case EWsWinOpFreePointerMoveBuffer:
1.914 + CWsPointerBuffer::Disconnect(this);
1.915 + iFlags&=~(EFlagUsingPointerBuffer|EFlagHasPointerBuffer);
1.916 + break;
1.917 + case EWsWinOpRetrievePointerMoveBuffer:
1.918 + CWsPointerBuffer::RetrievePointerMoveBuffer(this,*pData.Int);
1.919 + break;
1.920 + case EWsWinOpEnablePointerMoveBuffer:
1.921 + if (!(iFlags&EFlagHasPointerBuffer))
1.922 + OwnerPanic(EWservPanicNoPointerBuffer);
1.923 + iFlags|=EFlagUsingPointerBuffer;
1.924 + break;
1.925 + case EWsWinOpDisablePointerMoveBuffer:
1.926 + iFlags&=~EFlagUsingPointerBuffer;
1.927 + /*Fall Through*/
1.928 + case EWsWinOpDiscardPointerMoveBuffer:
1.929 + CWsPointerBuffer::DiscardPointerMoveBuffer(this);
1.930 + break;
1.931 + case EWsWinOpAddKeyRect:
1.932 + AddKeyRectL(pData.AddKeyRect->rect, pData.AddKeyRect->scanCode, pData.AddKeyRect->activatedByPointerSwitchOn);
1.933 + break;
1.934 + case EWsWinOpRemoveAllKeyRects:
1.935 + RemoveAllKeyRects();
1.936 + break;
1.937 + case EWsWinOpPasswordWindow:
1.938 + if (!iParent)
1.939 + OwnerPanic(EWservPanicParentDeleted);
1.940 + CWsPassword::SetPasswordWindowL(this, *pData.PasswordMode);
1.941 + break;
1.942 + case EWsWinOpEnableBackup:
1.943 + if (!iParent)
1.944 + OwnerPanic(EWservPanicParentDeleted);
1.945 + if (*pData.UInt==0)
1.946 + iBackupsRequested|=EWindowBackupAreaBehind; //For backwards compatibility
1.947 + else
1.948 + iBackupsRequested|=*pData.UInt;
1.949 + break;
1.950 + case EWsWinOpFadeBehind:
1.951 + {
1.952 + if (!iParent)
1.953 + OwnerPanic(EWservPanicParentDeleted);
1.954 +
1.955 + TUint8 blackMap;
1.956 + TUint8 whiteMap;
1.957 + iScreen->GetFadingParams(blackMap,whiteMap);
1.958 + SetFadeBehind(*pData.Bool);
1.959 + TWalkWindowTreeSetFaded wwt(*pData.Bool,this,blackMap,whiteMap);
1.960 + WalkWindowTree(wwt,EWalkBehind);
1.961 + }
1.962 + break;
1.963 + case EWsWinOpGetIsFaded:
1.964 + SetReply(iFadeCount);
1.965 + break;
1.966 + case EWsWinOpGetIsNonFading:
1.967 + SetReply(iFlags&EFlagNonFadingWindow);
1.968 + break;
1.969 + case EWsWinOpMoveToGroup:
1.970 + if (!iParent)
1.971 + OwnerPanic(EWservPanicParentDeleted);
1.972 + if (iParent->WinType()!=EWinTypeGroup)
1.973 + OwnerPanic(EWservPanicNotTopClient);
1.974 + ((CWsTopClientWindow*)this)->DoMoveWindowL(*pData.Int);
1.975 + break;
1.976 + case EWsWinOpTestLowPriorityRedraw:
1.977 + {
1.978 + // This is purely for testing purposes
1.979 + // Returns the redraw priority
1.980 + TUint priority=0;
1.981 + TPckgBuf<TUint> priBuf;
1.982 + priority=WsOwner()->RedrawQueue()->RedrawPriority((CWsWindowRedraw*)this->iRedraw);
1.983 + priBuf()=priority;
1.984 + CWsClient::ReplyBuf(priBuf);
1.985 + }
1.986 + break;
1.987 + case EWsWinOpEnableVisibilityChangeEvents:
1.988 + iFlags |= EFlagGeneratesVisibilityEvents;
1.989 + SetupVisibleRegionTracking(ETrue);
1.990 + if (iFlags&EFlagActive)
1.991 + {
1.992 + iScreen->DoRedrawNow();
1.993 + PossibleVisibilityChangedEvent(ETrue);
1.994 + }
1.995 + break;
1.996 + case EWsWinOpDisableVisibilityChangeEvents:
1.997 + iFlags &= ~EFlagGeneratesVisibilityEvents;
1.998 + SetupVisibleRegionTracking(EFalse);
1.999 + break;
1.1000 + case EWsWinOpSetTransparentRegion:
1.1001 + {
1.1002 + if (IsTranslucent())
1.1003 + {
1.1004 + TInt recs=*pData.Int;
1.1005 + RWsRegion* reg=recs>0? GetRegionFromClientL(iWsOwner,recs) : new(ELeave) RWsRegion;
1.1006 + SetUserTransparentRegion(reg);
1.1007 + SetReply(KErrNone);
1.1008 + }
1.1009 + else
1.1010 + {
1.1011 + OwnerPanic(EWservPanicTransparencyObjNotCreated);
1.1012 + }
1.1013 + }
1.1014 + break;
1.1015 + case EWsWinOpSetTransparencyPolicy:
1.1016 + {
1.1017 + if (IsTranslucent())
1.1018 + SetReply(KErrNone);
1.1019 + else
1.1020 + OwnerPanic(EWservPanicTransparencyObjNotCreated);
1.1021 + }
1.1022 + break;
1.1023 + case EWsWinOpSetTransparencyAlphaChannel:
1.1024 + {
1.1025 + iFlags |= static_cast<TUint>(EFlagHasAlpha);
1.1026 + SetReply(KErrNone);
1.1027 +
1.1028 + MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
1.1029 + if (windowTreeObserver)
1.1030 + {
1.1031 + windowTreeObserver->FlagChanged(*this, MWsWindowTreeObserver::EAlphaChannelTransparencyEnabled, ETrue);
1.1032 + }
1.1033 + break;
1.1034 + }
1.1035 + default:
1.1036 + if (iRedraw->CommandL(aOpcode,pData)==EFalse)
1.1037 + {
1.1038 + OwnerPanic(EWservPanicOpcode);
1.1039 + }
1.1040 + }
1.1041 + }
1.1042 +#if defined(_DEBUG)
1.1043 + rootWindow->CheckTree();
1.1044 +#endif
1.1045 + }
1.1046 +
1.1047 +void CWsClientWindow::GcActivated(CWsGc *aGc)
1.1048 + {
1.1049 + aGc->SetNextWinGc(iWinGcList);
1.1050 + iWinGcList=aGc;
1.1051 + }
1.1052 +
1.1053 +void CWsClientWindow::GcDeactivated(CWsGc *aGc)
1.1054 + {
1.1055 + if (aGc==iWinGcList)
1.1056 + iWinGcList=aGc->NextWinGc();
1.1057 + else
1.1058 + {
1.1059 + CWsGc *gc=iWinGcList;
1.1060 + CWsGc *next;
1.1061 + FOREVER
1.1062 + {
1.1063 + next=gc->NextWinGc();
1.1064 + WS_ASSERT_DEBUG(next!=NULL, EWsPanicBadActiveGcList);
1.1065 + if (next==aGc)
1.1066 + {
1.1067 + gc->SetNextWinGc(next->NextWinGc());
1.1068 + break;
1.1069 + }
1.1070 + gc=next;
1.1071 + }
1.1072 + }
1.1073 + aGc->SetNextWinGc(NULL);
1.1074 + }
1.1075 +
1.1076 +void CWsClientWindow::ReactivateGcs()
1.1077 + {
1.1078 + for (CWsGc * gc = iWinGcList; gc; gc = gc->NextWinGc())
1.1079 + {
1.1080 + gc->Reactivate();
1.1081 + }
1.1082 + }
1.1083 +
1.1084 +void CWsClientWindow::OffsetUserTransparentRegion(const TPoint& aOffset)
1.1085 + {
1.1086 + if (iUserDefinedTransparentRegion)
1.1087 + {
1.1088 + iUserDefinedTransparentRegion->Offset(aOffset);
1.1089 + }
1.1090 + }
1.1091 +
1.1092 +void CWsClientWindow::SetUserTransparentRegion(RWsRegion* aRegion)
1.1093 + {
1.1094 + if (iUserDefinedTransparentRegion)
1.1095 + {
1.1096 + iUserDefinedTransparentRegion->Close();
1.1097 + delete iUserDefinedTransparentRegion;
1.1098 + iUserDefinedTransparentRegion = 0;
1.1099 + }
1.1100 +
1.1101 + if (aRegion)
1.1102 + {
1.1103 + aRegion->Offset(iOrigin);
1.1104 + iUserDefinedTransparentRegion=aRegion;
1.1105 + }
1.1106 +
1.1107 + SetUserOpaqueRegion();
1.1108 + }
1.1109 +
1.1110 +void CWsClientWindow::SetUserOpaqueRegion()
1.1111 + {
1.1112 + if (iUserDefinedOpaqueRegion)
1.1113 + {
1.1114 + iUserDefinedOpaqueRegion->Close();
1.1115 + delete iUserDefinedOpaqueRegion;
1.1116 + iUserDefinedOpaqueRegion = 0;
1.1117 + }
1.1118 + if (iUserDefinedTransparentRegion)
1.1119 + {
1.1120 + iUserDefinedOpaqueRegion=new RWsRegion;
1.1121 + if (iUserDefinedOpaqueRegion)
1.1122 + {
1.1123 + iUserDefinedOpaqueRegion->Copy(*iBaseArea);
1.1124 + iUserDefinedOpaqueRegion->SubRegion(*iUserDefinedTransparentRegion);
1.1125 + if (iUserDefinedOpaqueRegion->CheckError() || iUserDefinedOpaqueRegion->Count() == 0)
1.1126 + {
1.1127 + iUserDefinedOpaqueRegion->Close();
1.1128 + delete iUserDefinedOpaqueRegion;
1.1129 + iUserDefinedOpaqueRegion = 0;
1.1130 + }
1.1131 + }
1.1132 + // Intentionally not sending this notification during destruction (when SetUserTransparentRegion is called from d'tor)
1.1133 + MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
1.1134 + if (windowTreeObserver)
1.1135 + {
1.1136 + windowTreeObserver->TransparentRegionChanged(*this, *iUserDefinedTransparentRegion, iUserDefinedOpaqueRegion);
1.1137 + }
1.1138 + }
1.1139 + }
1.1140 +
1.1141 +/** Checks whether this window is in front of aWin.
1.1142 +
1.1143 +@param aWin A window.
1.1144 +@return EFalse if aWin is the same or is in front of this, ETrue otherwise.
1.1145 +@internalComponent
1.1146 +* released
1.1147 +*/
1.1148 +TBool CWsClientWindow::IsInfrontOf(const CWsWindowBase* aWin) const
1.1149 + {
1.1150 + TInt thisDepth=Depth();
1.1151 + TInt otherDepth=aWin->Depth();
1.1152 + const CWsWindowBase *thisWin=this;
1.1153 + const CWsWindowBase *otherWin=aWin;
1.1154 + if (thisDepth>otherDepth)
1.1155 + {
1.1156 + for (TInt count=thisDepth-otherDepth;count>0;count--)
1.1157 + thisWin=thisWin->BaseParent();
1.1158 + }
1.1159 + else
1.1160 + {
1.1161 + for (TInt count=otherDepth-thisDepth;count>0;count--)
1.1162 + otherWin=otherWin->BaseParent();
1.1163 + }
1.1164 + if (thisWin==otherWin)
1.1165 + return thisDepth>otherDepth;
1.1166 + while(thisWin->BaseParent()!=otherWin->BaseParent())
1.1167 + {
1.1168 + thisWin=thisWin->BaseParent();
1.1169 + otherWin=otherWin->BaseParent();
1.1170 + }
1.1171 + const CWsWindowBase *win=thisWin->BaseParent()->BaseChild();
1.1172 + FOREVER
1.1173 + {
1.1174 + if (win==otherWin)
1.1175 + {
1.1176 + return EFalse;
1.1177 + }
1.1178 + if (win==thisWin)
1.1179 + return ETrue;
1.1180 + win=win->NextSibling();
1.1181 + }
1.1182 + }
1.1183 +
1.1184 +CWsTopClientWindow* CWsClientWindow::TopClientWindow()
1.1185 + {
1.1186 + if (iParent==NULL)
1.1187 + OwnerPanic(EWservPanicParentDeleted);
1.1188 + CWsWindowBase* win=this;
1.1189 + while(win->BaseParent()->WinType()!=EWinTypeGroup)
1.1190 + win=win->BaseParent();
1.1191 + return static_cast<CWsTopClientWindow*>(win);
1.1192 + }
1.1193 +
1.1194 +const TRegion &CWsClientWindow::InvalidArea() const
1.1195 + {
1.1196 + return(iRedraw->InvalidArea());
1.1197 + }
1.1198 +
1.1199 +
1.1200 +TUint CWsClientWindow::RedrawPriority(TInt *aShift) const
1.1201 + {
1.1202 + TUint ordinalPos=OrdinalPosition(EFalse)+1;
1.1203 + if (ordinalPos>15) // Algorithm only works upto 15 , make all windows after 15 equal in priority
1.1204 + ordinalPos=15;
1.1205 + TInt shift;
1.1206 + TUint parent=((CWsClientWindow *)iParent)->RedrawPriority(&shift);
1.1207 + if (shift>0)
1.1208 + shift--;
1.1209 + if (aShift)
1.1210 + *aShift=shift;
1.1211 + return(parent+(ordinalPos<<(shift*KWinRedrawPriBitsPerLevel)));
1.1212 + }
1.1213 +
1.1214 +TDblQue<TPointerKeyList> *CWsClientWindow::PointerKeyList() const
1.1215 + {
1.1216 + return(iPointerKeyList);
1.1217 + }
1.1218 +
1.1219 +void CWsClientWindow::AddKeyRectL(const TRect &aRect, TInt aScanCode, TBool aActivatedByPointerSwitchOn)
1.1220 + {
1.1221 + if (!iPointerKeyList)
1.1222 + iPointerKeyList=new(ELeave) TDblQue<TPointerKeyList>(_FOFF(TPointerKeyList,iQue));
1.1223 + TPointerKeyList *pkl=new(ELeave) TPointerKeyList();
1.1224 + iPointerKeyList->AddLast(*pkl);
1.1225 + pkl->iRect=aRect;
1.1226 + pkl->iScanCode=aScanCode;
1.1227 + pkl->iActivatedByPointerSwitchOn=aActivatedByPointerSwitchOn;
1.1228 + }
1.1229 +
1.1230 +void CWsClientWindow::RemoveAllKeyRects()
1.1231 + {
1.1232 + if (iPointerKeyList)
1.1233 + {
1.1234 + TPointerKeyList *pkl=NULL;
1.1235 + for(TDblQueIter<TPointerKeyList> iter(*iPointerKeyList);(pkl=iter++)!=NULL;)
1.1236 + {
1.1237 + pkl->iQue.Deque();
1.1238 + delete pkl;
1.1239 + }
1.1240 + delete iPointerKeyList;
1.1241 + iPointerKeyList=NULL;
1.1242 + }
1.1243 + }
1.1244 +
1.1245 +TBool CWsClientWindow::IsHidden()
1.1246 + {
1.1247 + return (!IsVisible()) || VisibleRegion().IsEmpty();
1.1248 + }
1.1249 +
1.1250 +void CWsClientWindow::SetFaded(TBool aFade, TUint8 aBlackMap, TUint8 aWhiteMap, TBool aNotifyObserver)
1.1251 + {
1.1252 + TBool stateChanged;
1.1253 + SetFaded(aFade, aBlackMap, aWhiteMap, aNotifyObserver, stateChanged);
1.1254 + }
1.1255 +
1.1256 +void CWsClientWindow::SetFaded(TBool aFade, TUint8 aBlackMap, TUint8 aWhiteMap, TBool aNotifyObserver, TBool& aStateChanged)
1.1257 + {
1.1258 + iBlackMap=aBlackMap;
1.1259 + iWhiteMap=aWhiteMap;
1.1260 + const TBool mapAltered = (iBlackMap != aBlackMap) || (iWhiteMap != aWhiteMap);
1.1261 + const TInt oldFadeCount = iFadeCount;
1.1262 +
1.1263 + if (iAbsoluteFading)
1.1264 + {
1.1265 + if (aFade)
1.1266 + {
1.1267 + iFadeCount = 1;
1.1268 + }
1.1269 + else
1.1270 + {
1.1271 + iFadeCount = 0;
1.1272 + }
1.1273 + }
1.1274 + else
1.1275 + {
1.1276 + if (aFade)
1.1277 + {
1.1278 + ++iFadeCount;
1.1279 + }
1.1280 + else if (iFadeCount > 0)
1.1281 + {
1.1282 + --iFadeCount;
1.1283 + }
1.1284 + }
1.1285 +
1.1286 + //Fade state only changes when iFadeCount transitions from 0 to 1 or from 1 to 0.
1.1287 + aStateChanged = (iFadeCount==0 || oldFadeCount==0) && (oldFadeCount != iFadeCount);
1.1288 + if (!Screen()->ChangeTracking() && CWsTop::IsFadeEnabled() && (aStateChanged || mapAltered) )
1.1289 + {
1.1290 + Screen()->AcceptFadeRequest(this, (iFadeCount > 0));
1.1291 + }
1.1292 +
1.1293 + const TBool doNotify = iAbsoluteFading ? aStateChanged : (oldFadeCount != iFadeCount);
1.1294 + MWsWindowTreeObserver* const windowTreeObserver = Screen()->WindowTreeObserver();
1.1295 + if (windowTreeObserver && aNotifyObserver && doNotify)
1.1296 + {
1.1297 + windowTreeObserver->FadeCountChanged(*this, iFadeCount);
1.1298 + }
1.1299 + }
1.1300 +
1.1301 +void CWsClientWindow::ResetHiddenFlagsInParentAndChildren()
1.1302 + {
1.1303 + ResetHiddenFlag();
1.1304 + SetElementOpacity(IsVisible() ? 0xFF : 0x00); // Update element visibility
1.1305 + for(CWsClientWindow* child=Child();child;child=child->NextSibling())
1.1306 + {
1.1307 + child->ResetHiddenFlagsInParentAndChildren();
1.1308 + }
1.1309 + }
1.1310 +
1.1311 +const TRegion& CWsClientWindow::WindowArea() const
1.1312 + {
1.1313 + WS_ASSERT_DEBUG(iBaseArea, EWsPanicRegionNull);
1.1314 + return *iBaseArea;
1.1315 + }
1.1316 +
1.1317 +void CWsClientWindow::Invalidate(const TRect * aRect)
1.1318 + {
1.1319 + iRedraw->Invalidate(aRect);
1.1320 + }
1.1321 +
1.1322 +void CWsClientWindow::ScheduleRegionUpdate(const TRegion* aDefinitelyDirty)
1.1323 + {
1.1324 + if (IsVisible())
1.1325 + {
1.1326 + iScreen->ScheduleRegionUpdate(aDefinitelyDirty);
1.1327 + }
1.1328 + }
1.1329 +
1.1330 +void CWsClientWindow::AddRedrawRegion(const TRegion& aRegion, TBool aSchedule, TRedrawDepth aDepth)
1.1331 + {
1.1332 + if (!IsHidden())
1.1333 + {
1.1334 + iScreen->AddRedrawRegion(aRegion, aSchedule, aDepth);
1.1335 + }
1.1336 + }
1.1337 +
1.1338 +void CWsClientWindow::SendState(MWsWindowTreeObserver& aWindowTreeObserver) const
1.1339 + {
1.1340 + CWsWindow::SendState(aWindowTreeObserver);
1.1341 +
1.1342 + if(iFadeCount > 0)
1.1343 + {
1.1344 + aWindowTreeObserver.FadeCountChanged(*this, iFadeCount);
1.1345 + }
1.1346 +
1.1347 + if(iUserDefinedTransparentRegion)
1.1348 + {
1.1349 + aWindowTreeObserver.TransparentRegionChanged(*this, *iUserDefinedTransparentRegion, iUserDefinedOpaqueRegion);
1.1350 + }
1.1351 +
1.1352 + if(HasElement())
1.1353 + {
1.1354 + CWindowElementSet& windowElementSet = Screen()->WindowElements();
1.1355 + const TBackgroundAttributes *bElementAttr;
1.1356 + const RArray<TPlacedAttributes> *pElementsAttr;
1.1357 +
1.1358 + TInt ret = windowElementSet.FindElements(*this, bElementAttr, pElementsAttr);
1.1359 + if(ret == KErrNone)
1.1360 + {
1.1361 + MWsElement* element = bElementAttr->iElement;
1.1362 + if (element)
1.1363 + aWindowTreeObserver.ElementAdded(*this, *element);
1.1364 + }
1.1365 + }
1.1366 +
1.1367 + }
1.1368 +
1.1369 +TBool CWsClientWindow::IsDSAHost() const
1.1370 + {
1.1371 + TBool res = CWsWindow::IsDSAHost();
1.1372 + if ( !res )
1.1373 + { // check for grace period when DSA is being restarted (after aborting but before client started DSA again)
1.1374 + res = Screen()->IsDSAClientWindow( this );
1.1375 + }
1.1376 + return res;
1.1377 + }
1.1378 +
1.1379 +void CWsClientWindow::UpdateElementExtent(const TPoint* aOffset)
1.1380 + {
1.1381 + if (Redraw()->HasElement())
1.1382 + {
1.1383 + Screen()->WindowElements().UpdateElementExtent(*this, aOffset);
1.1384 + }
1.1385 + }
1.1386 +
1.1387 +void CWsClientWindow::SetElementOpacity(TInt aOpacity)
1.1388 + {
1.1389 + if (Redraw()->HasElement())
1.1390 + {
1.1391 + Screen()->WindowElements().SetElementOpacity(*this,aOpacity);
1.1392 +
1.1393 + }
1.1394 + }
1.1395 +
1.1396 +TRect CWsClientWindow::GetOriginalSrcElementRect() const
1.1397 + {
1.1398 + return iOriginalSrcElementRect;
1.1399 + }
1.1400 +TRect CWsClientWindow::GetOriginalDestElementRect() const
1.1401 + {
1.1402 + return iOriginalDestElementRect;
1.1403 + }
1.1404 +
1.1405 +//
1.1406 +// Code for CWsTopClientWindow, a client window that connects to a group window //
1.1407 +//
1.1408 +
1.1409 +CWsTopClientWindow::CWsTopClientWindow(CWsClient* aOwner, CScreen* aScreen) : CWsClientWindow(aOwner, aScreen)
1.1410 + {
1.1411 + }
1.1412 +
1.1413 +void CWsTopClientWindow::ConstructL(const TWsClCmdCreateWindow &cmd, CWsWindowBase *aParent, TBool aScreenDeviceIsInvalid)
1.1414 + {
1.1415 + iFlags|=EFlagIsTopClientWindow;
1.1416 + CWsClientWindow::ConstructL(cmd, aParent, aScreenDeviceIsInvalid);
1.1417 + }
1.1418 +
1.1419 +void CWsTopClientWindow::SetInactive()
1.1420 + {
1.1421 + iFlags&=~EFlagActive;
1.1422 + ResetHiddenFlags();
1.1423 + }
1.1424 +
1.1425 +void CWsTopClientWindow::SetScreenDeviceValidState(TBool aState)
1.1426 + {
1.1427 + if (SetScreenDeviceValidStateFlag(aState))
1.1428 + ResetHiddenFlags();
1.1429 + }
1.1430 +
1.1431 +TBool CWsTopClientWindow::SetScreenDeviceValidStateFlag(TBool aState)
1.1432 + {
1.1433 + TBool isSet=iFlags&EFlagScreenDeviceInvalid;
1.1434 + if (!isSet==!aState)
1.1435 + {
1.1436 + if (aState)
1.1437 + iFlags&=~EFlagScreenDeviceInvalid;
1.1438 + else
1.1439 + iFlags|=EFlagScreenDeviceInvalid;
1.1440 +
1.1441 + MWsWindowTreeObserver* windowTreeObserver = iScreen->WindowTreeObserver();
1.1442 + if (windowTreeObserver)
1.1443 + {
1.1444 + windowTreeObserver->FlagChanged(*this, MWsWindowTreeObserver::EScreenDeviceValid, aState);
1.1445 + }
1.1446 +
1.1447 + return ETrue;
1.1448 + }
1.1449 + return EFalse;
1.1450 + }
1.1451 +
1.1452 +void CWsTopClientWindow::SetOrdinalPosition(TInt aPos)
1.1453 + {
1.1454 + if (!iParent)
1.1455 + {
1.1456 + OwnerPanic(EWservPanicParentDeleted);
1.1457 + }
1.1458 + if (CheckOrdinalPositionChange(aPos))
1.1459 + {
1.1460 + CWsWindowBase::SetOrdinalPosition(aPos);
1.1461 + CWsTop::TriggerRedraws(RootWindow());
1.1462 + }
1.1463 + }
1.1464 +
1.1465 +void CWsTopClientWindow::DoMoveWindowL(TInt aIdentifier)
1.1466 + {
1.1467 + CWsWindowGroup* group=CWsWindowGroup::WindowGroupFromIdentifierL(aIdentifier);
1.1468 + if (group==iParent)
1.1469 + return;
1.1470 + if (group->WsOwner()!=WsOwner())
1.1471 + User::Leave(KErrNotFound);
1.1472 + ChangeWindowPosition(0, group);
1.1473 + CWsTop::TriggerRedraws(RootWindow());
1.1474 + }
1.1475 +
1.1476 +TUint CWsTopClientWindow::RedrawPriority(TInt *aShift) const
1.1477 + {
1.1478 + TUint ordinalPos=OrdinalPosition(EFalse);
1.1479 + if (ordinalPos>KWinRedrawPriMaxOrdinal) // Algorithm only works for upto KWinRedrawPriMaxOrdinal windows,
1.1480 + ordinalPos=KWinRedrawPriMaxOrdinal; // make all windows after this equal in priority
1.1481 + if (aShift)
1.1482 + *aShift=KWinRedrawPriMaxLevel;
1.1483 + return(ordinalPos<<(KWinRedrawPriMaxLevel*KWinRedrawPriBitsPerLevel));
1.1484 + }
1.1485 +