// 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:

// Test adds a control factory function and resource file to the application.\n  

// 

//

/**

 @file

 @internalComponent - Internal Symbian test code

*/

#include <basched.h>

#include <eikenv.h>

#include <eikappui.h>

#include <techview/eikon.hrh>

#include <eikapp.h>

#include <eikdoc.h>

#include <techview/eiklabel.h>

#include <eikfctry.h>

#include <coecntrl.h>

#include <barsread.h>

#include "TADDLIB.HRH"

#include <external.rsg>

#include <techview/eiktbar.h>

#include <techview/eikmenub.h>

#include <eikspane.h>

#include <ecom/ecom.h>

_LIT(KTAddLibResourceFilePath, "");

#include "Taddlib.h"

/**

   Auxiliary function for refreshing Label

   This method is an override from CEikLabel. It draws the label control.

 */ 

void CTestLabel::Draw(const TRect& aRect) const

	{

	CWindowGc& gc=SystemGc();

	gc.SetPenColor(KRgbBlack);

	CEikLabel::Draw(aRect);

	}

CTestContainer::CTestContainer(CTestAppUi* aAppUi)

	: iResourceFile(_L("z:\\system\\test\\taddlib\\external.rsc")),

	iAppUi(aAppUi)

/**

   Constructor

 */

	{

	}

void CTestContainer::ConstructL(const TRect& aRect)

    {

    CreateWindowL();

    Window().SetShadowDisabled(ETrue);

	Window().SetBackgroundColor(KRgbWhite);

 	SetRect(aRect);

	ActivateL();

    }

/**

   @SYMTestCaseID UIF-AddLib-AddLibraryL

   @SYMPREQ

   @SYMTestCaseDesc Tests CEikonEnv::AddLibraryL() method.

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions The test case tests whether the specified control factory

   function and resource file are added to their respective lists by

   CEikonEnv::AddLibraryL(). The method verifies this by checking whether

   CEikonEnv::AddLibraryL() returns a non-zero value for the resource file

   offset indicating successful addition.\n

   API Calls:\n	

   TInt CEikonEnv::AddLibraryL(TCreateByTypeFunction aControlFactory, TFileName* aResourceFile)\n

   @SYMTestExpectedResults On successful addition of the specified control

   factory function and resource file, CEikonEnv::AddLibraryL() should

   return a non-zero value.

 */

void CTestContainer::AddLibraryL()

    {

	if(iResFileOffset)

		{

		iEikonEnv->InfoMsg(_L("Library already added!"));

		return;

		}

	iAppUi->INFO_PRINTF1(_L("ADD LOCAL CONTROL FACTORY AND RESOURCE FILE TO THE EIKON ENVIRONMENT"));

	iResFileOffset = iEikonEnv->AddLibraryL(CreateByTypeL, &iResourceFile);

	iAppUi->TEST(iResFileOffset >= 0);

	iEikonEnv->InfoMsg(_L("Library added."));

    }

/**

   @SYMTestCaseID UIF-AddLib_RemoveLibrary

   @SYMPREQ

   @SYMTestCaseDesc Tests CEikonEnv::RemoveLibrary() method.

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions The test case tests whether the specified control factory

   function and the resource file identified by the resource file offset

   specified as parameters are removed from their respective lists by

   CEikonEnv::RemoveLibrary().\n

   API Calls:\n	

   void CEikonEnv::RemoveLibrary(TCreateByTypeFunction aControlFactory, TInt aResourceFileOffset)\n

   @SYMTestExpectedResults The test removes the control factory function

   and the resource file which was previously added.

 */

void CTestContainer::RemoveLibrary()

    {

	if(!iResFileOffset)

		{

		iEikonEnv->InfoMsg(_L("No library to remove."));

		return;

		}

	iAppUi->INFO_PRINTF1(_L("FREE UP THE CONTROL FACTORY AND RESOURCE FILE MEMORY FROM EIKENV"));

	iEikonEnv->RemoveLibrary(CreateByTypeL, iResFileOffset);

	delete iLabel;

	iLabel = NULL;

	iResFileOffset = 0;

	iEikonEnv->InfoMsg(_L("Library removed."));

	DrawNow();

    }

