// 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
 @internalComponent - Internal Symbian test code 
*/

#include <coeaui.h>
#include <coemain.h>
#include <coecntrl.h>
#include <coefont.h>
#include <coedef.h>
#include <coesndpy.h>
#include <coefontprovider.h>
#include <basched.h>
#include <bassnd.h>
#include <ecom/ecom.h>
#include "TConeZoomFont.h"

_LIT(KConeZoomFontText, "Zoom text!");


class CConeZoomFontControl : public CCoeControl
    {
public:
	static CConeZoomFontControl* NewL(const TRect& aRect);
	CConeZoomFontControl();
	~CConeZoomFontControl();
    void ConstructL(const TRect& aRect);
	TZoomFactor AccZoom();
private:
	           // Inherited from CCoeControl
	void Draw(const TRect& /*aRect*/) const;

private:
	HBufC*  iConeZoomFontText;
	TCoeFont iFont;
    };

class CConeZoomFontView : public CCoeControl
    {
public:
	static CConeZoomFontView* NewL();
	CConeZoomFontView();
	~CConeZoomFontView();
    void ConstructL();
    
    void Test1L();
    void Test2L();
    void Test3L();

    TInt CountComponentControls() const;
    CCoeControl* ComponentControl(TInt aIndex) const;

private:
	           // Inherited from CCoeControl
	void Draw(const TRect& /*aRect*/) const;
	void SizeChanged();

private:
	CConeZoomFontControl*  iControl;
    };


//
//
// CConeZoomFontControl
//
//
CConeZoomFontControl::CConeZoomFontControl():
iFont(TCoeFont::NormalFont())
	{
	}

CConeZoomFontControl* CConeZoomFontControl::NewL(const TRect& aRect)
	{
	CConeZoomFontControl* self = new(ELeave) CConeZoomFontControl();
	CleanupStack::PushL(self);
	self->ConstructL(aRect);
	CleanupStack::Pop(self);
	return self;
	}

CConeZoomFontControl::~CConeZoomFontControl()
	{
	delete iConeZoomFontText;
	}

void CConeZoomFontControl::ConstructL(const TRect& /*aRect*/)
    {
	iConeZoomFontText = KConeZoomFontText().AllocL();
	}

void CConeZoomFontControl::Draw(const TRect& /*aRect*/) const
	{
	CWindowGc& gc = SystemGc();
	TRect      drawRect = Rect();
	gc.Clear();
	drawRect.Shrink(10,10);		   	
	gc.DrawRect(drawRect);
	
	// Testing bit - get the correct font based on the current zoom factor.
	// NB, the Font() function takes a non-const reference to a TZoomFactor as
	// its second argument, so we can't pass the direct return from AccumulatedZoom()
	// as might seem to be the natural thing to do.
	TZoomFactor junk = AccumulatedZoom();
	const CFont& fontUsed = FindFontProvider().Font(TCoeFont::TitleFont(), junk);
	gc.UseFont(&fontUsed);
	TInt   baselineOffset=(drawRect.Height() + fontUsed.HeightInPixels())/2; 
	gc.DrawText(*iConeZoomFontText,drawRect,baselineOffset,CGraphicsContext::ECenter, 0);
	gc.DiscardFont();
	}

TZoomFactor CConeZoomFontControl::AccZoom()
	{
	return AccumulatedZoom();
	}
	
//
//
// CConeZoomFontView
//
//
CConeZoomFontView::CConeZoomFontView()
	{
	}

