--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/test/t_stress/src/compwin.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,466 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+/**
+ @file
+ @test
+ @internalComponent
+*/
+
+#include "compwin.h"
+#include "utils.h"
+#include "crpwin.h"
+#include "edgedwin.h"
+#include "coordinatewin.h"
+#include "backedupwin.h"
+#include "enormouswin.h"
+#include "spritewin.h"
+#include "animatedwin.h"
+
+#include "test_step_logger.h"
+#include "test_step_comparison.h"
+#include "stresslet.h"
+#include "comparison.h"
+
+//static configuration data, definitions and default assignments
+TInt CCompWin::sBackgroundAlpha = 0;
+
+//configuration parameter names
+_LIT(KT_WservStressParamBackgroundAlpha, "background_alpha");
+
+
+/**
+BASE COMPARISON WINDOW
+*/
+CCompWin* CCompWin::NewLC(RWsSession& aWs, RWindowGroup* aGroup, CCompWin* aParent, CWindowGc& aGc)
+	{
+	typedef CCompWin* (*TPtrNewLC)(RWsSession&, RWindowGroup*, CCompWin*, CWindowGc&);
+	TPtrNewLC winFactory[8];
+	TInt numEnabledWindows = 0;
+
+	//setup an array of factory functions, one for each enabled window type
+	if (CAnimatedWin::IsEnabled())   
+		{
+		winFactory[numEnabledWindows++] = TPtrNewLC(CAnimatedWin::NewLC);
+		}
+	if (CCoordinateWin::IsEnabled()) 
+		{
+		winFactory[numEnabledWindows++] = TPtrNewLC(CCoordinateWin::NewLC);
+		}
+	if (CBackedupWin::IsEnabled())   
+		{
+		winFactory[numEnabledWindows++] = TPtrNewLC(CBackedupWin::NewLC);
+		}
+	if (CEnormousWin::IsEnabled())   
+		{
+		winFactory[numEnabledWindows++] = TPtrNewLC(CEnormousWin::NewLC);
+		}
+	if (CCrpWin::IsEnabled())        
+		{
+		winFactory[numEnabledWindows++] = TPtrNewLC(CCrpWin::NewLC);
+		}
+	if (CEdgedWin::IsEnabled())      
+		{
+		winFactory[numEnabledWindows++] = TPtrNewLC(CEdgedWin::NewLC);
+		}
+	if (CSpritedWin::IsEnabled())    
+		{
+		winFactory[numEnabledWindows++] = TPtrNewLC(CSpritedWin::NewLC);
+		}
+
+	if (numEnabledWindows == 0)
+		{
+		aWs.LogMessage(_L("Error: No window-type is enabled(see ini file)"));
+		User::Leave(KErrNotFound);
+		}
+	
+	TInt winType = TRnd::rnd(numEnabledWindows);
+	CCompWin* self = winFactory[ winType ](aWs, aGroup, aParent, aGc);
+	return self;
+	}
+
+void CCompWin::LoadConfiguration(const MTestStepConfigurationContext* aContext)
+	{
+	aContext->GetInt(KT_WservStressParamBackgroundAlpha, sBackgroundAlpha);
+	}
+
+/**
+ Get a random TDrawMode value.
+ */
+CGraphicsContext::TDrawMode CCompWin::GetRandomDrawMode()
+	{
+	static CGraphicsContext::TDrawMode modes[] =
+		{
+		CGraphicsContext::EDrawModeAND, CGraphicsContext::EDrawModeNOTAND, 
+		CGraphicsContext::EDrawModePEN, CGraphicsContext::EDrawModeANDNOT,
+		CGraphicsContext::EDrawModeXOR, CGraphicsContext::EDrawModeOR, 
+		CGraphicsContext::EDrawModeNOTANDNOT, CGraphicsContext::EDrawModeNOTXOR,
+		CGraphicsContext::EDrawModeNOTSCREEN, CGraphicsContext::EDrawModeNOTOR, 
+		CGraphicsContext::EDrawModeNOTPEN, CGraphicsContext::EDrawModeORNOT,
+		CGraphicsContext::EDrawModeNOTORNOT, CGraphicsContext::EDrawModeWriteAlpha
+		};
+	return modes[TRnd::rnd(sizeof(modes)/sizeof(CGraphicsContext::TDrawMode))];
+	}
+
+CGraphicsContext::TPenStyle CCompWin::GetRandomPenStyle()
+	{
+	static CGraphicsContext::TPenStyle styles[] = 
+		{
+		CGraphicsContext::ENullPen,
+		CGraphicsContext::ESolidPen,
+		CGraphicsContext::EDottedPen,
+		CGraphicsContext::EDashedPen,
+		CGraphicsContext::EDotDashPen,
+		CGraphicsContext::EDotDotDashPen
+		};
+	return styles[TRnd::rnd(sizeof(styles)/sizeof(CGraphicsContext::TPenStyle))];
+	}
+
+CGraphicsContext::TBrushStyle CCompWin::GetRandomBrushStyle()
+	{
+	//CGraphicsContext::EPatternedBrush is not joined in the test in current version.
+	static CGraphicsContext::TBrushStyle styles[] = 
+		{
+		CGraphicsContext::ENullBrush,
+		CGraphicsContext::ESolidBrush,
+		CGraphicsContext::EVerticalHatchBrush,
+		CGraphicsContext::EForwardDiagonalHatchBrush,
+		CGraphicsContext::EHorizontalHatchBrush,
+		CGraphicsContext::ERearwardDiagonalHatchBrush,
+		CGraphicsContext::ESquareCrossHatchBrush,
+		CGraphicsContext::EDiamondCrossHatchBrush
+		};
+	return styles[TRnd::rnd(sizeof(styles)/sizeof(CGraphicsContext::TBrushStyle))];
+	}
+
+CCompWin::CCompWin(RWsSession& aWs, RWindowGroup* aGroup, CCompWin* aParent, CWindowGc& aGc) :
+	iWs(aWs),
+	iGroup(aGroup),
+	iParent(aParent),
+	iWsGc(aGc)
+	{
+	}
+
+CCompWin::~CCompWin()
+	{
+	iChildren.ResetAndDestroy();
+	
+	if (iParent)
+		{
+		iParent->RemoveChild(this);
+		}
+
+	if (iWindow)
+		{
+		iWindow->Close();
+		delete iWindow;
+		}
+	}
+
+void CCompWin::PreConstructL(TBool aTransparency, TBool aBackedup)
+	{
+	if (aBackedup)
+		{
+		iWindow = iBackedupWindow = new(ELeave) RBackedUpWindow(iWs);
+		if (iParent)
+			{
+			User::LeaveIfError(iBackedupWindow->Construct(*iParent->Window(), EColor64K, (TUint32)(this)));
+			iParent->AddChildL(this);
+			}
+		else
+			{
+			User::LeaveIfError(iBackedupWindow->Construct(*iGroup, EColor64K, (TUint32)(this)));
+			}
+		}
+	else
+		{
+		iWindow = iRedrawWindow = new(ELeave) RWindow(iWs);
+		if (iParent)
+			{
+			User::LeaveIfError(iRedrawWindow->Construct(*iParent->Window(), (TUint32)(this)));
+			iParent->AddChildL(this);
+			}
+		else
+			{
+			User::LeaveIfError(iRedrawWindow->Construct(*iGroup, (TUint32)(this)));
+			}
+		}
+	if (iRedrawWindow)
+		{
+		if (aTransparency)
+			{
+			iRedrawWindow->SetTransparencyAlphaChannel();
+			}
+		/* Note: if background color is set to include a transparent background
+		 * and AUTOCLEAR is set to 1 in wsini.ini, window's background will not be
+		 * totaly cleared.
+		 */
+		iRedrawWindow->SetBackgroundColor(BackgroundColor());
+		}
+
+	iPos.iX = TRnd::rnd(KPosLimit);
+	iPos.iY = TRnd::rnd(KPosLimit);
+	iSize.iWidth = TRnd::rnd(KPosLimit);
+	iSize.iHeight = TRnd::rnd(KPosLimit);
+	iPos.iX -= iSize.iWidth / 2;
+	iPos.iY -= iSize.iHeight / 2;
+	SetPos(iPos);
+	SetSize(iSize);
+	iWindow->SetOrdinalPosition(0);
+	}
+	
+void CCompWin::PostConstructL()
+	{
+	iVisible = ETrue;
+	iWindow->Activate();
+	}
+	
+void CCompWin::SetPos(const TPoint & aPos)
+	{
+	iPos = aPos;
+	iWindow->SetPosition(iPos);
+	}
+
+void CCompWin::SetSize(const TSize & aSize)
+	{
+	iSize = aSize;
+	TInt err = iWindow->SetSizeErr(iSize);
+	if (err != KErrNone)
+		{
+		__DEBUGGER();
+		}
+	if (iRedrawWindow)
+		{
+		iRedrawWindow->Invalidate();
+		}
+	else if (iBackedupWindow)
+		{
+		Redraw(aSize);
+		}
+	}
+
+
+void CCompWin::BringToFrontL()
+	{
+	if (iParent)
+		{
+		iParent->RemoveChild(this);
+		iParent->AddChildL(this);
+		}
+	iWindow->SetOrdinalPosition(0);
+	}
+
+void CCompWin::SendToBackL()
+	{
+	if (iParent)
+		{
+		iParent->RemoveChild(this);
+		iParent->iChildren.Insert(this, 0);
+		iWindow->SetOrdinalPosition(-1);
+		}
+	}
+
+void CCompWin::RemoveChild(CCompWin* aChild)
+	{
+	TInt num = iChildren.Find(aChild);
+	if (num != KErrNotFound)
+		{
+		iChildren.Remove(num);
+		}
+	}
+
+void CCompWin::AddChildL(CCompWin* aChild)
+	{
+	CleanupStack::PushL(aChild);
+	User::LeaveIfError(iChildren.Append(aChild));
+	CleanupStack::Pop(aChild);
+	}
+
+CCompWin * CCompWin::RandomWindow()
+	{
+	TInt num = TRnd::rnd(iChildren.Count() + 1);
+	
+	if (num == iChildren.Count())
+		{
+		return this;
+		}
+	else
+		{
+		return iChildren[num]->RandomWindow();
+		}
+	}
+
+void CCompWin::ToggleVisible()
+	{
+	iVisible = !iVisible;
+	iWindow->SetVisible(iVisible);
+	}
+
+void CCompWin::Dump(RFile& aFile, TPoint& aOrigin, TInt aDepth, CCompWin * aMark)
+	{
+	TPoint abs = aOrigin + iPos;
+	static TBuf8<256> buf;
+	buf.SetLength(0);
+	for (TInt d = 0; d < aDepth; ++d)
+		{
+		buf.Append(_L8("  "));
+		}
+	buf.Append(_L8("rel ["));
+	buf.AppendNum((TInt64)iPos.iX);
+	buf.Append(_L8(","));
+	buf.AppendNum((TInt64)iPos.iY);
+	buf.Append(_L8("] abs ["));
+	buf.AppendNum((TInt64)abs.iX);
+	buf.Append(_L8(","));
+	buf.AppendNum((TInt64)abs.iY);
+	buf.Append(_L8("] size ["));
+	buf.AppendNum((TInt64)iSize.iWidth);
+	buf.Append(_L8(","));
+	buf.AppendNum((TInt64)iSize.iHeight);
+	buf.Append(_L8("] "));
+	if (iVisible)
+		{
+		buf.Append(_L8("visible "));
+		}
+	else
+		{
+		buf.Append(_L8("invisible "));
+		}
+	buf.Append(TypeName());
+	if (this == aMark)
+		{
+		buf.Append(_L8(" <active>"));
+		}
+	buf.Append(_L8("\r\n"));
+	aFile.Write(buf);
+	
+	DumpDetails(aFile, aDepth);
+	
+	for (TInt num = 0; num < iChildren.Count(); ++num)
+		{
+		iChildren[num]->Dump(aFile, abs, aDepth + 1, aMark);
+		}
+	}
+
+void CCompWin::DumpDetails(RFile&, TInt)
+	{
+	}
+
+void CCompWin::HandleRedraw(TWsRedrawEvent& aEvent)
+	{
+	Redraw(aEvent.Rect());
+	}
+
+void CCompWin::DrawBitmap(CFbsBitGc* aGc, TRect& aClip, TPoint& aOrigin)
+	{
+	if (aClip.Width() > 0 && aClip.Height() > 0)
+		{
+		TPoint origin = iPos + aOrigin;
+		TRect clip(origin, iSize);
+		clip.Intersection(aClip);
+
+		for (TInt num = 0; num < iChildren.Count(); ++num)
+			{
+			if (iChildren[num]->iVisible)
+				{
+				iChildren[num]->DrawBitmap(aGc, clip, origin);
+				}
+			}
+		}
+	}
+
+/**
+ Fills window's background with it's background color, 
+ then iterates visible children
+ */
+void CCompWin::ClearBitmapBackground(CFbsBitGc* aGc, TRect& aClip, TPoint& aOrigin)
+	{
+	if (aClip.Width() > 0 && aClip.Height() > 0)
+		{
+		TPoint origin = iPos + aOrigin;
+		TRect clip(origin, iSize);
+		clip.Intersection(aClip);
+
+		aGc->Reset();
+		aGc->SetOrigin(TPoint(0,0));
+		aGc->SetPenColor(BackgroundColor());
+		aGc->SetBrushColor(BackgroundColor());
+		aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+		aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+		aGc->DrawRect(clip);
+
+		for (TInt num = 0; num < iChildren.Count(); ++num)
+			{
+			if (iChildren[num]->iVisible)
+				{
+				iChildren[num]->ClearBitmapBackground(aGc, clip, origin);
+				}
+			}
+		}
+	}
+
+TBool CCompWin::QueryReadyForVerification()
+	{
+	TBool res = ETrue;
+	
+	TInt idx = 0;
+
+	while ( idx < iChildren.Count() && res )
+		{
+		res = iChildren[ idx ]->QueryReadyForVerification();
+		idx++;
+		}
+	
+	return res;	
+	}
+
+/**	
+ Subtracts window region from the supplied region 
+ then calls all children to subtract themsleves
+ @param aRegion region from which current window are should be subtructed
+ @param aClip clipping area provided by the parent window
+ @param aOrigin absolute origin of parent
+ */
+void CCompWin::SubSelfFromRegion(TRegion& aRegion, const TRect& aClip, const TPoint& aOrigin)
+	{
+	if (!iVisible)
+		{
+		return;
+		}
+	TPoint origin = iPos + aOrigin;
+	TRect clip(origin, iSize);
+	clip.Intersection(aClip);
+	aRegion.SubRect(clip);
+	for (TInt num = 0; num < iChildren.Count(); ++num)
+		{
+		if (iChildren[num]->iVisible)
+			{
+			iChildren[num]->SubSelfFromRegion(aRegion, clip, origin);
+			}
+		}
+	}
+
+void CCompWin::SetVerifyTick(TUint32 aTick)
+	{
+	iVerifyTick = aTick;
+	for (TInt num = 0; num < iChildren.Count(); ++num)
+		{
+		if (iChildren[num]->iVisible)
+			{
+			iChildren[num]->SetVerifyTick(aTick);
+			}
+		}
+	}
+