// 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();
	}