MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/graphics/windowing/windowserver/test/tlib/TESTBASE.CPP
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 // Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Base classes used for building window server test code

    15 // 

    16 //

    17 

    18 #include <e32std.h>

    19 #include <w32std.h>

    20 #include <e32svr.h>

    21 #include <e32property.h>

    22 #include "TLIB.H"

    23 #include <graphics/wsgraphicdrawerinterface.h>

    24 

    25 //

    26 // Test code classes

    27 //

    28 // CTWinBase

    29 // CTBaseWin

    30 // CTWin

    31 // CTBackedUpWin

    32 // CTGroupWin

    33 // CTClient

    34 //

    35 //

    36 

    37 _LIT(KTestFontTypefaceName,"DejaVu Sans Condensed");

    38 

    39 class CStopTheScheduler : public CAsyncOneShot

    40 	{

    41 public:

    42 	inline CStopTheScheduler(CTClient* aClient,TInt aPriority,TBool aAll) :CAsyncOneShot(aPriority), iClient(aClient), iAll(aAll) {}

    43 	inline CStopTheScheduler(CTClient* aClient,TInt aPriority) :CAsyncOneShot(aPriority), iClient(aClient) {}

    44 	inline CStopTheScheduler(TInt aPriority) :CAsyncOneShot(aPriority) {}

    45 	void RunL();

    46 public:

    47 	CTClient* iClient;

    48 	TBool iAll;

    49 #ifdef __WINS__

    50 	TInt iCStopTheSchedulerRunCount;

    51 #endif

    52 	};

    53 

    54 

    55 void TbPanic(TInt aPanic)

    56 	{

    57 	User::Panic(_L("TestBase"),aPanic);

    58 	}

    59 

    60 EXPORT_C CTWinBase::CTWinBase(TInt aType) : iType(aType)

    61 	{

    62 	__DECLARE_NAME(_S("CTWinBase"));

    63 	}

    64 

    65 EXPORT_C CTWinBase *CTWinBase::Parent() const

    66 	{

    67 	return((CTWinBase *)WinTreeNode()->Parent());

    68 	}

    69 

    70 EXPORT_C CTWinBase *CTWinBase::NextSibling() const

    71 	{

    72 	return((CTWinBase *)WinTreeNode()->NextSibling());

    73 	}

    74 

    75 EXPORT_C CTWinBase *CTWinBase::PrevSibling() const

    76 	{

    77 	return((CTWinBase *)WinTreeNode()->PrevSibling());

    78 	}

    79 

    80 EXPORT_C CTClient *CTWinBase::Client() const

    81 	{

    82 	return(iOwnerWin->Client());

    83 	}

    84 

    85 EXPORT_C CTBaseWin *CTWinBase::Child() const

    86 	{

    87 	return((CTBaseWin *)WinTreeNode()->Child());

    88 	}

    89 

    90 EXPORT_C TPoint CTWinBase::Position() const

    91 	{

    92 	return(TPoint(0,0));

    93 	}

    94 

    95 EXPORT_C void CTWinBase::PointerEnter(const TTime&)

    96 	{

    97 	}

    98 

    99 EXPORT_C void CTWinBase::PointerExit(const TTime&)

   100 	{

   101 	}

   102 

   103 EXPORT_C void CTWinBase::PointerBufferReady(const TTime&)

   104 	{

   105 	}

   106 

   107 EXPORT_C void CTWinBase::PointerL(const TPointerEvent&,const TTime&)

   108 	{

   109 	}

   110 

   111 EXPORT_C void CTWinBase::SwitchOn(const TTime &)

   112 	{

   113 	}

   114 

   115 EXPORT_C void CTWinBase::ModifiersChanged(const TModifiersChangedEvent &,const TTime &)

   116 	{

   117 	}

   118 

   119 EXPORT_C void CTWinBase::AdjustOrdinal(TInt)

   120 	{

   121 	}

   122 

   123 EXPORT_C void CTWinBase::AdjustShadow(TInt)

   124 	{

   125 	}

   126 

   127 EXPORT_C void CTWinBase::SetVisible(TBool)

   128 	{

   129 	}

   130 

   131 EXPORT_C TInt CTWinBase::SubType()

   132 	{

   133 	return(0);

   134 	}

   135 

   136 EXPORT_C void CTWinBase::ErrorMessage(const TWsErrorMessage&, const TTime &)

   137 	{

   138 	}

   139 

   140 EXPORT_C void CTWinBase::__DbgTestInvariant() const

   141 	{

   142 	WinTreeNode()->__DbgTestInvariant();

   143 	}

   144 

   145 // CTBaseWin //

   146 

   147 EXPORT_C CTBaseWin::CTBaseWin(TInt aType) : CTWinBase(aType)

   148 	{

   149 	__DECLARE_NAME(_S("CTBaseWin"));

   150 	}

   151 

   152 EXPORT_C CTBaseWin::~CTBaseWin()

   153 	{

   154 	}

   155 

   156 EXPORT_C void CTBaseWin::RelinquishFocus()

   157 	{

   158 	CTWinBase *parent=Parent();

   159 	CTWindowGroup *group=Group();

   160 	CTWinBase *child=group->Child();

   161 	if (child==this)

   162 		child=child->NextSibling();

   163 	group->SetCurrentWindow((parent->iType==EWinTypeClient) ? (CTBaseWin *)parent : (CTBaseWin *)child);

   164 	}

   165 

   166 EXPORT_C void CTBaseWin::SetVisible(TBool aState)

   167 	{

   168 	BaseWin()->SetVisible(aState);

   169 	}

   170 

   171 EXPORT_C const RWindowTreeNode *CTBaseWin::WinTreeNode() const

   172 	{

   173 	return((const RWindowTreeNode *)BaseWin());

   174 	}

   175 

   176 EXPORT_C RWindowTreeNode *CTBaseWin::WinTreeNode()

   177 	{

   178 	return((RWindowTreeNode *)BaseWin());

   179 	}

   180 

   181 EXPORT_C void CTBaseWin::InitWin()

   182 	{

   183 	}

   184 

   185 EXPORT_C void CTBaseWin::ConstructExtLD(CTWinBase &aParent, const TPoint &aPos, const TSize &aSize)

   186 //

   187 // Call ConstructL, SetExt and either of these fail destroy this and leave

   188 //

   189 	{

   190 	TRAPD(err,ConstructL(aParent));

   191 	if (err!=KErrNone)

   192 		goto celd_err;

   193 	TRAP(err,SetExtL(aPos,aSize));

   194 	if (err!=KErrNone)

   195 		{

   196 celd_err:

   197 		delete this;

   198 		User::Leave(err);

   199 		}

   200 	}

   201 

   202 EXPORT_C void CTBaseWin::ConstructL(CTWinBase &aParent)

   203 	{

   204 	TInt ret;

   205 	__ASSERT_DEBUG(aParent.iOwnerWin!=NULL,TbPanic(ETestBasePanicNullOwnerWin));

   206 	iOwnerWin=aParent.iOwnerWin;

   207 	if ((ret=ConstructWin(aParent))==KErrNone)

   208 		{

   209 		//TFontSpec fspec(KTestFontTypefaceName,200);

   210 		//User::LeaveIfError(Client()->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)iFont, fspec));

   211 		TFontSpec fspec(KTestFontTypefaceName,17);

   212 		User::LeaveIfError(Client()->iScreen->GetNearestFontToDesignHeightInPixels((CFont *&)iFont, fspec));

   213 		AdjustShadow(1);

   214 		InitWin();

   215 		iSize=BaseWin()->Size();

   216 		}

   217 	User::LeaveIfError(ret);

   218 	}

   219 

   220 EXPORT_C void CTBaseWin::Activate()

   221 	{

   222 	BaseWin()->Activate();

   223 	}

   224 

   225 EXPORT_C void CTBaseWin::SetFullScreenExtL()

   226 	{

   227 	SetExtL(TPoint(0,0), Parent()->Size());

   228 	}

   229 

   230 EXPORT_C void CTBaseWin::SetDefaultExtL()

   231 	{

   232 	TSize size=Parent()->Size();

   233 	size.iWidth>>=1;

   234 	size.iHeight>>=1;

   235 	SetExtL(TPoint(size.iWidth>>1,size.iHeight>>1), size);

   236 	}

   237 

   238 EXPORT_C void CTBaseWin::AssignGC(CWindowGc &aGc)

   239 	{

   240 	iGc= &aGc;

   241 	}

   242 

   243 EXPORT_C void CTBaseWin::SetPos(const TPoint &aPos)

   244 	{

   245 	BaseWin()->SetPosition(aPos);

   246 	iPos=aPos;

   247 	}

   248 

   249 EXPORT_C void CTBaseWin::SetInitialPos(const TPoint &aPos)

   250 	{

   251 	TSize screen=Client()->iScreen->SizeInPixels();

   252 	TPoint pos(aPos);

   253 	TPoint botLeft=pos+iSize;

   254 	if (botLeft.iX>screen.iWidth)

   255 		pos.iX=Max(0,pos.iX-botLeft.iX+screen.iWidth);

   256 	if (botLeft.iY>screen.iHeight)

   257 		pos.iY=Max(0,pos.iY-botLeft.iY+screen.iHeight);

   258 	SetPos(pos);

   259 	}

   260 

   261 EXPORT_C void CTBaseWin::SetExtL(const TPoint &aPos, const TSize &aSize)

   262 	{

   263 	User::LeaveIfError(BaseWin()->SetExtentErr(aPos,aSize));

   264 	iPos=aPos;

   265 	iSize=aSize;

   266 	Resized(iSize);

   267 	}

   268 

   269 EXPORT_C void CTBaseWin::AdjustSizeL(TInt xMove,TInt yMove,TInt modifiers)

   270 	{

   271 	if (modifiers&EModifierCtrl)	// 4 times the movement

   272 		{

   273 		xMove<<=2;

   274 		yMove<<=2;

   275 		}

   276 	if (modifiers&EModifierShift)

   277 		{

   278 		TSize size(iSize.iWidth+xMove,iSize.iHeight+yMove);

   279 	

   280 		if (size.iWidth<0)

   281 			size.iWidth=0;

   282 		if (size.iHeight<0)

   283 			size.iHeight=0;

   284 		if (modifiers&EModifierCtrl)

   285 			{

   286 			TPoint pos(iPos);

   287 			pos.iX-=(xMove>>1);

   288 			pos.iY-=(yMove>>1);

   289 			SetExtL(pos,size);

   290 			}

   291 		else

   292 			SetSizeL(size);

   293 		}

   294 	else

   295 		SetPos(TPoint(iPos+TPoint(xMove,yMove)));

   296 	}

   297 

   298 EXPORT_C void CTBaseWin::SetSizeL(const TSize &aSize)

   299 	{

   300 	User::LeaveIfError(BaseWin()->SetSizeErr(aSize));

   301 	iSize=aSize;

   302 	Resized(iSize);

   303 	}

   304 

   305 EXPORT_C TSize CTBaseWin::Size() const

   306 	{

   307 	return(iSize);

   308 	}

   309 

   310 EXPORT_C void CTBaseWin::Resized(const TSize &aSize)

   311 //

   312 	{

   313 	SetDragRect(TRect(aSize));

   314 	}

   315 

   316 EXPORT_C TPoint CTBaseWin::Position() const

   317 	{

   318 	return(BaseWin()->Position());

   319 	}

   320 

   321 EXPORT_C void CTBaseWin::Delete(CTBaseWin *aWin)

   322 	{

   323 	RHeap& heap = User::Heap();

   324 	TUint8* base=heap.Base();

   325 	TInt size=heap.Size();

   326 	TUint8* cell=REINTERPRET_CAST(TUint8*,aWin);

   327 	__ASSERT_ALWAYS(base<=cell && cell<base+size, TbPanic(ETestBasePanicInvalidHeapAddress));

   328 	CTWinBase *tmp=aWin;

   329 	CTWinBase *win2;

   330 	CTBaseWin *curwin=NULL;

   331 	if (tmp->Group())

   332 		curwin=tmp->Group()->CurWin();

   333 	do

   334 		{

   335 		win2=tmp;

   336 		while((tmp=win2->Child())!=NULL)

   337 			win2=tmp;

   338 		if ((tmp=win2->NextSibling())==NULL)

   339 			tmp=win2->Parent();

   340 		if (curwin==win2)

   341 			((CTBaseWin *)win2)->RelinquishFocus();

   342 		delete win2;

   343 		} while(win2!=aWin);

   344 	}

   345 

   346 EXPORT_C void CTBaseWin::KeyUpL(const TKeyEvent &,const TTime&)

   347 	{

   348 	}

   349 

   350 EXPORT_C void CTBaseWin::KeyDownL(const TKeyEvent &,const TTime&)

   351 	{

   352 	}

   353 

   354 EXPORT_C void CTBaseWin::WinKeyL(const TKeyEvent &,const TTime&)

   355 	{

   356 	}

   357 

   358 EXPORT_C void CTBaseWin::PointerL(const TPointerEvent &aPointer,const TTime&)

   359 	{

   360 	if (iDragging)

   361 		{

   362 		if (aPointer.iType==TPointerEvent::EDrag)

   363 			SetPos(aPointer.iParentPosition-iDragPos);

   364 		else

   365 			iDragging=EFalse;

   366 		return;

   367 		}

   368 	if (aPointer.iType==TPointerEvent::EButton1Down)

   369 		{

   370 		if (aPointer.iModifiers&EModifierCtrl)

   371 			{

   372 			if (aPointer.iModifiers&EModifierShift)

   373 				BaseWin()->SetOrdinalPosition(-1);

   374 			else

   375 				BaseWin()->SetOrdinalPosition(0);

   376 			return;

   377 			}

   378 #if defined(__WINS__)

   379 		else if (aPointer.iModifiers&EModifierShift)

   380 			__DbgTestInvariant();

   381 #endif

   382 		else

   383 			{

   384 			Group()->SetCurrentWindow(this);

   385 			if (iDragRect.Contains(aPointer.iPosition))

   386 				{

   387 				iDragging=ETrue;

   388 				iDragPos=aPointer.iPosition;

   389 				return;

   390 				}

   391 			}

   392 		}

   393 	}

   394 

   395 EXPORT_C void CTBaseWin::DragDropL(const TPointerEvent &,const TTime &)

   396 	{

   397 	}

   398 

   399 EXPORT_C void CTBaseWin::AdjustOrdinal(TInt aAdjust)

   400 	{

   401 	TInt pos=BaseWin()->OrdinalPosition()+aAdjust;

   402 	if (pos>=0)

   403 		BaseWin()->SetOrdinalPosition(pos);

   404 	}

   405 

   406 EXPORT_C void CTBaseWin::AdjustShadow(TInt aAdjust)

   407 	{

   408 	iShadow+=aAdjust;

   409 	if (iShadow<0)

   410 		iShadow=0;

   411 	BaseWin()->SetShadowHeight(iShadow);

   412 	}

   413 

   414 EXPORT_C void CTBaseWin::DrawBorder()

   415 	{

   416 	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   417 	iGc->DrawRect(TRect(iSize));

   418 	iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

   419 	}

   420 

   421 EXPORT_C void CTBaseWin::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc, TDisplayMode *aMode,TBool aVisible,TInt aTransparency)

   422 	{

   423 	ConstructL(*parent);

   424 	if (aMode)

   425 		BaseWin()->SetRequiredDisplayMode(*aMode);

   426 	SetExtL(pos,size);

   427 	if (!aVisible)

   428 		BaseWin()->SetVisible(aVisible);

   429 	if (aTransparency!=ENoTransparency)

   430 		{

   431 		TInt err=((RWindow*)(BaseWin()))->SetTransparencyFactor(TRgb::_Gray256(aTransparency));	

   432 		User::LeaveIfError(err);	//asked for transparency when not got none!

   433 		}

   434 	Activate();

   435 	AssignGC(aGc);

   436 	}

   437 

   438 EXPORT_C void CTBaseWin::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc, TDisplayMode *aMode)

   439 	{

   440 	SetUpL(pos,size,parent,aGc,aMode,ETrue);

   441 	}

   442 

   443 EXPORT_C void CTBaseWin::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc,TBool aVisible)

   444 	{

   445 	SetUpL(pos,size,parent,aGc,NULL,aVisible);

   446 	}

   447 

   448 EXPORT_C void CTBaseWin::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc)

   449 	{

   450 	SetUpL(pos,size,parent,aGc,NULL,ETrue);

   451 	}

   452 

   453 EXPORT_C void CTBaseWin::SetDragRect(const TRect &aRect)

   454 	{

   455 	BaseWin()->PointerFilter(EPointerFilterDrag,0);	// Clear the drag filter

   456 	BaseWin()->SetPointerGrab(ETrue);

   457 	iDragRect=aRect;

   458 	}

   459 

   460 EXPORT_C CTWindowGroup *CTBaseWin::Group() const

   461 	{

   462 	return(iOwnerWin);

   463 	}

   464 

   465 EXPORT_C void CTBaseWin::FocusChanged(TBool )

   466 	{

   467 	}

   468 

   469 EXPORT_C CTBaseWin *CTBaseWin::Next()

   470 	{

   471 	CTWinBase *win;

   472 	CTWinBase *ret=Child();

   473 	if (ret==NULL)

   474 		{

   475 		win=this;

   476 		while((ret=win->NextSibling())==NULL)

   477 			{

   478 			ret=win;

   479 			win=win->Parent();

   480 			if (win==NULL)	// Group window

   481 				{

   482 				ret=ret->Child();

   483 				break;

   484 				}

   485 			}

   486 		}

   487 	return((CTBaseWin *)ret);

   488 	}

   489 

   490 EXPORT_C CTBaseWin *CTBaseWin::Prev()

   491 	{

   492 	CTWinBase *par=Parent();

   493 	CTWinBase *win;

   494 	CTWinBase *child;

   495 	if ((win=PrevSibling())==NULL)

   496 		{

   497 		if (par->iType==EWinTypeGroup)

   498 			{

   499 			CTWinBase *win2=par->Child();

   500 			do

   501 				{

   502 				win=win2;

   503 				while((win2=win->NextSibling())!=NULL)

   504 					win=win2;

   505 				win2=win->Child();

   506 				} while(win2!=NULL);

   507 			}

   508 		else

   509 			win=par;

   510 		}

   511 	else

   512 		{

   513 		child=win->Child();

   514 		while(child!=NULL)

   515 			{

   516 			win=child;

   517 			child=child->NextSibling();

   518 			}

   519 		}

   520 	return((CTBaseWin *)win);

   521 	}

   522 

   523 //EXPORT_C void CTBaseWin::SetDefaultExt()

   524 //	{

   525 //	TbPanic(ETestBasePanicUnimplementedBaseFunction);

   526 //	}

   527 

   528 EXPORT_C void CTBaseWin::Draw()

   529 	{

   530 	TbPanic(ETestBasePanicUnimplementedBaseFunction);

   531 	}

   532 

   533 EXPORT_C void CTBaseWin::__DbgTestInvariant() const

   534 	{

   535 	CTWinBase::__DbgTestInvariant();

   536 #if defined(__WINS__)

   537 	if (BaseWin()->Size()!=iSize)

   538 		User::Invariant();

   539 	TPoint offset;

   540 	const CTWinBase *win=this;

   541 	const CTWinBase *win2;

   542 	while((win2=win->Parent())!=NULL)

   543 		{

   544 		offset+=((CTBaseWin *)win)->BaseWin()->Position();

   545 		if (BaseWin()->InquireOffset(*(win2->WinTreeNode()))!=offset)

   546 			User::Invariant();

   547 		win=win2;

   548 		}

   549 #endif

   550 	}

   551 

   552 //CTDrawableWin//

   553 //	Drawable window					   //

   554 //

   555 

   556 EXPORT_C CTDrawableWin::CTDrawableWin(TInt aType) : CTBaseWin(aType)

   557 	{

   558 	__DECLARE_NAME(_S("CTDrawableWin"));

   559 	}

   560 

   561 //CTWin//

   562 //	Standard client window					   //

   563 //

   564 

   565 EXPORT_C CTWin::CTWin() : CTDrawableWin(EWinTypeClient)

   566 	{

   567 	__DECLARE_NAME(_S("CTWin"));

   568 	}

   569 

   570 EXPORT_C CTWin::~CTWin()

   571 	{

   572 	if (iFont)

   573 		Client()->iScreen->ReleaseFont(iFont);

   574 	iWin.Close();

   575 	}

   576 

   577 EXPORT_C TInt CTWin::ConstructWin(const CTWinBase &aParent)

   578 	{

   579 	iWin=RWindow(aParent.Client()->iWs);

   580 	return(iWin.Construct(*(aParent.WinTreeNode()),(TUint32)this));

   581 	}

   582 

   583 EXPORT_C void CTWin::SetDefaultExt()

   584 	{

   585 	TSize size=Parent()->Size();

   586 	size.iWidth>>=1;

   587 	size.iHeight>>=1;

   588 	SetExt(TPoint(size.iWidth>>1,size.iHeight>>1), size);

   589 	Invalidate();

   590 	}

   591 

   592 EXPORT_C void CTWin::SetExt(const TPoint &aPos, const TSize &aSize)

   593 	{

   594 	iWin.SetExtent(aPos,aSize);

   595 	iPos=aPos;

   596 	iSize=aSize;

   597 	Resized(iSize);

   598 	}

   599 

   600 EXPORT_C void CTWin::SetSize(const TSize &aSize)

   601 	{

   602 	iWin.SetSize(aSize);

   603 	iSize=aSize;

   604 	Resized(iSize);

   605 	}

   606 

   607 EXPORT_C void CTWin::AdjustSize(TInt xMove,TInt yMove,TInt modifiers)

   608 	{

   609 	if (modifiers&EModifierCtrl)	// 4 times the movement

   610 		{

   611 		xMove<<=2;

   612 		yMove<<=2;

   613 		}

   614 	if (modifiers&EModifierShift)

   615 		{

   616 		TSize size(iSize.iWidth+xMove,iSize.iHeight+yMove);

   617 	

   618 		if (size.iWidth<0)

   619 			size.iWidth=0;

   620 		if (size.iHeight<0)

   621 			size.iHeight=0;

   622 		if (modifiers&EModifierCtrl)

   623 			{

   624 			TPoint pos(iPos);

   625 			pos.iX-=(xMove>>1);

   626 			pos.iY-=(yMove>>1);

   627 			SetExt(pos,size);

   628 			}

   629 		else

   630 			SetSize(size);

   631 		Invalidate();

   632 		}

   633 	else

   634 		SetPos(TPoint(iPos+TPoint(xMove,yMove)));

   635 	}

   636 

   637 EXPORT_C RWindowBase *CTWin::BaseWin()

   638 	{

   639 	return((RWindowBase *)&iWin);

   640 	}

   641 

   642 EXPORT_C const RWindowBase *CTWin::BaseWin() const

   643 	{

   644 	return((const RWindowBase *)&iWin);

   645 	}

   646 

   647 EXPORT_C RDrawableWindow *CTWin::DrawableWin()

   648 	{

   649 	return((RDrawableWindow *)&iWin);

   650 	}

   651 

   652 EXPORT_C const RDrawableWindow *CTWin::DrawableWin() const

   653 	{

   654 	return((const RDrawableWindow *)&iWin);

   655 	}

   656 

   657 

   658 EXPORT_C void CTWin::Invalidate()

   659 	{

   660 	iWin.Invalidate();

   661 	}

   662 

   663 EXPORT_C void CTWin::Invalidate(const TRect &rect)

   664 	{

   665 	iWin.Invalidate(rect);

   666 	}

   667 

   668 EXPORT_C void CTWin::DrawNow()

   669 	{

   670 	iWin.Invalidate();

   671 	iWin.BeginRedraw();

   672 	iGc->Activate(iWin);

   673 	iGc->UseFont((CFont *)iFont);

   674 	Draw();

   675 	iGc->Deactivate();

   676 	iWin.EndRedraw();

   677 	}

   678 

   679 EXPORT_C void CTWin::Redraw()

   680 	{

   681 	iWin.BeginRedraw();

   682 	iGc->Activate(iWin);

   683 	iGc->UseFont((CFont *)iFont);

   684 	Draw();

   685 	iGc->Deactivate();

   686 	iWin.EndRedraw();

   687 	}

   688 

   689 EXPORT_C void CTWin::Redraw(const TRect &aRect)

   690 	{

   691 	iWin.BeginRedraw(aRect);

   692 	iGc->Activate(iWin);

   693 	iGc->UseFont((CFont *)iFont);

   694 	Draw();

   695 	iGc->Deactivate();

   696 	iWin.EndRedraw();

   697 	}

   698 

   699 //CTBackedUpWin//

   700 //	Backed up window						   //

   701 //

   702 

   703 EXPORT_C CTBackedUpWin::CTBackedUpWin(TDisplayMode aDisplayMode) : CTDrawableWin(EWinTypeClient), iDisplayMode(aDisplayMode)

   704 	{

   705 	__DECLARE_NAME(_S("CTBackedUpWin"));

   706 	}

   707 

   708 EXPORT_C CTBackedUpWin::~CTBackedUpWin()

   709 	{

   710 	if (iFont)

   711 		Client()->iScreen->ReleaseFont(iFont);

   712 	iWin.Close();

   713 	}

   714 

   715 EXPORT_C TInt CTBackedUpWin::ConstructWin(const CTWinBase &aParent)

   716 	{

   717 	iWin=RBackedUpWindow(aParent.Client()->iWs);

   718 	return(iWin.Construct(*(aParent.WinTreeNode()), iDisplayMode, (TUint32)this));

   719 	}

   720 

   721 EXPORT_C RWindowBase *CTBackedUpWin::BaseWin()

   722 	{

   723 	return((RWindowBase *)&iWin);

   724 	}

   725 

   726 EXPORT_C const RWindowBase *CTBackedUpWin::BaseWin() const

   727 	{

   728 	return((const RWindowBase *)&iWin);

   729 	}

   730 

   731 EXPORT_C RDrawableWindow *CTBackedUpWin::DrawableWin()

   732 	{

   733 	return((RDrawableWindow *)&iWin);

   734 	}

   735 

   736 EXPORT_C const RDrawableWindow *CTBackedUpWin::DrawableWin() const

   737 	{

   738 	return((const RDrawableWindow *)&iWin);

   739 	}

   740 

   741 EXPORT_C RBackedUpWindow *CTBackedUpWin::BackedUpWin()

   742 	{

   743 	return &iWin;

   744 	}

   745 

   746 EXPORT_C const RBackedUpWindow *CTBackedUpWin::BackedUpWin() const

   747 	{

   748 	return &iWin;

   749 	}

   750 

   751 //CTTitledWindow//

   752 

   753 EXPORT_C CTTitledWindow::CTTitledWindow() : CTWin(), iWinColor(TRgb(255,255,255)), iPenColor(TRgb(0,0,0))

   754 	{

   755 	__DECLARE_NAME(_S("CTTitledWin"));

   756 	}

   757 

   758 EXPORT_C CTTitledWindow::~CTTitledWindow()

   759 	{

   760 	}

   761 

   762 EXPORT_C void CTTitledWindow::ConstructL(CTWinBase &parent)

   763 	{

   764 	CTBaseWin::ConstructL(parent);

   765 	iTitleHeight=iFont->HeightInPixels()+4;

   766 	if (iTitle.Length()==0)

   767 		SetTitle(*Client()->Title());

   768 	}

   769 

   770 EXPORT_C void CTTitledWindow::SetColor(TRgb aRgb)

   771 	{

   772 	iWinColor=aRgb;

   773 	iWin.SetBackgroundColor(aRgb);

   774 	}

   775 

   776 EXPORT_C void CTTitledWindow::Resized(const TSize &aSize)

   777 	{

   778 	SetDragRect(TRect(0,0,aSize.iWidth,iTitleHeight));

   779 	}

   780 

   781 EXPORT_C void CTTitledWindow::SetTitle(const TWindowTitle &aTitle)

   782 	{

   783 	iTitle=aTitle;

   784 	}

   785 

   786 EXPORT_C void CTTitledWindow::Draw()

   787 	{

   788 	iGc->SetPenColor(iPenColor);

   789 	iGc->SetBrushColor(iWinColor);

   790 	DrawBorder();

   791 	iGc->DrawLine(TPoint(0,iTitleHeight),TPoint(iSize.iWidth,iTitleHeight));

   792 	if (Group()->HasFocus(this))

   793 		{

   794 		iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   795 		iGc->SetPenColor(~iPenColor);

   796 		iGc->SetBrushColor(~iWinColor);

   797 		}

   798 	iGc->DrawText(iTitle, TRect(1,1,iSize.iWidth-1,iTitleHeight),iFont->AscentInPixels()+1,CGraphicsContext::ECenter);

   799 	iGc->SetPenColor(iPenColor);

   800 	iGc->SetBrushColor(iWinColor);

   801 	}

   802 

   803 EXPORT_C void CTTitledWindow::FocusChanged(TBool )

   804 	{

   805 	iWin.Invalidate(TRect(0,0,iSize.iWidth,iTitleHeight));

   806 	}

   807 

   808 // CTBlankWindow //

   809 

   810 EXPORT_C CTBlankWindow::CTBlankWindow() : CTBaseWin(EWinTypeClient)

   811 	{

   812 	__DECLARE_NAME(_S("CTBlankWin"));

   813 	}

   814 

   815 EXPORT_C void CTBlankWindow::ConstructL(CTWinBase &aParent)

   816 	{

   817 	CTBaseWin::ConstructL(aParent);

   818 	}

   819 

   820 EXPORT_C CTBlankWindow::~CTBlankWindow()

   821 	{

   822 	if (iFont)

   823 		Client()->iScreen->ReleaseFont(iFont);

   824 	iWin.Close();

   825 	}

   826 

   827 EXPORT_C void CTBlankWindow::SetExt(const TPoint &aPos, const TSize &aSize)

   828 	{

   829 	iWin.SetExtent(aPos,aSize);

   830 	iPos=aPos;

   831 	iSize=aSize;

   832 	Resized(iSize);

   833 	}

   834 

   835 EXPORT_C void CTBlankWindow::SetSize(const TSize &aSize)

   836 	{

   837 	iWin.SetSize(aSize);

   838 	iSize=aSize;

   839 	Resized(iSize);

   840 	}

   841 

   842 EXPORT_C void CTBlankWindow::SetColor(const TRgb &aRgb)

   843 	{

   844 	iWin.SetColor(aRgb);

   845 	}

   846 

   847 EXPORT_C TInt CTBlankWindow::ConstructWin(const CTWinBase &aParent)

   848 	{

   849 	iWin=RBlankWindow(aParent.Client()->iWs);

   850 	return(iWin.Construct(*(aParent.WinTreeNode()),(TUint32)this));

   851 	}

   852 

   853 EXPORT_C const RWindowBase *CTBlankWindow::BaseWin() const

   854 	{

   855 	return((const RWindowBase *)&iWin);

   856 	}

   857 

   858 EXPORT_C RWindowBase *CTBlankWindow::BaseWin()

   859 	{

   860 	return((RWindowBase *)&iWin);

   861 	}

   862 

   863 //CTWindowGroup//

   864 

   865 EXPORT_C CTWindowGroup::CTWindowGroup(CTClient *aClient) : CTWinBase(EWinTypeGroup), iGroupWin(aClient->iWs)

   866 	{

   867 	__DECLARE_NAME(_S("CTWindowGroup"));

   868 	iClient=aClient;

   869 	iOwnerWin=this;

   870 	}

   871 

   872 EXPORT_C CTWindowGroup::~CTWindowGroup()

   873 	{

   874 	iGroupWin.Close();

   875 	}

   876 

   877 EXPORT_C const RWindowTreeNode *CTWindowGroup::WinTreeNode() const

   878 	{

   879 	return((const RWindowTreeNode *)&iGroupWin);

   880 	}

   881 

   882 EXPORT_C RWindowTreeNode *CTWindowGroup::WinTreeNode()

   883 	{

   884 	return((RWindowTreeNode *)&iGroupWin);

   885 	}

   886 

   887 EXPORT_C void CTWindowGroup::ConstructL()

   888 	{

   889 	User::LeaveIfError(iGroupWin.Construct((TUint32)this));

   890 	}

   891 

   892 EXPORT_C TSize CTWindowGroup::Size() const

   893 	{

   894 	return(iClient->iScreen->SizeInPixels());

   895 	}

   896 

   897 EXPORT_C void CTWindowGroup::WinKeyL(const TKeyEvent &,const TTime&)

   898 	{

   899 	}

   900 

   901 EXPORT_C void CTWindowGroup::KeyL(const TKeyEvent &aKey,const TTime&aTime)

   902 	{

   903 	if (iCurWin)

   904 		iCurWin->WinKeyL(aKey,aTime);

   905 	}

   906 

   907 EXPORT_C void CTWindowGroup::KeyUpL(const TKeyEvent &,const TTime&)

   908 	{

   909 	}

   910 

   911 EXPORT_C void CTWindowGroup::KeyDownL(const TKeyEvent &,const TTime&)

   912 	{

   913 	}

   914 

   915 EXPORT_C void CTWindowGroup::ClearCurrentWindow()

   916 	{

   917 	iCurWin=NULL;

   918 	}

   919 

   920 EXPORT_C void CTWindowGroup::SetCurrentWindow(CTBaseWin *aWindow)

   921 	{

   922 	SetCurrentWindow(aWindow, EFalse);

   923 	}

   924 

   925 EXPORT_C void CTWindowGroup::SetCurrentWindow(CTBaseWin *aWindow, TBool aLocked)

   926 	{

   927 	if (iCurWin!=aWindow)

   928 		{

   929 		if (iFocus && iCurWin)

   930 			iCurWin->FocusChanged(EFalse);

   931 		iCurWin=aWindow;

   932 		if (iFocus && iCurWin)

   933 			iCurWin->FocusChanged(ETrue);

   934 		}

   935 	iLocked=aLocked;

   936 	}

   937 

   938 EXPORT_C CTBaseWin *CTWindowGroup::CurWin(void) const

   939 	{

   940 	return(iCurWin);

   941 	}

   942 

   943 EXPORT_C void CTWindowGroup::FocusLost()

   944 	{

   945 	iFocus=EFalse;

   946 	if (iCurWin)

   947 		iCurWin->FocusChanged(EFalse);

   948 	}

   949 

   950 EXPORT_C void CTWindowGroup::FocusGained()

   951 	{

   952 	iFocus=ETrue;

   953 	if (iCurWin)

   954 		iCurWin->FocusChanged(ETrue);

   955 	}

   956 

   957 EXPORT_C TBool CTWindowGroup::HasFocus(CTBaseWin *aWin) const

   958 	{

   959 	return(iFocus && iCurWin==aWin);

   960 	}

   961 

   962 EXPORT_C CTClient *CTWindowGroup::Client() const

   963 	{

   964 	return(iClient);

   965 	}

   966 

   967 EXPORT_C CTWindowGroup *CTWindowGroup::Group() const

   968 	{

   969 	return((CTWindowGroup *)this);

   970 	}

   971 

   972 EXPORT_C void CTWindowGroup::PasswordL(const TTime &)

   973 	{

   974 	TbPanic(ETestBasePanicPassword);

   975 	}

   976 

   977 EXPORT_C void CTWindowGroup::MessageReady(const TWsEvent &)

   978 //

   979 // Dummy handler for un-exepected messages (could panic, but better not as the app sending the messages fault really not ours)

   980 //

   981 	{

   982 	}

   983 

   984 EXPORT_C void CTWindowGroup::ScreenDeviceChanged()

   985 	{

   986 	TPixelsAndRotation sizeAndRotation;

   987 	Client()->iScreen->GetDefaultScreenSizeAndRotation(sizeAndRotation);

   988 	Client()->iScreen->SetScreenSizeAndRotation(sizeAndRotation);

   989 	}

   990 

   991 EXPORT_C void CTWindowGroup::UserEvent(TInt /*aEventType*/)

   992 	{

   993 	}

   994 

   995 

   996 // CTClient //

   997 

   998 EXPORT_C CTClient::CTClient()

   999 	{

  1000 	__DECLARE_NAME(_S("CTClient"));

  1001 	}

  1002 

  1003 EXPORT_C void CTClient::DestroyWindows()

  1004 	{

  1005 	if (iGroup)

  1006 		{

  1007 		CTBaseWin *win;

  1008 		if (iGroup->GroupWin()->WsHandle()!=0)	// Check it was created okay

  1009 			while((win=iGroup->Child())!=NULL && ((TUint)win)!=ENullWsHandle)

  1010 				CTBaseWin::Delete(win);

  1011 		delete iGroup;

  1012 		iGroup=NULL;

  1013 		}

  1014 	}

  1015 

  1016 EXPORT_C CTClient::~CTClient()

  1017 	{

  1018 	DestroyWindows();

  1019 	delete iGc;

  1020 	delete iEventHandler;

  1021 	delete iRedrawEventHandler;

  1022 	delete iScreen;

  1023 	TInt count=iWs.ResourceCount();

  1024 	__ASSERT_ALWAYS(count==0,TbPanic(ETestBasePanicResourceCount));

  1025 	iWs.Close();

  1026 	}

  1027 

  1028 EXPORT_C void CTClient::ConstructEventHandlerL()

  1029 	{

  1030 	iEventHandler=new(ELeave) CTEvent(&iWs);

  1031 	iEventHandler->Construct();

  1032 	}

  1033 

  1034 EXPORT_C void CTClient::ConstructL()

  1035 	{

  1036 	User::LeaveIfError(iWs.Connect());

  1037 	iScreen=new(ELeave) CWsScreenDevice(iWs);

  1038 	User::LeaveIfError(iScreen->Construct(iScreenNumber));

  1039 	iRedrawEventHandler=new(ELeave) CTRedraw(&iWs);

  1040 	iRedrawEventHandler->Construct();

  1041 	ConstructEventHandlerL();

  1042 	iGc=new(ELeave) CWindowGc(iScreen);

  1043 	User::LeaveIfError(iGc->Construct());

  1044 	iTitle.Copy(RThread().FullName());

  1045 	}

  1046 

  1047 EXPORT_C void CTClient::ResetFocus()

  1048 	{

  1049 	iGroup->ClearCurrentWindow();

  1050 	iGroup->SetCurrentWindow(iGroup->Child());

  1051 	}

  1052 

  1053 EXPORT_C TWindowTitle *CTClient::Title()

  1054 	{

  1055 	return(&iTitle);

  1056 	}

  1057 

  1058 EXPORT_C TBool CTClient::QueueRead()

  1059 	{

  1060 	TBool ret=iEventHandler->IsActive();

  1061 	if (ret==EFalse)

  1062 		iEventHandler->Request();

  1063 	return(ret);

  1064 	}

  1065 

  1066 EXPORT_C void CTClient::CancelRead()

  1067 	{

  1068 	iEventHandler->Cancel();

  1069 	}

  1070 

  1071 EXPORT_C void CTClient::SetCancelFunction(const TCallBack &aCallBack)

  1072 	{

  1073 	iEventHandler->SetCancelFunction(aCallBack);

  1074 	}

  1075 

  1076 EXPORT_C void CTClient::CancelRedrawRead()

  1077 	{

  1078 	iRedrawEventHandler->Cancel();

  1079 	}

  1080 

  1081 EXPORT_C void CTClient::SetRedrawCancelFunction(const TCallBack &aCallBack)

  1082 	{

  1083 	iRedrawEventHandler->SetCancelFunction(aCallBack);

  1084 	}

  1085 

  1086 EXPORT_C void CTClient::RequestRedraw()

  1087 	{

  1088 	iRedrawEventHandler->Request();

  1089 	}

  1090 

  1091 EXPORT_C void CTClient::LogMessage(const TLogMessageText &aMessage)

  1092 	{

  1093 	iWs.LogMessage(aMessage);

  1094 	iWs.Flush();

  1095 	}

  1096 

  1097 EXPORT_C TBool CTClient::IsEventWaiting()

  1098 	{

  1099 	iWs.NumWindowGroups();		//Make sure all asyncronus calls have finished

  1100 	return (iEventHandler->iStatus!=KRequestPending);

  1101 	}

  1102 

  1103 TBool CTClient::WaitUntilEventPending(const TRequestStatus& aStatus)

  1104 	{

  1105 	if (aStatus!=KRequestPending)

  1106 		return ETrue;

  1107 	User::After(2000000);		//Need something smarter than this

  1108 	return (aStatus!=KRequestPending);

  1109 	}

  1110 

  1111 EXPORT_C TBool CTClient::WaitUntilRedrawPending()

  1112 	{

  1113 	return WaitUntilEventPending(iRedrawEventHandler->iStatus);

  1114 	}

  1115 

  1116 EXPORT_C TBool CTClient::WaitUntilEventPending()

  1117 	{

  1118 	return WaitUntilEventPending(iEventHandler->iStatus);

  1119 	}

  1120 

  1121 EXPORT_C TInt CTClient::WaitForRedrawsToFinish()

  1122 	{

  1123 	return WaitForEventsToFinish(EFalse);

  1124 	}

  1125 

  1126 EXPORT_C TInt CTClient::WaitForAllEventProcessingToFinish()

  1127 	{

  1128 	return WaitForEventsToFinish(ETrue);

  1129 	}

  1130 

  1131 TInt CTClient::WaitForEventsToFinish(TBool aAll)

  1132 	{

  1133 	CStopTheScheduler* stop=new CStopTheScheduler(this,ETlibRedrawActivePriority-1,aAll);

  1134 	if (!stop)

  1135 		return KErrNoMemory;

  1136 	stop->Call();

  1137 	CActiveScheduler::Start();

  1138 	delete stop;

  1139 	return KErrNone;

  1140 	}

  1141 

  1142 

  1143 // CStopTheScheduler //

  1144 

  1145 void CStopTheScheduler::RunL()

  1146 	{

  1147 #ifdef __WINS__

  1148 	RDebug::Print(_L("CStopTheScheduler::RunL - enter - %d"), iCStopTheSchedulerRunCount);

  1149 #endif

  1150 	if (iClient)

  1151 	    {

  1152 		iClient->iWs.NumWindowGroups();		//Make sure all asyncronus calls have finished

  1153 	    }

  1154 	

  1155 	if (!iClient || (iClient->RedrawHandler()->iStatus==KRequestPending && (!iAll || iClient->EventHandler()->iStatus==KRequestPending)))

  1156 	    {

  1157 #ifdef __WINS__

  1158 	    RDebug::Print(_L("CStopTheScheduler::RunL - Stop - %d"), iCStopTheSchedulerRunCount);

  1159 #endif

  1160 	    CActiveScheduler::Stop();

  1161 	    }

  1162 	else

  1163 	    {  

  1164 #ifdef __WINS__

  1165 	    RDebug::Print(_L("CStopTheScheduler::RunL - Call - %d"), iCStopTheSchedulerRunCount);

  1166 #endif

  1167 	    Call();

  1168 	    }

  1169 #ifdef __WINS__

  1170     RDebug::Print(_L("CStopTheScheduler::RunL - exit - %d"), iCStopTheSchedulerRunCount);

  1171     iCStopTheSchedulerRunCount++;

  1172 #endif

  1173 	}

  1174 

  1175 void WaitForRedrawsToFinish()

  1176 	{

  1177 	CStopTheScheduler* ps=new CStopTheScheduler(ETlibRedrawActivePriority-1);

  1178 	if(ps)

  1179 		{

  1180 		ps->Call();

  1181 		CActiveScheduler::Start();

  1182 		delete ps;

  1183 		}

  1184 	}

  1185 

  1186 

  1187 // CTEventBase //

  1188 

  1189 EXPORT_C CTEventBase::CTEventBase(RWsSession *aWs, TInt aPriority) : CActive(aPriority), iWs(aWs)

  1190 	{

  1191 	}

  1192 

  1193 EXPORT_C CTEventBase::~CTEventBase()

  1194 	{

  1195 	}

  1196 

  1197 EXPORT_C void CTEventBase::Construct()

  1198 	{

  1199 	CActiveScheduler::Add(this);

  1200 	Request();

  1201 	}

  1202 

  1203 EXPORT_C void CTEventBase::RunL()

  1204 	{

  1205 	if (iStatus==KErrNone)

  1206 		{

  1207 		++iCount;

  1208 		TRAPD(err,doRunL());

  1209 		if (err<=0)	// Positive value means this has been destroyed

  1210 			{

  1211 			if (iCancelRequested)

  1212 				CancelHandler();

  1213 			Request();

  1214 //			if (err!=KErrNone)

  1215 //				User::LeaveIfError(err); Should have a guaranteed to work error dialog here I guess

  1216 			}

  1217 		}

  1218 	else if (iStatus==KErrCancel && iCancelRequested)

  1219 		{

  1220 		CancelHandler();

  1221 		Request();

  1222 		}

  1223 	else

  1224 		TbPanic(ETestBasePanicEventStat);

  1225 	}

  1226 

  1227 void CTEventBase::SetCancelFunction(const TCallBack &aCallBack)

  1228 	{

  1229 	if (!IsActive() && iCancelRequested)

  1230 		TbPanic(ETestBasePanicCancelFunction);

  1231 	iCancelCallBack=aCallBack;

  1232 	iCancelRequested=ETrue;

  1233 	DoCancel();

  1234 	}

  1235 

  1236 EXPORT_C void CTEventBase::CancelHandler()

  1237 	{

  1238 	iCancelCallBack.CallBack();

  1239 	iCancelRequested=EFalse;

  1240 	}

  1241 

  1242 // TLibWsEvent //

  1243 

  1244 EXPORT_C CTWindowGroup *TlibWsEvent::WindowGroup()

  1245 	{

  1246 	CTWindowGroup *group=(CTWindowGroup *)Handle();

  1247 	__ASSERT_DEBUG(group->iType==EWinTypeGroup,TbPanic(ETestBasePanicWinType));

  1248 	return(group);

  1249 	}

  1250 

  1251 EXPORT_C CTBaseWin *TlibWsEvent::BaseWin()

  1252 	{

  1253 	CTBaseWin *win=(CTBaseWin *)Handle();

  1254 	__ASSERT_DEBUG(win->iType==EWinTypeClient || win->iType==EWinTypeGroup,TbPanic(ETestBasePanicWinType));

  1255 	return(win);

  1256 	}

  1257 

  1258 // CTEvent //

  1259 

  1260 EXPORT_C CTEvent::CTEvent(RWsSession *aWs) : CTEventBase(aWs, ETlibWsEventActivePriority)

  1261 	{

  1262 	__DECLARE_NAME(_S("CTEvent"));

  1263 	}

  1264 

  1265 EXPORT_C CTEvent::~CTEvent()

  1266  	{

  1267 	Cancel();

  1268 	}

  1269 

  1270 EXPORT_C void CTEvent::DoCancel()

  1271 	{

  1272 	iWs->EventReadyCancel();

  1273 	}

  1274 

  1275 EXPORT_C void CTEvent::Request()

  1276 	{

  1277 	iWs->EventReady(&iStatus);

  1278 	SetActive();

  1279 	}

  1280 

  1281 EXPORT_C void CTEvent::LogEvent(const TWsEvent &)

  1282 	{

  1283 	}

  1284 

  1285 EXPORT_C void CTEvent::doRunL()

  1286 	{

  1287 	TlibWsEvent event;

  1288 	

  1289 	iWs->GetEvent(event);

  1290 	LogEvent(event);

  1291 	if (event.Handle()!=0 && event.Handle()!=ENullWsHandle)

  1292 		{

  1293 		switch(event.Type())

  1294 			{

  1295 			case EEventKey:

  1296 				event.WindowGroup()->KeyL(*event.Key(),event.Time());

  1297 				break;

  1298 			case EEventKeyDown:

  1299 				__ASSERT_ALWAYS(event.Key()->iCode==0 && event.Key()->iRepeats==0, TbPanic(ETestBasePanicKeyParams));

  1300 				event.WindowGroup()->KeyDownL(*event.Key(),event.Time());

  1301 				break;

  1302 			case EEventKeyUp:

  1303 				__ASSERT_ALWAYS(event.Key()->iCode==0 && event.Key()->iRepeats==0, TbPanic(ETestBasePanicKeyParams));

  1304 				event.WindowGroup()->KeyUpL(*event.Key(),event.Time());

  1305 				break;

  1306 			case EEventModifiersChanged:

  1307 				event.BaseWin()->ModifiersChanged(*event.ModifiersChanged(),event.Time());

  1308 				break;

  1309 			case EEventPointer:

  1310 				event.BaseWin()->PointerL(*event.Pointer(),event.Time());

  1311 				break;

  1312 			case EEventDragDrop:

  1313 				event.BaseWin()->DragDropL(*event.Pointer(),event.Time());

  1314 				break;

  1315 			case EEventPointerEnter:

  1316 				event.BaseWin()->PointerEnter(event.Time());

  1317 				break;

  1318 			case EEventPointerExit:

  1319 				event.BaseWin()->PointerExit(event.Time());

  1320 				break;

  1321 			case EEventPointerBufferReady:

  1322 				event.BaseWin()->PointerBufferReady(event.Time());

  1323 				break;

  1324 			case EEventSwitchOn:

  1325 				event.BaseWin()->SwitchOn(event.Time());

  1326 				break;

  1327 			case EEventFocusLost:

  1328 				event.WindowGroup()->FocusLost();

  1329 				break;

  1330 			case EEventFocusGained:

  1331 				event.WindowGroup()->FocusGained();

  1332 				break;

  1333 			case EEventPassword:

  1334 				event.WindowGroup()->PasswordL(event.Time());

  1335 				break;

  1336 			case EEventMessageReady:

  1337 				event.WindowGroup()->MessageReady(event);

  1338 				break;

  1339 			case EEventErrorMessage:

  1340 				event.WindowGroup()->ErrorMessage(*event.ErrorMessage(), event.Time());

  1341 				break;

  1342 			case EEventSwitchOff:

  1343 			case EEventKeySwitchOff:

  1344 				{

  1345 				TTimeIntervalMicroSeconds32 ii=1000000;

  1346 				User::After(ii);			//WINS does not always work without this!

  1347 				UserHal::SwitchOff();

  1348 				}

  1349 				break;

  1350 			case EEventScreenDeviceChanged:

  1351 				event.WindowGroup()->ScreenDeviceChanged();

  1352 				break;

  1353 			case EEventNull:

  1354 				break;

  1355 			default:

  1356 				if (event.Type()>=EEventUser)

  1357 					{

  1358 					event.WindowGroup()->UserEvent(event.Type());

  1359 					break;

  1360 					}

  1361 				else

  1362 					{

  1363 					//if not in BufferSecurity test - panic

  1364 					TInt value = EFalse;

  1365 					TInt err = RProperty::Get(KUidWServSecurityTesting,EWServSecTestBufferSecurity,value);

  1366 					if ((err != KErrNone) || (value != (TInt)ETrue))

  1367 						TbPanic(ETestBasePanicInvalidEvent);

  1368 					}

  1369 				break;

  1370 			}

  1371 		}

  1372 	}

  1373 

  1374 EXPORT_C CTRedraw::CTRedraw(RWsSession *aWs) : CTEventBase(aWs, ETlibRedrawActivePriority)

  1375 	{

  1376 	__DECLARE_NAME(_S("CTRedraw"));

  1377 	}

  1378 

  1379 EXPORT_C CTRedraw::~CTRedraw()

  1380 	{

  1381 	Cancel();

  1382 	}

  1383 

  1384 EXPORT_C void CTRedraw::Request()

  1385 	{

  1386 	iWs->RedrawReady(&iStatus);

  1387 	SetActive();

  1388 	}

  1389 

  1390 EXPORT_C void CTRedraw::DoCancel()

  1391 	{

  1392 	iWs->RedrawReadyCancel();

  1393 	}

  1394 

  1395 EXPORT_C void CTRedraw::doRunL()

  1396 	{

  1397 	TWsRedrawEvent redraw;

  1398 	iWs->GetRedraw(redraw);

  1399 	if (redraw.Handle()!=0 && redraw.Handle()!=ENullWsHandle)

  1400 		{

  1401 		__ASSERT_ALWAYS(!redraw.Rect().IsEmpty(),TbPanic(ETestBasePanicNullRedraw));

  1402 		((CTWin *)redraw.Handle())->Redraw(redraw.Rect());

  1403 		}

  1404 	}

  1405 

  1406 EXPORT_C void CTUser::Splat(CTClient *aClient, const TRect &aRect, const TRgb &aRgb)

  1407 	{

  1408 	RBlankWindow win(aClient->iWs);

  1409 	win.Construct(*(aClient->iGroup->WinTreeNode()),1);

  1410 	win.SetColor(aRgb);

  1411 	win.SetExtent(aRect.iTl,aRect.Size());

  1412 	win.Activate();

  1413 	aClient->iWs.Flush();

  1414 	win.Close();

  1415 	}

  1416 

  1417 void doTestLibStartUpL(TInt aScreenNumber, CTClient *&aClient, CActiveScheduler *&aActiveScheduler,CTrapCleanup *&aCleanUpStack,TCreateClientFunc aFunc)

  1418 	{

  1419 	User::LeaveIfNull(aCleanUpStack=CTrapCleanup::New());

  1420 	aActiveScheduler=new(ELeave) CActiveScheduler;

  1421 	CActiveScheduler::Install(aActiveScheduler);

  1422 	aClient=aFunc();

  1423 	aClient->SetScreenNumber(aScreenNumber);

  1424 	aClient->ConstructL();

  1425 	CActiveScheduler::Start();

  1426 	}

  1427 

  1428 EXPORT_C TInt TestLibStartUp(TCreateClientFunc aFunc,TInt aScreenNumber)

  1429 	{

  1430 	__UHEAP_MARK;

  1431 	CTrapCleanup* cleanUpStack=NULL;

  1432 	CActiveScheduler *activeScheduler=NULL;

  1433 	CTClient *client=NULL;

  1434 	TRAPD(err,doTestLibStartUpL(aScreenNumber, client,activeScheduler,cleanUpStack,aFunc));

  1435 	delete client;

  1436 	delete activeScheduler;

  1437 	delete cleanUpStack;

  1438 	__UHEAP_MARKEND;

  1439 	return(err);

  1440 	}

  1441 

  1442 EXPORT_C TInt TestLibStartUp(TCreateClientFunc aFunc)

  1443 	{

  1444 	return TestLibStartUp(aFunc, KDefaultScreen);

  1445 	}

  1446
Symaptic