// 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 code for the clock DLL
// $Workfile:   TCLCK1.CPP  $
// $Revision:   1.7  $
// $Author:     DougF  $
// $Date:       07 Jul 1999 16:16:30  $
// 
//

/**
 @file
 @internalComponent - Internal Symbian test code
*/
#include <e32keys.h>
#include <coemain.h>
#include <coedef.h>
#include <coeaui.h>
#include <coecntrl.h>
#include <clock.h>
#include <basched.h>

#include <mbs1.mbg>
#include "TCLCK1STEP.h"



#define TCLCK1_MBM _L("z:\\system\\data\\MBS1.MBM")
#define CLOCK EMbmMbs1Clock
#define CLOCKMSK EMbmMbs1Clockmsk

// classes
// main functions

CTestClck1Ui::CTestClck1Ui(CTmsTestStep* aStep) :
CTestCoeAppUi(aStep)
	{}


void CTestClck1Ui::ConstructL()
	{
	CTestCoeAppUi::ConstructL();
	iControl=new(ELeave) CClk1Control;
	AddToStackL(iControl,ECoeStackPriorityDefault,ECoeStackFlagOwnershipTransfered);
//	appUi->AddToStackL(control,ECoeStackPriorityDefault,ECoeStackFlagOwnershipTransfered);
	iControl->ConstructL();

	AutoTestManager().StartAutoTest();
	}

/**
   @SYMTestCaseID UIF-Clock-TClock1
 */

void CTestClck1Ui::RunTestStepL(TInt aNumStep)
	{
	TKeyEvent theKeyEvent;
	TEventCode theType = EEventKey;
	
	//only for debug
	User::After(TTimeIntervalMicroSeconds32(1000000));
	
	
	switch(aNumStep)
		{
		case 1:
		SetTestStepID(_L("UIF-Clock-TClock1"));
		theKeyEvent.iCode = EKeyEnter;
		theKeyEvent.iModifiers = 0;
		
		iControl->OfferKeyEventL(theKeyEvent, theType);
		INFO_PRINTF1(_L("Show analog & digital clocks"));
		break;
		
		case 2: case 3: case 4: case 5:
		theKeyEvent.iCode = EKeyLeftArrow;
		theKeyEvent.iModifiers = 0;
		
		iControl->OfferKeyEventL(theKeyEvent, theType);
		INFO_PRINTF1(_L("Change universal time backward"));
		break;

		case 6: case 7: case 8: case 9:
		theKeyEvent.iCode = EKeyRightArrow;
		theKeyEvent.iModifiers = 0;
		
		iControl->OfferKeyEventL(theKeyEvent, theType);
		INFO_PRINTF1(_L("Change universal time forward"));
		break;

		case 10:
		theKeyEvent.iCode = '*';
		theKeyEvent.iModifiers = 0;
		
		iControl->OfferKeyEventL(theKeyEvent, theType);
		INFO_PRINTF1(_L("Change clock separator"));
		break;

		case 11:  
		theKeyEvent.iCode = EKeySpace;
		theKeyEvent.iModifiers = EModifierShift;
		
		iControl->OfferKeyEventL(theKeyEvent, theType);
		INFO_PRINTF1(_L("Set a new background color"));
		break;

		case 12:  
		theKeyEvent.iCode = EKeySpace;
		theKeyEvent.iModifiers = 0;
		
		iControl->OfferKeyEventL(theKeyEvent, theType);
		INFO_PRINTF1(_L("Restore previos background color"));
		break;

		case 13:
		theKeyEvent.iCode = EKeyEnter;
		theKeyEvent.iModifiers = EModifierShift;
		
		iControl->OfferKeyEventL(theKeyEvent, theType);
		INFO_PRINTF1(_L("hide clocks"));
		RecordTestResultL();
		CloseTMSGraphicsStep();
		break;

		case 14:
			AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass);
		}
	}


void CTClck1Step::ConstructAppL(CCoeEnv* aCoeEnv)
	{
	aCoeEnv->ConstructL();
	CTestClck1Ui* appUi=new(ELeave) CTestClck1Ui(this);
	appUi->ConstructL();
	aCoeEnv->SetAppUi(appUi);
	}

CTClck1Step::~CTClck1Step()
/**
   Destructor
 */
	{
	}

CTClck1Step::CTClck1Step()
/**
   Constructor
 */
	{
	// Call base class method to set up the human readable name for logging
	SetTestStepName(KTClck1Step);
	}

TVerdict CTClck1Step::doTestStepL()
	{
	INFO_PRINTF1(_L("Test Started"));
	CCoeEnv* coeEnv=new CCoeEnv;
	if (coeEnv==NULL)
		{
		SetTestStepResult(EFail);
		return TestStepResult();
		}
	TRAPD(error, ConstructAppL(coeEnv));
	if (error!=KErrNone)
		{
		delete coeEnv;
		SetTestStepResult(EFail);
		return TestStepResult();
		}
	coeEnv->ExecuteD();
	INFO_PRINTF1(_L("Test Finished"));
	return TestStepResult();
	}


