--- /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 <coeaui.h>
+#include <coemain.h>
+#include <coedef.h>
+#include <coesndpy.h>
+#include <basched.h>
+#include <bassnd.h>
+#include <coeccntx.h>
+#include <ecom/ecom.h>
+#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();
+ }