MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/graphics/windowing/windowserver/test/t_eventchecker/src/openwfc/scenechecker.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 2008-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 //

    15 

    16 #include "scenechecker.h"

    17 #include <graphics/wselement.h>

    18 #include "panics.h"

    19 

    20 CSceneChecker* CSceneChecker::NewL(MWsGraphicDrawerEnvironment& /*aEnv*/, MWsScreen& aScreen)

    21 	{

    22 	CSceneChecker* self = new(ELeave) CSceneChecker(aScreen);

    23 	return self;

    24 	}

    25 

    26 CSceneChecker::CSceneChecker(MWsScreen& aScreen)

    27 	: iScreen(aScreen)

    28 	{

    29 	}

    30 

    31 CSceneChecker::~CSceneChecker()

    32 	{

    33 	iScene = NULL;

    34 	iBottomElement = NULL;

    35 	iElementsWithoutAssociatedWindow.Reset();

    36 	}

    37 

    38 void CSceneChecker::SetScene(MWsScene* aScene)

    39 	{

    40 	iScene = aScene;

    41 	}

    42 

    43 void CSceneChecker::OnEnd()

    44 	{

    45 	if(iElementSetChanged)

    46 		{

    47 		if(!iBottomElement)

    48 			{

    49 			CHK_ASSERT_ALWAYS(iElementSetCount == 0, EEventCheckerPanicElementCountMismatch);

    50 			return;

    51 			}

    52 

    53 		//walk upwards

    54 		MWsElement* layer = iBottomElement;

    55 		CHK_ASSERT_ALWAYS(!layer->ElementBelow(), EEventCheckerPanicElementLinksMismatch);

    56 		TInt index = 0;

    57 		while(layer->ElementAbove())

    58 			{

    59 			MWsElement* previousElement = layer;

    60 			layer = layer->ElementAbove();

    61 			index++;

    62 			CHK_ASSERT_ALWAYS(layer->ElementBelow() == previousElement, EEventCheckerPanicElementLinksMismatch);

    63 			}

    64 		CHK_ASSERT_ALWAYS(iElementSetCount == index + 1, EEventCheckerPanicElementCountMismatch);

    65 		//walk downwards

    66 		CHK_ASSERT_ALWAYS(!layer->ElementAbove(), EEventCheckerPanicElementLinksMismatch);

    67 		while(layer->ElementBelow())

    68 			{

    69 			MWsElement* previousElement = layer;

    70 			layer = layer->ElementBelow();

    71 			index--;

    72 			CHK_ASSERT_ALWAYS(layer->ElementAbove() == previousElement, EEventCheckerPanicElementLinksMismatch);

    73 			}

    74 		CHK_ASSERT_ALWAYS(layer == iBottomElement, EEventCheckerPanicElementLinksMismatch);

    75 		CHK_ASSERT_ALWAYS(index == 0, EEventCheckerPanicElementLinksMismatch);

    76 		}

    77 

    78 	CHK_ASSERT_ALWAYS(iElementsWithoutAssociatedWindow.Count() == 0, EEventCheckerPanicElementsWithoutAssociatedWindow);

    79 	}

    80 	

    81 TAny* CSceneChecker::ResolveObjectInterface(TUint aTypeId)

    82 	{

    83 	switch(aTypeId)

    84 		{

    85 		case MWsWindowTreeObserver::EWsObjectInterfaceId:

    86 			return static_cast<MWsWindowTreeObserver*>(this);

    87 		}	

    88 	return iScene->ResolveObjectInterface(aTypeId);

    89 	}

    90 

    91 TInt CSceneChecker::SetSceneRotation(TSceneRotation aRotation)

    92 	{

    93 	return iScene->SetSceneRotation(aRotation);

    94 	}

    95 

    96 MWsScene::TSceneRotation CSceneChecker::SceneRotation() const

    97 	{

    98 	return iScene->SceneRotation();

    99 	}

   100 

   101 MWsElement* CSceneChecker::CreateSceneElementL()

   102 	{

   103 	return iScene->CreateSceneElementL();

   104 	}

   105 

   106 void CSceneChecker::DestroySceneElement(MWsElement* aElement)

   107 	{

   108 	if(iBottomElement == aElement || aElement->ElementAbove() || aElement->ElementBelow()) //part of the layer set

   109 		{

   110 		iElementSetCount--;

   111 		iElementSetChanged = ETrue;

   112 		if(aElement == iBottomElement)

   113 			iBottomElement = iBottomElement->ElementAbove();

   114 		}

   115 	iScene->DestroySceneElement(aElement);

   116 	}

   117 

   118 void CSceneChecker::ComposePendingScene(TSurfaceId& aOffScreenTarget, TRequestStatus* aCompleted)

   119 	{

   120 	iScene->ComposePendingScene(aOffScreenTarget, aCompleted);

   121 	}

   122 

   123 TInt CSceneChecker::InsertSceneElement(MWsElement* aInsertElement, MWsElement* aSubordinateElement)

   124 	{

   125 	TInt err = KErrNone;

   126 

   127 	iElementSetCount++;

   128 	iElementSetChanged = ETrue;

   129 	

   130     if(!aSubordinateElement)

   131         {

   132         iBottomElement = aInsertElement;

   133         }

   134     else if(aInsertElement == iBottomElement)

   135         {

   136         iBottomElement = iBottomElement->ElementAbove();

   137         }

   138     

   139     TUint32 flags;

   140     aInsertElement->GetRenderStageFlags(flags);

   141 	if(!(flags & MWsElement::EElementIsIndirectlyRenderedUserInterface)) //the UI element won't be associated with any window

   142 		{

   143 		err = iElementsWithoutAssociatedWindow.Append(aInsertElement);

   144 		}

   145 	

   146 	if(!err)

   147 		err = iScene->InsertSceneElement(aInsertElement, aSubordinateElement);

   148 

   149 	//cleanup on error

   150 	if(err)

   151 		{

   152 		const TInt index = iElementsWithoutAssociatedWindow.Find(aInsertElement);

   153 		if(index >= 0)

   154 			iElementsWithoutAssociatedWindow.Remove(index);

   155 		}

   156 

   157 	return err;

   158 	}

   159 

   160 TInt CSceneChecker::RemoveSceneElement(MWsElement* aRemoveElement)

   161 	{

   162 	iElementSetCount--;

   163 	iElementSetChanged = ETrue;

   164 	if(aRemoveElement == iBottomElement)

   165 		iBottomElement = iBottomElement->ElementAbove();

   166 	return iScene->RemoveSceneElement(aRemoveElement);

   167 	}

   168 

   169 TInt CSceneChecker::RegisterSurface(const TSurfaceId& aSurface)

   170 	{

   171 	return iScene->RegisterSurface(aSurface);

   172 	}

   173 

   174 TInt CSceneChecker::UnregisterSurface(const TSurfaceId& aSurface)

   175 	{

   176 	return iScene->UnregisterSurface(aSurface);

   177 	}

   178 

   179 void CSceneChecker::NodeCreated(const MWsWindowTreeNode& /*aWindowTreeNode*/, MWsWindowTreeNode const* /*aParent*/)

   180 	{

   181 	}

   182 

   183 void CSceneChecker::NodeReleased(const MWsWindowTreeNode& /*aWindowTreeNode*/)

   184 	{

   185 	}

   186 

   187 void CSceneChecker::NodeActivated(const MWsWindowTreeNode& /*aWindowTreeNode*/)

   188 	{

   189 	}

   190 

   191 void CSceneChecker::NodeExtentChanged(const MWsWindowTreeNode& /*aWindowTreeNode*/, const TRect& /*aRect*/)

   192 	{

   193 	}

   194 

   195 void CSceneChecker::SiblingOrderChanged(const MWsWindowTreeNode& /*aWindowTreeNode*/, TInt /*aNewPosition*/)

   196 	{

   197 	}

   198 

   199 void CSceneChecker::MovedToWindowGroup(const MWsWindowTreeNode& /*aWindowTreeNode*/, const MWsWindowTreeNode& /*aNewWindowGroup*/)

   200 	{

   201 	}

   202 

   203 void CSceneChecker::FlagChanged(const MWsWindowTreeNode& /*aWindowTreeNode*/, MWsWindowTreeObserver::TFlags /*aAttribute*/, TBool /*aNewValue*/)

   204 	{

   205 	}

   206 

   207 void CSceneChecker::AttributeChanged(const MWsWindowTreeNode& /*aWindowTreeNode*/, MWsWindowTreeObserver::TAttributes /*aAttribute*/)

   208 	{

   209 	}

   210 

   211 void CSceneChecker::TransparentRegionChanged(const MWsWindowTreeNode& /*aWindowTreeNode*/, const TRegion& /*aNewTransparentRegion*/, const TRegion* /*aNewOpaqueRegion*/)

   212 	{

   213 	}

   214 

   215 void CSceneChecker::ElementAdded(const MWsWindowTreeNode& aWindowTreeNode, const MWsElement& aElement)

   216 	{

   217 	CHK_ASSERT_ALWAYS(aWindowTreeNode.Window(), EEventCheckerPanicAcquireElementWithoutWindow);

   218 	MWsScreen* eventScreen = aWindowTreeNode.Window()->WsScreen();

   219 	if(eventScreen == &iScreen)

   220 		{

   221 		const TInt index = iElementsWithoutAssociatedWindow.Find(&aElement);

   222 		CHK_ASSERT_ALWAYS(index >= 0, EEventCheckerPanicAcquireElementForUnknownElement);

   223 		iElementsWithoutAssociatedWindow.Remove(index);

   224 		}

   225 	}

   226 

   227 void CSceneChecker::FadeCountChanged(const MWsWindowTreeNode& /*aWindowTreeNode*/, TInt /*aFadeCount*/)

   228 	{

   229 	}

   230 

   231 void CSceneChecker::FadeAllChildren(const MWsWindowTreeNode& /*aWindowTreeNode*/, TBool /*aFaded*/)

   232 	{

   233 	}

   234 

   235 void CSceneChecker::WindowGroupChained(const MWsWindowTreeNode& /*aParent*/, const MWsWindowTreeNode& /*aChild*/)

   236 	{

   237 	}

   238 

   239 void CSceneChecker::WindowGroupChainBrokenAfter(const MWsWindowTreeNode& /*aWindowGroup*/)

   240 	{

   241 	}

   242 

   243
Symaptic