// CClck1DestructableFont

CClck1DestructableFont::CClck1DestructableFont(CWsScreenDevice* aScreenDevice)
	:iScreenDevice(aScreenDevice)
	{
	}

void CClck1DestructableFont::ConstructL(const TFontSpec& aFontSpec)
	{
	User::LeaveIfError(iScreenDevice->GetNearestFontInTwips((CFont*&)iFont, aFontSpec));
	}

CClck1DestructableFont::~CClck1DestructableFont()
	{
	iScreenDevice->ReleaseFont(iFont); // N.B. do not need to do "delete iFont"
	}

TInt CClck1DestructableFont::Handle() const
	{
	return iFont->Handle();
	}

// CClk1Control

CClk1Control::CClk1Control()
	:iBackgroundColor(85, 85, 85),
	 iAnimDll(iCoeEnv->WsSession()),
	 iDigitalClock0Position(350, 125),
	 iDigitalClock0Size(180, 70),
	 iAnalogClock0Position(10, 0),
	 iAnalogClock0Size(300, 222),
	 iUniversalTimeOffset(0)
	{
	__DECLARE_NAME(_S("CClk1Control"));

	__ASSERT_DEBUG(iDigitalClock0==NULL, User::Panic(_L("Clock test-code"), 1));
	__ASSERT_DEBUG(iAnalogClock0==NULL, User::Panic(_L("Clock test-code"), 2));
	}

void CClk1Control::ConstructL()
	{
	// CONE construction stuff
	CreateBackedUpWindowL(iCoeEnv->RootWin());
	SetExtent(TPoint(10, 10), TSize(620, 220));
	ActivateL();
	iCoeEnv->WsSession().Flush();

	User::LeaveIfError(iAnimDll.Load(_L("CLOCKA.DLL")));

	// clock construction stuff
	CreateDigitalClocksL();
	CreateAnalogClocksL();
	}

CClk1Control::~CClk1Control()
	{
	if (iDigitalClock0!=NULL)
		iDigitalClock0->Destroy();
	if (iAnalogClock0!=NULL)
		iAnalogClock0->Destroy();
	iAnimDll.Close();
	}

TKeyResponse CClk1Control::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)
	{
	if (aType==EEventKey)
		{
		TInt adjust=0;
		switch (aKeyEvent.iCode)
			{
		case CTRL('e'):
			iCoeEnv->Flush();
			CBaActiveScheduler::Exit();
			break;
		case EKeySpace:
			if (aKeyEvent.iModifiers&EModifierShift)
				iDigitalClock0->SetBackgroundColor(TRgb(85, 85, 85), TRgb(0, 0, 0));
			else
				iDigitalClock0->SetBackgroundColor(TRgb(170, 170, 170), TRgb(85, 85, 85));
			break;
		case EKeyEnter:
			if (aKeyEvent.iModifiers&EModifierShift)
				{
				iDigitalClock0->SetVisible(EFalse);
				iAnalogClock0->SetVisible(EFalse);
				}
			else
				{
				iDigitalClock0->SetVisible(ETrue);
				iAnalogClock0->SetVisible(ETrue);
				}
			break;
		case '$':
		case '%':
		case '^':
		case '&':
		case '+':
		case '-':
		case '*':
		case '/':
		case 'S':
		case 's':
		case '\\':
		case ':':
			{
			TLocale locale;
			locale.Refresh();
#pragma warning (disable: 4710)
			locale.SetTimeSeparator(aKeyEvent.iCode, 1);
			locale.SetTimeSeparator(aKeyEvent.iCode, 2);
#pragma warning (default: 4710)
			locale.Set();
			}
			break;
		case EKeyLeftArrow:
		case EKeyUpArrow:
			adjust=-3600;
			goto adjustClock;
		case EKeyRightArrow:
		case EKeyDownArrow:
			adjust=3600;
			goto adjustClock;
		adjustClock:
			iUniversalTimeOffset+=adjust;
			iDigitalClock0->SetUniversalTimeOffset(iUniversalTimeOffset);
			iAnalogClock0->SetUniversalTimeOffset(iUniversalTimeOffset);
			break;
		case 'U':
		case 'u':
			iDigitalClock0->UpdateDisplay();
			iAnalogClock0->UpdateDisplay();
			break;
		case 'D':
		case 'd':
			iDigitalClock0->Draw();
			iAnalogClock0->Draw();
			break;
			}
		}

	return EKeyWasConsumed;
	}

void CClk1Control::Draw(const TRect&) const
	{
	CGraphicsContext& systemGc=SystemGc();
	systemGc.SetPenStyle(CGraphicsContext::ENullPen);
	systemGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
	systemGc.SetBrushColor(iBackgroundColor);
	systemGc.DrawRect(Rect());
	}

