diff -r 000000000000 -r 2f259fa3e83a lafagnosticuifoundation/cone/tef/TConeVisibility.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lafagnosticuifoundation/cone/tef/TConeVisibility.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,279 @@ +// Copyright (c) 2005-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: +// framework visibility event receipt and dispatch to registered message monitor observers. +// Creates a three control(window) application (main control(window) and two children). +// The two children are flagged to windows server as generators of visibility events. +// The application is registered to the framework as a message monitor observer and handles the relevant TWsVisibilityChangedEvent messages. +// One window is moved on and off the other window and the visibility status is compared to that expected. +// The visibility status returned should match the status of the control as visible or not visible, which is handled +// specifically in each test step. +// +// + +/** + @file + @internalComponent - Internal Symbian test code + @SYMTestCaseID UIF-Cone-TConeVisibility + @SYMPREQ 915 + @SYMTestCaseDesc + @SYMTestPriority Medium + @SYMTestStatus Implemented + @SYMTestActions + @SYMTestExpectedResults +*/ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include "TConeVisibility.h" +#include "gdi.h" + + +//Draw the control, different colours are used depending on status although this is for cosmetic purposes and is not required +//by the test. +void CVisibleControl::Draw(const TRect& aRect) const + { + + CWindowGc& gc=SystemGc(); + + TRect rc = Rect(); + + gc.SetClippingRect(aRect); + + gc.SetPenColor(KRgbBlack); + + switch (iStatus) + { + case EPartial: gc.SetBrushColor(KRgbBlue); break; + case EHidden: gc.SetBrushColor(KRgbRed); break; + case EPartiallyVisible: gc.SetBrushColor(KRgbGreen); break; + case ENone: gc.SetBrushColor(KRgbYellow); break; + case EFullyVisible: gc.SetBrushColor(KRgbMagenta); break; + default: gc.SetBrushColor(KRgbBlack); break; + } + + gc.SetBrushStyle(CGraphicsContext::ESolidBrush); + gc.DrawRect(rc); + gc.CancelClippingRect(); + + } + + +//Construct the main background control. A parent control with two child controls that receive visibility events. +void CVisibilityBackground::ConstructL() + { + CreateWindowL(); + SetExtent(TPoint(20,20),TSize(600,200)); + + iControl1 = new (ELeave) CVisibleControl(); + iControl1->CreateWindowL(this); + iControl1->SetExtent(TPoint(200,36),TSize(128,128)); + iControl1->ActivateL(); + + iControl2 = new (ELeave) CVisibleControl(); + iControl2->CreateWindowL(this); + iControl2->SetExtent(TPoint(200,36),TSize(128,128)); + iControl2->ActivateL(); + + //Enable visibility events for both these windows. + iControl1->DrawableWindow()->EnableVisibilityChangeEvents(); + iControl2->DrawableWindow()->EnableVisibilityChangeEvents(); + + ActivateL(); + } + + +//Destruction of the main control content +CVisibilityBackground::~CVisibilityBackground() + { + delete iControl1; + delete iControl2; + } + + +//Standard implementation +CTConeVisibilityAppUi::CTConeVisibilityAppUi(CTmsTestStep* aStep) : +CTestCoeAppUi(aStep) +{} + +//Destruction of the application +CTConeVisibilityAppUi::~CTConeVisibilityAppUi() + { + RemoveFromStack(iViewControl); + delete iViewControl; + } + + +//Standard Implementation +void CTConeVisibilityAppUi::ConstructL() + { + CTestCoeAppUi::ConstructL(); + + iViewControl=new(ELeave) CVisibilityBackground(); + iViewControl->ConstructL(); + AddToStackL(iViewControl); + + //Register this MCoeVisibilityChangeObserver class as a cone visibility observer. + CCoeEnv::Static()->AddMessageMonitorObserverL(*this); + + AutoTestManager().StartAutoTest(); + } + +//Standard Implementation +TKeyResponse CTConeVisibilityAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType) + { + TKeyResponse ret=EKeyWasNotConsumed; + if (aType==EEventKey && aKeyEvent.iCode==CTRL('e')) + { + CBaActiveScheduler::Exit(); + ret=EKeyWasConsumed; + } + return ret; + } + +//The test case/steps, not that the TEST statement compares the result for the PREVIOUS test step. +void CTConeVisibilityAppUi::RunTestStepL(TInt aStepNum) + { + switch (aStepNum) + { + case 1: + SetTestStepID( _L("UIF-cone-TConeVisibility")); + //Overlap control1 (expect visible) + iViewControl->iControl2->SetExtent(TPoint(300,36),TSize(128,128)); + iViewControl->iControl2->ControlEnv()->WsSession().Flush(); + User::After(TTimeIntervalMicroSeconds32(1000000)); + break; + + case 2: + //Test result 1 + TEST(iViewControl->iControl1->iStatus == CVisibleControl::EPartiallyVisible); + + //Occlude control1 (expect hidden) + iViewControl->iControl2->SetExtent(TPoint(200,36),TSize(128,128)); + iViewControl->iControl2->ControlEnv()->WsSession().Flush(); + User::After(TTimeIntervalMicroSeconds32(1000000)); + break; + + case 3: + //Test result 2 + TEST(iViewControl->iControl1->iStatus == CVisibleControl::EHidden); + + //Set next to control1 the window, not-overlapped (expect visible) + iViewControl->iControl2->SetExtent(TPoint(450,36),TSize(128,128)); + iViewControl->iControl2->ControlEnv()->WsSession().Flush(); + User::After(TTimeIntervalMicroSeconds32(1000000)); + break; + + case 4: + //Test result 3 + TEST( iViewControl->iControl1->iStatus == CVisibleControl::EPartiallyVisible | CVisibleControl::EFullyVisible); + + //Occlude control1 (expect hidden) + iViewControl->iControl2->SetExtent(TPoint(200,36),TSize(128,128)); + iViewControl->iControl2->ControlEnv()->WsSession().Flush(); + User::After(TTimeIntervalMicroSeconds32(1000000)); + break; + + case 5: + //Test result 4 + TEST(iViewControl->iControl1->iStatus == CVisibleControl::EHidden); + break; + + case 6: + //Unregister this MCoeVisibilityChangeObserver. + CCoeEnv::Static()->RemoveMessageMonitorObserver(*this); + RecordTestResultL(); + CloseTMSGraphicsStep(); + break; + + default: + AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass); + } + } + +//Overidden visibility message monitor/ + +void CTConeVisibilityAppUi::MonitorWsMessage(const TWsEvent& aEvent) +{ + //Check for visibility events, the only event we are interested in + if (aEvent.Type() == EEventWindowVisibilityChanged) + { + const TWsVisibilityChangedEvent *pVC = aEvent.VisibilityChanged(); + + //The window handle for cone controls is the CCoeControl pointer. We know we only receive + //events on specific windows so it is safe to cast them. + CVisibleControl *pControl = REINTERPRET_CAST(CVisibleControl *, aEvent.Handle()); + + if (pControl) + { + //Set the received visibility status of this control + pControl->iStatus = pVC->iFlags; + //Call a redraw event. + pControl->DrawDeferred(); + } + } +} + +//Construct application +void CTConeVisibilityStep::ConstructAppL(CCoeEnv* aCoe) + { // runs inside a TRAP harness + aCoe->ConstructL(); + CTConeVisibilityAppUi* appUi= new (ELeave) CTConeVisibilityAppUi(this); + aCoe->SetAppUi(appUi); + appUi->ConstructL(); + + } + +//Default implementation +CTConeVisibilityStep::CTConeVisibilityStep() + { + SetTestStepName(KTConeVisibilityStep); + } + +//Default implementation +CTConeVisibilityStep::~CTConeVisibilityStep() + {} + +//Default implementation +TVerdict CTConeVisibilityStep::doTestStepL() // main function called by E32 + { + INFO_PRINTF1(_L("Test Started")); + + PreallocateHALBuffer(); + + __UHEAP_MARK; + CCoeEnv* coe=new(ELeave) CCoeEnv; + TRAPD(err,ConstructAppL(coe)); + + if (!err) + coe->ExecuteD(); + else + { + SetTestStepResult(EFail); + delete coe; + } + + REComSession::FinalClose(); + + __UHEAP_MARKEND; + + INFO_PRINTF1(_L("Test Finished")); + return TestStepResult(); + }