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

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code 

*/

#include "tscale.h"

#include "te_gesturegenerator.h"

#include "twindow.h"

_LIT(KSemaphore, "SemTScaleSync"); // Name of the global semaphore

const TInt KGestureGenerationLimit = 50;

// Test bitmap file location

_LIT(KBigBitmap,"z:\\resource\\apps\\uibench_s60_big.mbm");

_LIT(KTestStep0007,"GRAPHICS-UI-BENCH-S60-0007");

CTScale::CTScale()

	{

	SetTestStepName(KTScale);	

	}

TVerdict CTScale::doTestStepPreambleL()

    {

    // The semaphore has to be created before, otherwise the control can't open it.

    TESTNOERRORL(iSemaphore.CreateGlobal(KSemaphore, 0));

    return CTe_ConeStepBase::doTestStepPreambleL();

    }

TVerdict CTScale::doTestStepPostambleL()

    {

    iSemaphore.Close();

    return CTe_ConeStepBase::doTestStepPostambleL(); 

    }

/**

   @SYMTestCaseID GRAPHICS-UI-BENCH-S60-0007

   @SYMTestCaseDesc Measures the time for scaling in reaction to pointer events.

   @SYMTestActions Simulate horizontal and vertical drag pointer events and scales a bitmap.

   @SYMTestExpectedResults Measure and display the average framerate for the whole test.

*/

TVerdict CTScale::doTestStepL()

	{

	iProfiler->InitResults();

    // Use CGestureGenerator to simulate some horizontal drag pointer events.

	GestureGenerator::SimulateFlickGestureL(iSemaphore, TPoint(0, 0), 

	    TPoint(KGestureGenerationLimit, 0));

    // now some vertical drag

	GestureGenerator::SimulateFlickGestureL(iSemaphore, TPoint(KGestureGenerationLimit, 0), 

    	    TPoint(KGestureGenerationLimit, KGestureGenerationLimit));

	iProfiler->MarkResultSetL();

    TSize screenSize = CTWindow::GetDisplaySizeInPixels();

    iProfiler->ResultsAnalysisFrameRate(KTestStep0007, 0, 0, 0, iAppUi->ScaleControl()->Iterations(), screenSize.iWidth * screenSize.iHeight);

    return TestStepResult();

	} 

void CTScale::InitUIL(CCoeEnv* aCoeEnv)

	{

  	iAppUi = new(ELeave) CScaleAppUi();

  	// iAppUi needs to be put on the cleanupstack until CCoeEnv takes ownership of iAppUi

  	CleanupStack::PushL(iAppUi);

   	iAppUi->ConstructL();

   	CleanupStack::Pop(iAppUi);

   	aCoeEnv->SetAppUi(iAppUi);

  	}

CScaleControl* CScaleControl::NewL(const TRect& aRect,const CCoeControl* aParent)

    {

    CScaleControl* self = CScaleControl::NewLC(aRect,aParent);

    CleanupStack::Pop(self);

    return self;

    }

CScaleControl* CScaleControl::NewLC(const TRect& aRect,const CCoeControl* aParent)

    {

    CScaleControl* self = new(ELeave) CScaleControl();

    CleanupStack::PushL(self);

    self->ConstructL(aRect,aParent);

    return self;

    }

CScaleControl::CScaleControl() : iWsSession(CCoeEnv::Static()->WsSession())

	{

	// empty

    }

CScaleControl::~CScaleControl()

    {

    delete iSourceBitmap;

    iSemaphore.Close();

    }

void CScaleControl::ConstructL(const TRect& aRect,const CCoeControl* aParent)

    {

    User::LeaveIfError(iSemaphore.OpenGlobal(KSemaphore));

    // No owner, so create an own window

    if(!aParent)     

        {

        CreateWindowL();

        DrawableWindow()->PointerFilter(EPointerFilterDrag, 0);

        SetRect(aRect);

        ActivateL();

        }

    // Use Parent's window

    else

        {

        // This is component in a compound control

        SetContainerWindowL(*aParent);

        SetRect(aRect);

        }

    iSourceBitmap = new(ELeave) CFbsBitmap;

	User::LeaveIfError(iSourceBitmap->Load(KBigBitmap, 0));

    iSourceRect = iSourceBitmap->SizeInPixels();

    iSourceRatio = (TReal)iSourceRect.Height()/(TReal)iSourceRect.Width();    

    }

/**

 * Compute the new zoom rectangle based on the type of pointer event.

 * Horizontal events make the source rectangle smaller (zooming in)

 * and vertical events make it larger (zooming out).

 * @param aPointerEvent Current Pointer position.

 */

void CScaleControl::HandlePointerEventL(const TPointerEvent& aPointerEvent)

	{

	if(aPointerEvent.iType == TPointerEvent::EDrag)

		{

		if (iCurrentPointerPos.iY == aPointerEvent.iPosition.iY)

			{

			iSourceRect.Shrink(1,0);

			// After shrinking the width, calculate amount to shrink height.

			iSourceRect.Shrink(0, iSourceRect.Height() - (iSourceRect.Width()*iSourceRatio));

			}

		else 

			{

			iSourceRect.Grow(1, 0);

		    iSourceRect.Grow(0, (iSourceRect.Width()*iSourceRatio) - iSourceRect.Height());

			}

		iCurrentPointerPos = aPointerEvent.iPosition;

		}	

	DrawNow(); // Draws the entire control

	iWsSession.Finish(); // Wait until WServ has finished drawing

	iIterations++; // Update frame counter

	iSemaphore.Signal(); // Signal test that control was drawn

	}

/**

 * Scales and draws the bitmap to the screen.

 * @param aRect Region that covered by this control

 */

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

    {

    CWindowGc& gc = SystemGc();

    gc.DrawBitmap(aRect, iSourceBitmap, iSourceRect); // scale and draw the bitmap

    }

TInt CScaleControl::Iterations()

    {

    return iIterations;

    }

CScaleAppUi::CScaleAppUi()

	{

	// empty

	}

void CScaleAppUi::ConstructL()

    {

    BaseConstructL(ENoAppResourceFile);

    iScale = CScaleControl::NewL(TRect(CTWindow::GetDisplaySizeInPixels()));

    AddToStackL(iScale);

    } 

CScaleAppUi::~CScaleAppUi()

	{

	RemoveFromStack(iScale);

	delete iScale;

	}

CScaleControl* CScaleAppUi::ScaleControl()

    {

    return iScale;

    }