/**

   Auxiliary function for TestCaseID T-AddLib-RunL

   This method is used by CTestContainer::RunL() to create the applications

   control. This method calls the control factory function

   CTestContainer::CreateByTypeL() to create the control. The method then uses

   Cone to construct the control by reading information from the resource

   file that was added.

 */

TBool CTestContainer::CreateControlL()

	{

	TBool ret = EFalse;

	if(!iLabel)

		{

		iAppUi->INFO_PRINTF1(_L("ASK THE EIKON CONTROL FACTORY TO CREATE THIS APPLICATION'S CONTROL\n"));

		SEikControlInfo controlInfo = EikControlFactory::CreateByTypeL(ECtTestLabel);

		if(controlInfo.iControl)

			{

			iAppUi->INFO_PRINTF1(_L("Control successfully created\n"));

			iLabel = STATIC_CAST(CTestLabel*, controlInfo.iControl);

			iAppUi -> TEST(iLabel != NULL);

			iLabel->SetContainerWindowL(*this);

			iLabel->SetControlContext(iLabel);

			iAppUi->INFO_PRINTF1(_L("ASK CONE TO CONSTRUCT THIS APPLICATION'S CONTROL FROM THE LOCAL RESOURCE FILE\n"));

			TResourceReader reader;

			iCoeEnv->CreateResourceReaderLC(reader,R_TESTADDLIB_LABEL);

			iLabel->ConstructFromResourceL(reader);

			CleanupStack::PopAndDestroy();

			iLabel->SetRect(TRect(TPoint(260,110),iLabel->MinimumSize()));

			iLabel->ActivateL();

			ret = ETrue;

			}

		}

	// Control already created

	else ret = ETrue;

	return ret;

	}

/**

   @SYMTestCaseID UIF-AddLib-RunL

   @SYMPREQ

   @SYMTestCaseDesc Tests Creation of Applications Control.

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions The test initiates creation of applications control and

   draws it on the container. \n

   @SYMTestExpectedResults The test should create controls by reading

   information from the resource file and should display them.

 */

void CTestContainer::RunL()

    {

	if(CreateControlL())

		DrawNow();

	else iEikonEnv->InfoMsg(_L("Must add library first!"));

    }

CTestContainer::~CTestContainer()

/**

   Destructor

 */

    {

	delete iLabel;

    }

/**

   Auxiliary function for TestCaseID T-AddLib-RunL

   This method is an override from CCoeControl. It returns the number of

   controls contained in a compound control.

 */

TInt CTestContainer::CountComponentControls() const

    {

	if(iLabel)

		return 1;

	else

		return 0;

    }

/**

   Auxiliary function for TestCaseID T-AddLib-RunL

   This method is an override from CCoeControl. It returns the label component

   from the container control. 

 */  

CCoeControl* CTestContainer::ComponentControl(TInt aIndex) const

    {			 

	switch (aIndex)

		{

		case 0:

		default:

			return iLabel;

		}

	}

/**

   Auxiliary function for refreshing Container

   This method is an override from CCoeControl. It draws the container control.

 */ 

void CTestContainer::Draw(const TRect& aRect) const

    {

   	CWindowGc& gc=SystemGc();

	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

	gc.SetBrushColor(KRgbGray);

	gc.SetPenStyle(CGraphicsContext::ESolidPen);

	gc.SetPenColor(KRgbWhite);

	gc.DrawRect(aRect);

    }

/**

   Auxiliary function for TestCaseID T-AddLib-RunL

   This method is the control factory function for this Application.

   It is called by CTestContainer::CreateControlL() to create label control.

   The method returns the structure SEikControlInfo which contains the

   control information for the control.

 */  

SEikControlInfo CTestContainer::CreateByTypeL(TInt aControlType)

	{	

	SEikControlInfo controlInfo;

	controlInfo.iControl = NULL;

	controlInfo.iTrailerTextId = 0;

	controlInfo.iFlags = 0;

    switch (aControlType)

        {

    case ECtTestLabel:

		controlInfo.iControl = new(ELeave) CTestLabel;

		break;

		}

	return controlInfo;

	}

CTestAddLibraryAppUi::CTestAddLibraryAppUi(CTmsTestStep*		aStep, const TDesC& aRes) :

	CTestAppUi(	aStep, aRes)