void CClk1Control::CreateDigitalClocksL()
	{
	TMargins margins;
	margins.iLeft=0;
	margins.iRight=0;
	margins.iTop=0;
	margins.iBottom=0;
	// construct digital clock
	STimeDeviceShadow digitalClock0Shadow;
	digitalClock0Shadow.iIsOn=ETrue;
	digitalClock0Shadow.iColor=TRgb(85, 85, 85);
	digitalClock0Shadow.iOffset.SetXY(2, 2);
	//
	iDigitalClock0=new(ELeave) RDigitalClock(iAnimDll, BackedUpWindow());
	iDigitalClock0->ConstructL(TTimeIntervalSeconds(30*60), iDigitalClock0Position, iDigitalClock0Size, margins, digitalClock0Shadow, TRgb(170, 170, 170), 1);
	//
	TBuf<64> digitalClock0Format0=_L("%-B%J%:1%T%+B");
	CClck1DestructableFont* digitalClock0Font0=new(ELeave) CClck1DestructableFont(iCoeEnv->ScreenDevice());
	CleanupStack::PushL(digitalClock0Font0);
	TFontSpec digitalClock0FontSpec0(_L("arial"), iCoeEnv->ScreenDevice()->VerticalPixelsToTwips(25));
	digitalClock0FontSpec0.iFontStyle.SetPosture(EPostureItalic);
	digitalClock0FontSpec0.iFontStyle.SetStrokeWeight(EStrokeWeightBold);
	digitalClock0Font0->ConstructL(digitalClock0FontSpec0);
	iDigitalClock0->AddTextSectionL(TDigitalDisplayTextSection(digitalClock0Font0->Handle(), TRgb(0, 0, 0),
																EDigitalDisplayHorizontalTextAlignmentCenter,
																EDigitalDisplayVerticalTextAlignmentCenterExclDescent,
																0, 0, digitalClock0Format0));
	//
	CleanupStack::PopAndDestroy(); // pop and destroy digitalClock0Font0
	}

void CClk1Control::CreateAnalogClocksL()
	{
	CWsScreenDevice* screenDevice=iCoeEnv->ScreenDevice();
	TMargins margins;
	margins.iLeft=0;
	margins.iRight=0;
	margins.iTop=0;
	margins.iBottom=0;
	// construct analog clock
	//
	STimeDeviceShadow  analogClock0Shadow;
	analogClock0Shadow.iIsOn=ETrue;
	analogClock0Shadow.iColor=TRgb(85, 85, 85);
	analogClock0Shadow.iOffset.SetXY(4, 4);
	//
	CFbsBitmap* analogClock0Face=new(ELeave) CFbsBitmap;
	CleanupStack::PushL(analogClock0Face);
	User::LeaveIfError(analogClock0Face->Load(TCLCK1_MBM, CLOCK));
	analogClock0Face->SetSizeInTwips(screenDevice);
	CFbsBitmap* analogClock0FaceMask=new(ELeave) CFbsBitmap;
	CleanupStack::PushL(analogClock0FaceMask);
	User::LeaveIfError(analogClock0FaceMask->Load(TCLCK1_MBM, CLOCKMSK));
	analogClock0Face->SetSizeInTwips(screenDevice);
	//
	iAnalogClock0=new(ELeave) RAnalogClock(iAnimDll, BackedUpWindow());
	iAnalogClock0->ConstructL(TTimeIntervalSeconds(30*60), iAnalogClock0Position, iAnalogClock0Size, margins, analogClock0Shadow,
								analogClock0Face->Handle(), analogClock0FaceMask->Handle(), 2);
	//
	TRgb black(0, 0, 0);
	CArrayFix<TPoint>* pointList=new(ELeave) CArrayFixFlat<TPoint>(4);
	CleanupStack::PushL(pointList);
	//
	// N.B. the dimensions/positions of the hand features (i.e. lines and circles) are specified with the hand assumed to be in the
	// 12 o'clock position, with TPoint(0, 0) being the center of the clock
	TAnalogDisplayHand analogClock0HourHand(EAnalogDisplayHandOneRevPer12Hours);
	analogClock0HourHand.AddLine(CGraphicsContext::ESolidPen, black, TSize(4, 4), TPoint(0, 10), TPoint(0, -55));
	iAnalogClock0->AddHandL(analogClock0HourHand);
	//
	TAnalogDisplayHand analogClock0MinuteHand(EAnalogDisplayHandOneRevPerHour);
	analogClock0MinuteHand.AddLine(CGraphicsContext::ESolidPen, black, TSize(4, 4), TPoint(0, 10), TPoint(0, -70));
	iAnalogClock0->AddHandL(analogClock0MinuteHand);
	//
	CleanupStack::PopAndDestroy(); // pop and destroy pointList
	CleanupStack::PopAndDestroy(); // pop and destroy analogClock0FaceMask
	CleanupStack::PopAndDestroy(); // pop and destroy analogClock0Face
	}