CConeZoomFontView* CConeZoomFontView::NewL()
	{
	CConeZoomFontView* self = new(ELeave) CConeZoomFontView();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CConeZoomFontView::~CConeZoomFontView()
	{
	delete iControl;
	}
    
TInt CConeZoomFontView::CountComponentControls() const
	{
	return 1;
	}

/**
   @SYMTestCaseID UIF-TConeZoomFont-Test1L
  
   @SYMPREQ 857
  
   @SYMTestCaseDesc
   The parent is set to have relative zoom factor of 1000, and the child a relative zoom 
   of 500 using the CCoeControl:: SetZoomFactorL.  This should give a cumulative zoom 
   factor of 500. The child will draw text in its rectangle based this cumulative zoom factor.
  
   @SYMTestPriority High
  
   @SYMTestStatus Implemented
  
   @SYMTestActions
   Set the zoom factors of the parent and child objects
   Chect the accumulated zoom is calculated correctly
   finally call draw now to display zoomed text
  
   @SYMTestExpectedResults
   Will leave if accumulated zoom factor is incorrect, zoomed text is displayed.
  
 */
void CConeZoomFontView::Test1L()
	{
	TInt viewZoom = 1000;
	TInt controlZoom = 500;
	
	SetZoomFactorL(viewZoom, ERelativeZoom);
	iControl->SetZoomFactorL(controlZoom, ERelativeZoom);
	TZoomFactor viewZoomFactor = AccumulatedZoom();
	TZoomFactor controlZoomFactor = iControl->AccZoom();
	
	//Check to see if the AccumulatedZoom returns the correct values
	if ((viewZoomFactor.ZoomFactor() != viewZoom) ||
	    (controlZoomFactor.ZoomFactor() != ((viewZoom * controlZoom) /1000)))
		{
		User::Leave(-1);	
		}

	DrawNow();
	}

/**
   @SYMTestCaseID UIF-TConeZoomFont-Test2L
  
   @SYMPREQ 857
  
   @SYMTestCaseDesc
   The parent is set to have relative zoom factor of 500, and the child a absolute 
   zoom of 1000.  This should give a cumulative zoom factor of 1000 (because the 
   child's zoom is absolute). The child will draw text in its rectangle based this 
   cumulative zoom factor.
  
   @SYMTestPriority High
  
   @SYMTestStatus Implemented
  
   @SYMTestActions
   Set the zoom factors of the parent and child objects
   Chect the accumulated zoom is calculated correctly
   finally call draw now to display zoomed text
  
   @SYMTestExpectedResults
   Will leave if accumulated zoom factor is incorrect, zoomed text is displayed.
  
 */
void CConeZoomFontView::Test2L()
	{	
	TInt viewZoom = 500;
	TInt controlZoom = 1000;
	
	SetZoomFactorL(viewZoom, ERelativeZoom);
	iControl->SetZoomFactorL(controlZoom, EAbsoluteZoom);
	TZoomFactor viewZoomFactor = AccumulatedZoom();
	TZoomFactor controlZoomFactor = iControl->AccZoom();
	
	//Check to see if the AccumulatedZoom returns the correct values
	if ((viewZoomFactor.ZoomFactor() != viewZoom) ||
	    (controlZoomFactor.ZoomFactor() != (controlZoom)))
		{
		User::Leave(-1);	
		}
	
	DrawNow();
	}

/**
   @SYMTestCaseID UIF-TConeZoomFont-Test3L
  
   @SYMPREQ 857
  
   @SYMTestCaseDesc
   The parent is set to have absolute zoom factor of 1500, and the child 
   a relative zoom of 1500. This should give a cumulative zoom factor of 
   2250. The child will draw text in its rectangle based this cumulative 
   zoom factor.
  
   @SYMTestPriority High
  
   @SYMTestStatus Implemented
  
   @SYMTestActions
   Set the zoom factors of the parent and child objects
   Chect the accumulated zoom is calculated correctly
   finally call draw now to display zoomed text
  
   @SYMTestExpectedResults
   Will leave if accumulated zoom factor is incorrect, zoomed text is displayed.
  
 */
void CConeZoomFontView::Test3L()
	{
	
	TInt viewZoom = 1500;
	TInt controlZoom = 1500;
	
	SetZoomFactorL(viewZoom, EAbsoluteZoom);
	iControl->SetZoomFactorL(controlZoom, ERelativeZoom);
	TZoomFactor viewZoomFactor = AccumulatedZoom();
	TZoomFactor controlZoomFactor = iControl->AccZoom();
	
	//Check to see if the AccumulatedZoom returns the correct values
	if ((viewZoomFactor.ZoomFactor() != viewZoom) ||
	    (controlZoomFactor.ZoomFactor() != ((viewZoom * controlZoom) /1000)))
		{
		User::Leave(-1);	
		}

	DrawNow();
	}

CCoeControl* CConeZoomFontView::ComponentControl(TInt /*aIndex*/) const
	{
	return iControl;
	}

void CConeZoomFontView::ConstructL()
    {
	CreateWindowL();
    	
	iControl = CConeZoomFontControl::NewL(Rect());
	iControl->SetContainerWindowL(*this);
	iControl->SetParent(this);
	
	SetExtent( TPoint(20,20),TSize(600,200) );
	
	SetZoomFactorL(1000);
	iControl->SetZoomFactorL(1000, EAbsoluteZoom);

	ActivateL();
	}

void CConeZoomFontView::Draw(const TRect& /*aRect*/) const
	{
	
	CWindowGc& gc = SystemGc();
	TRect      drawRect = Rect();
	gc.Clear();
	drawRect.Shrink(10,10);		   	
	gc.DrawRect(drawRect);
	
	}
	
void CConeZoomFontView::SizeChanged()
	{
	ComponentControl(1)->SetRect( TRect(TPoint(20,20),TSize(560,160))) ;
	}

//
//
// CConeZoomFontAppUi
//
//
CConeZoomFontAppUi::CConeZoomFontAppUi(CTmsTestStep* aStep) :
CTestCoeAppUi(aStep)
{}

CConeZoomFontAppUi::~CConeZoomFontAppUi()
	{
	delete iView;
	}


void CConeZoomFontAppUi::ConstructL()
	{
	CTestCoeAppUi::ConstructL();
	
	iView = CConeZoomFontView::NewL();
	
	AutoTestManager().StartAutoTest();
	}
	
void CConeZoomFontAppUi::RunTestStepL(TInt aStepNum)
	{

	User::After(TTimeIntervalMicroSeconds32(1000000));
	
	TInt err;

	switch(aStepNum)
		{
		case 1:
			SetTestStepID(_L("UIF-TConeZoomFont-Test1L"));			
			_LIT(KTest1, "Zoom Relative 0.5");
			INFO_PRINTF1(KTest1);
			TRAP(err, iView->Test1L());
			RecordTestResultL();			
			break;
		case 2:
			SetTestStepID(_L("UIF-TConeZoomFont-Test2L"));			
			_LIT(KTest2, "Zoom Absolute 2.0");
			INFO_PRINTF1(KTest2);
			TRAP(err, iView->Test2L());
			RecordTestResultL();			
			break;
		case 3:
			SetTestStepID(_L("UIF-TConeZoomFont-Test3L"));					
			_LIT(KTest3, "Zoom Relative 1.5*1.5");
			INFO_PRINTF1(KTest3);
			TRAP(err, iView->Test3L());
			RecordTestResultL();	
			CloseTMSGraphicsStep();
			break;
		case 4:
			AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass);
			break;

		}
	}

//
//
// CConeZoomFontStep
//
//
void CTConeZoomFontStep::ConstructAppL(CCoeEnv* aCoe)
	{ // runs inside a TRAP harness
	aCoe->ConstructL();
	CConeZoomFontAppUi* appUi= new (ELeave) CConeZoomFontAppUi(this);
	aCoe->SetAppUi(appUi);
	appUi->ConstructL();
	}

CTConeZoomFontStep::CTConeZoomFontStep()
	{
	SetTestStepName(KTConeZoomFontStep);
	}

CTConeZoomFontStep::~CTConeZoomFontStep()
{}


TVerdict CTConeZoomFontStep::doTestStepL() // main function called by E32
	{
	_LIT(KTestStart, "Test Started");
	INFO_PRINTF1(KTestStart);
	
	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;
	
	_LIT(KTestFinished, "Test Finished");
	INFO_PRINTF1(KTestFinished);
	return TestStepResult();
	}