/**

   Constructor

 */

	{

	}

CTestAddLibraryAppUi::~CTestAddLibraryAppUi()

/**

   Destructor

 */

	{

	RemoveFromStack(iContainer);

	delete iContainer;

	}

/**

   Auxiliary function for all Test Cases

   The method creates a container and sets active object with lowest

   priority for running test in auto mode.

 */

void CTestAddLibraryAppUi::ConstructL()

	{

	CTestAppUi::ConstructL();

	TRect boundingRect=ClientRect(); // make toolband stretch to the screen width by default

    iContainer=new(ELeave) CTestContainer(this);

	ReduceRect(boundingRect);

	iContainer->ConstructL(boundingRect);

    AddToStackL(iContainer);

	AutoTestManager().StartAutoTest();

	}

/**

   Auxiliary function for all Test Cases

   The method is an override from CTestAppUi. The method initiates all tests

   to be performed by calling CTestAddLibraryAppUi::HandleCommandL().

 */

void CTestAddLibraryAppUi::RunTestStepL(TInt aStep)

	{

	TInt theProgramState = 0;

//#ifdef FORCE_AUTO

	User::After(TTimeIntervalMicroSeconds32(1000000));

//#endif	

	switch (aStep)

		{

	case 1:

		INFO_PRINTF1(_L("Adding library\n"));

		SetTestStepID(_L("UIF-AddLib-AddLibraryL"));

		theProgramState = ECmdAddLibrary;

		RecordTestResultL();

		break;

	case 2:

		INFO_PRINTF1(_L("Run library\n"));

		SetTestStepID(_L("UIF-AddLib-RunL"));

		theProgramState = ECmdRun;

		RecordTestResultL();

		break;

	case 3:

		INFO_PRINTF1(_L("Removing library\n"));

		SetTestStepID(_L("UIF-AddLib_RemoveLibrary"));

		theProgramState = ECmdRemoveLibrary;

		RecordTestResultL();

		CloseTMSGraphicsStep();

		break;

	case 5:

		theProgramState = EEikCmdExit;

		break;

		}

	HandleCommandL(theProgramState);							

	}

/**

   Auxiliary function for all Test Cases

   This method is called by CTestAddLibraryAppUi::RunTestStepL() to initiate

   the tests.

 */

void CTestAddLibraryAppUi::HandleCommandL(TInt aCommand)

	{

	switch (aCommand)

		{

	case ECmdAddLibrary:

		if(iContainer)

			{

			iContainer->AddLibraryL();

			}

		break;

	case ECmdRemoveLibrary:

		if(iContainer)

			{

			iContainer->RemoveLibrary();

			}

		break;

	case ECmdRun:

		if(iContainer)

			{

			iContainer->RunL();

			}

		break;

	case EEikCmdExit:

		if(iContainer)

			{

			iContainer->RemoveLibrary();

			iCoeEnv->Flush();

			}

		Exit();

		break;

		}

	}

//----------

CTestAddLibraryStep::CTestAddLibraryStep()

/**

   Constructor

 */

	{

	SetTestStepName(KTestAddLibraryStep);

	}

CTestAddLibraryStep::~CTestAddLibraryStep()

/**

   Destructor

 */

	{

	}

/**

   Auxiliary function for all Test Cases

   The method creates & sets the application's user interface object.

 */

void CTestAddLibraryStep::ConstructAppL(CEikonEnv* aCoe)

    { // runs inside a TRAP harness

	aCoe->ConstructL();

	CTestAppUi* appUi= new (ELeave) CTestAddLibraryAppUi(this,KTAddLibResourceFilePath);

    aCoe->SetAppUi(appUi);

    appUi->ConstructL();

    }

/**

   Auxiliary function for all Test Cases

   The method creates & sets the application's user interface object to

   launch the application which will initiate the tests.

 */

TVerdict CTestAddLibraryStep::doTestStepL() // main function called by E32

	{

	PreallocateHALBuffer();

	__UHEAP_MARK;

	CEikonEnv* coe=new CEikonEnv;

	TRAPD(err,ConstructAppL(coe));

	if (!err)

		coe->ExecuteD();

		REComSession::FinalClose();	

		__UHEAP_MARKEND;

	return TestStepResult();

	}