diff -r 000000000000 -r bde4ae8d615e os/graphics/windowing/windowserver/test/t_stress/src/compwin.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/windowing/windowserver/test/t_stress/src/compwin.cpp Fri Jun 15 03:10:57 2012 +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(" ")); + } + 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); + } + } + } +