// Copyright (c) 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:

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code 

*/

#include "cmultiplesurfaces.h"

#include "tsmallwindowraster.h"

const TInt KTimeBetweenFrames = 100000; // checks every 100 ms for a new message

// messages which are sent by the test step

const TInt KBringToFront = 1;

const TInt KTerminate = 2;

// defines number of windows on the screen

const TInt KWindowsAcross = 1;

const TInt KWindowsDown = 1;

_LIT(KSmallBitmap,"z:\\resource\\apps\\cover2.jpg"); // bitmap that is displayed by the windows

CMultipleSurfaces* CMultipleSurfaces::NewL(RWsSession& aWs, RWindowGroup& aWindowGroup, TPtrC childQueueName, CMultipleSurfacesAppUi* aMultipleSurfacesAppUi, TPtrC aParentQueueName)

    {

    CMultipleSurfaces* self = new (ELeave)CMultipleSurfaces(aWs, aWindowGroup, aMultipleSurfacesAppUi);

    self->ConstructL(childQueueName, aParentQueueName);

    return self;

    }

CMultipleSurfaces::CMultipleSurfaces(RWsSession& aWs, RWindowGroup& aWindowGroup, CMultipleSurfacesAppUi* aMultipleSurfacesAppUi) :

        iWs(aWs), iWindowGroup(aWindowGroup), iMultipleSurfacesAppUi(aMultipleSurfacesAppUi)

	{

	// empty

	}

CMultipleSurfaces::~CMultipleSurfaces()

    {

    delete iTimer;

    iParentMsgQueue.Send(KTerminate);

    iParentMsgQueue.Close();

    iMsgQueue.Close();

    for (TInt w = 0; w < iSmallWindows.Count(); w++)

        {

        delete iSmallWindows[w];

        }

    iSmallWindows.Close();

    }

void CMultipleSurfaces::ConstructL(TPtrC childQueueName, TPtrC aParentQueueName)

    {

    iTimer = CPeriodic::NewL(CActive::EPriorityIdle);

    // available screensize is reduced by the menu bar

    TSize screenSize = iMultipleSurfacesAppUi->ClientRect().Size();

    TSize windowSize;

    windowSize.iHeight = screenSize.iHeight/KWindowsDown;

    windowSize.iWidth = screenSize.iWidth/KWindowsAcross;

    // adjust window size to make square windows

    if (windowSize.iWidth > windowSize.iHeight)

        {

        windowSize.iWidth = windowSize.iHeight;

        }

    else

        {

        windowSize.iHeight = windowSize.iWidth;

        }

    // available screensize is reduced by the menu bar

    TPoint initialPosition(iMultipleSurfacesAppUi->ClientRect().iTl);

    CSurfaceUtility* utility = CSurfaceUtility::NewL();

    CleanupStack::PushL(utility);

    CTWindow* smallWindow;

    for (TInt i = 0; i < KWindowsAcross; i++)

        {

        initialPosition.iX = 0;

        for (TInt j = 0; j < KWindowsDown; j++)

            {

            smallWindow = CTSmallWindowRaster::NewL(iWs, iWindowGroup, initialPosition, windowSize);

            CleanupStack::PushL(smallWindow);

            smallWindow->LoadL(utility, KSmallBitmap());

            iSmallWindows.AppendL(smallWindow);

            CleanupStack::Pop(smallWindow);

            initialPosition.iX += windowSize.iWidth;

            }

        initialPosition.iY += windowSize.iHeight;

        }

    CleanupStack::PopAndDestroy(utility);

    User::LeaveIfError(iMsgQueue.OpenGlobal(childQueueName));

    User::LeaveIfError(iParentMsgQueue.OpenGlobal(aParentQueueName));

    // inform test app that the message queues are ready

    RProcess::Rendezvous(KErrNone);

    }

/**

 * Starts a timer which redraws the screen periodically.

 */

void CMultipleSurfaces::Start()

	{

	iTimer->Start(0, KTimeBetweenFrames, TCallBack(TimerCallBack, this));

	}

TInt CMultipleSurfaces::TimerCallBack(TAny* MultipleSurfaces)

	{

	TRAPD(err, static_cast<CMultipleSurfaces*>(MultipleSurfaces)->RenderL());

	return err;

	}

/**

 * Meassures the time it takes to bring this application to the foreground.

 * It receives a message from the test step which coordinates the switching.

 */

void CMultipleSurfaces::RenderL()

	{

	TInt msg = 0;

    iMsgQueue.ReceiveBlocking(msg);

    for (TInt w = 0; w < iSmallWindows.Count(); w++)

        {

        iSmallWindows[w]->Move(0, 1);

        iSmallWindows[w]->RenderL();

        }

    iWs.Flush();

    iWs.Finish();	    

    switch (msg)

        {

        case KBringToFront:

            {

            TUint32 timeStamp = User::FastCounter();

            iMultipleSurfacesAppUi->BringToFront();

            TUint32 time = User::FastCounter() - timeStamp;

            iParentMsgQueue.Send(time);

            break;

            }

        case KTerminate:

            {

            Stop();

            iMultipleSurfacesAppUi->Terminate();

            break;

            }

        }    

	}

/**

 * Stops the timer.

 */

void CMultipleSurfaces::Stop()

	{

	if(iTimer)

		{

		iTimer->Cancel();

		}	

	}