// 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:   TCLCK0.CPP  $

// $Revision:   1.6  $

// $Author:   DougF  $

// $Date:   07 Jul 1999 16:16:28  $

// 

//

/**

 @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 <mbs0.mbg>

#define TCLCK0_MBM _L("z:\\system\\data\\MBS0.MBM")

#define CLOCK EMbmMbs0Clock

#define CLOCKMSK EMbmMbs0Clockmsk

#include "TCLCK0STEP.h"

//_LIT(KTestString1,"Show analog & digital clocks");

_LIT(KTestString2,"Change universal time backward");

_LIT(KTestString3,"Change universal time forward");

_LIT(KTestString4,"Change clock separator");

_LIT(KTestString5,"Moving clock to right");

_LIT(KTestString6,"Set a new background color");

_LIT(KTestString7,"Restore previos background color");

_LIT(KTestString8,"hide clocks");

_LIT(KTestStarted,"Test Started");

_LIT(KTestFinished,"Test Finished");

// enums, structs and classes

// local functions

LOCAL_C TInt PanickingFunction(TAny* aPtr)

	{

	SPanickingFunctionData* data=(SPanickingFunctionData*)aPtr;

	RWsSession wsSession;

	wsSession.Connect();

	RAnimDll animDll(wsSession);

	animDll.Load(_L("CLOCKA.DLL"));

	RWindowGroup windowGroup(wsSession);

	windowGroup.Construct(NULL);

	windowGroup.SetOwningWindowGroup(data->iMainWindowGroup);

	RWindow window(wsSession);

	window.Construct(windowGroup, NULL);

	CWsScreenDevice* wsScreenDevice=new CWsScreenDevice(wsSession);

	wsScreenDevice->Construct();

	CDestructableFont* font=new CDestructableFont(wsScreenDevice);

	font->ConstructL(TFontSpec(_L("arial"), wsScreenDevice->VerticalPixelsToTwips(60)));

	TInt fontHandle=font->Handle();

	STimeDeviceShadow shadow;

	shadow.iIsOn=EFalse;

	TRgb color(255, 255, 255);

	TPoint position(10, 0);

	TSize size(0, 10);

	TInt seconds(20*60);

	TMargins margins;

	margins.iLeft=0;

	margins.iRight=0;

	margins.iTop=0;

	margins.iBottom=0;

	TBuf<64> digitalClockFormat=_L("any old thing");

	TDigitalDisplayTextSection digitalDisplayTextSection(fontHandle, color, EDigitalDisplayHorizontalTextAlignmentCenter,

																	EDigitalDisplayVerticalTextAlignmentBottomInclDescent,

																	0, 0, digitalClockFormat);

	RDigitalClock digitalClock(animDll, window);

	CFbsBitmap* analogClockFace0=new(ELeave) CFbsBitmap;

	analogClockFace0->Load(TCLCK0_MBM, CLOCK);

	CFbsBitmap* analogClockFace1=new(ELeave) CFbsBitmap;

	analogClockFace1->Load(TCLCK0_MBM, CLOCK);

	TInt analogClockFaceHandle0=analogClockFace0->Handle();

	TInt analogClockFaceHandle1=analogClockFace1->Handle();

	TAnalogDisplayHand analogClockHandWithNoFeatures(EAnalogDisplayHandOneRevPerMinute);

	TAnalogDisplayHand analogClockHand(EAnalogDisplayHandOneRevPerMinute);

	analogClockHand.AddCircle(CGraphicsContext::EDashedPen, color, size, CGraphicsContext::ESolidBrush, color, position, 8);

	RAnalogClock analogClock(animDll, window);

	// the last line of each of these cases should panic

	switch (data->iFunction)

		{

	case ECreateDigitalClockWithNoConstructCall:

		digitalClock.AddTextSectionL(digitalDisplayTextSection);

		break;

	case ECreateDigitalClockWithTooManyConstructCalls:

		digitalClock.ConstructL(seconds, position, size, margins, shadow, color, 1);

		digitalClock.ConstructL(seconds, position, size, margins, shadow, color, 1);

		break;

	case ECreateDigitalClockWithNoTextSections:

		digitalClock.ConstructL(seconds, position, size, margins, shadow, color, 0);

		break;

	case ECreateDigitalClockWithTooManyTextSections:

		digitalClock.ConstructL(seconds, position, size, margins, shadow, color, 2);

		digitalClock.AddTextSectionL(digitalDisplayTextSection);

		digitalClock.AddTextSectionL(digitalDisplayTextSection);

		digitalClock.AddTextSectionL(digitalDisplayTextSection);

		break;

	case ECreateDigitalClockWithNonNormalizedRect:

		digitalClock.ConstructL(seconds, position, TSize(-1, 0), margins, shadow, color, 1);

		break;

	case ECreateAnalogClockWithNoConstructCall:

		analogClock.AddHandL(analogClockHand);

		break;

	case ECreateAnalogClockWithTooManyConstructCalls:

		analogClock.ConstructL(seconds, position, size, margins, shadow, analogClockFaceHandle0, 0, 2);

		analogClock.ConstructL(seconds, position, size, margins, shadow, analogClockFaceHandle1, 0, 2);

		break;

	case ECreateAnalogClockWithNoHands:

		analogClock.ConstructL(seconds, position, size, margins, shadow, analogClockFaceHandle0, 0, 0);

		break;

	case ECreateAnalogClockWithTooManyHands:

		analogClock.ConstructL(seconds, position, size, margins, shadow, analogClockFaceHandle0, 0, 2);

		analogClock.AddHandL(analogClockHand);

		analogClock.AddHandL(analogClockHand);

		analogClock.AddHandL(analogClockHand);

		break;

	case ECreateAnalogClockWithHandWithNoFeatures:

		analogClock.ConstructL(seconds, position, size, margins, shadow, analogClockFaceHandle0, 0, 1);

		analogClock.AddHandL(analogClockHandWithNoFeatures);

		break;

		}

	return 0;

	}

// CDestructableFont

CDestructableFont::CDestructableFont(CWsScreenDevice* aScreenDevice)

	:iScreenDevice(aScreenDevice)

	{

	}

void CDestructableFont::ConstructL(const TFontSpec& aFontSpec)

	{

	User::LeaveIfError(iScreenDevice->GetNearestFontInTwips((CFont*&)iFont, aFontSpec));

	}

CDestructableFont::~CDestructableFont()

	{

	iScreenDevice->ReleaseFont(iFont); // N.B. do not need to do "delete iFont"

	}

TInt CDestructableFont::Handle() const

	{

	return iFont->Handle();

	}

// CClkControl

CClkControl::CClkControl()

	:iBackgroundColor(85, 85, 85),

	 iAnimDll(iCoeEnv->WsSession()),

	 iDigitalClock0Position(250, 125),

	 iDigitalClock0Size(180, 70),

	 iAnalogClock0Position(10, 5),

	 iAnalogClock0Size(200, 200),

	 iUniversalTimeOffset(0)

	{

	__DECLARE_NAME(_S("CClkControl"));

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

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

	}

void CClkControl::ConstructL()

	{

	// CONE construction stuff

	CreateWindowL();

	Window().SetBackgroundColor(iBackgroundColor);

	SetExtent(TPoint(10, 10), TSize(620, 220));

	ActivateL();

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

#if (0)

	TTime time;

	time.HomeTime();

	TDateTime dateTime=time.DateTime();

	User::SetHomeTime(TTime(TDateTime(dateTime.Year(), dateTime.Month(), dateTime.Day(), 10, 11, 0, 0)));

	time=time.DateTime();

#endif

	// clock construction stuff

	TestForDegenerateClockCreationL();

	CreateDigitalClocksL();

	CreateAnalogClocksL();

	}

CClkControl::~CClkControl()

	{

	if (iDigitalClock0!=NULL)

		iDigitalClock0->Destroy();

	if (iAnalogClock0!=NULL)

		iAnalogClock0->Destroy();

	iAnimDll.Close();

	}

TKeyResponse CClkControl::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

	{

	if (aType==EEventKey)

		{

		if (aKeyEvent.iModifiers&EModifierFunc)

			{

			TPoint increment(0, 0);

			TInt incrementMagnitude=(aKeyEvent.iModifiers&EModifierCtrl)? 5: 1;

			switch(aKeyEvent.iCode)

				{

			case EKeyLeftArrow:

				increment.iX=-incrementMagnitude;

				goto setDigitalClockSize;

			case EKeyRightArrow:

				increment.iX=incrementMagnitude;

				goto setDigitalClockSize;

			case EKeyUpArrow:

				increment.iY=-incrementMagnitude;

				goto setDigitalClockSize;

			case EKeyDownArrow:

				increment.iY=incrementMagnitude;

				goto setDigitalClockSize;

			setDigitalClockSize:

				iDigitalClock0Size+=increment;

				iAnalogClock0Size+=increment;

				iDigitalClock0->SetPositionAndSize(iDigitalClock0Position, iDigitalClock0Size);

				iAnalogClock0->SetPositionAndSize(iAnalogClock0Position, iAnalogClock0Size);

				break;

				}

			}

		else

			{

			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 CClkControl::HandlePointerEventL(const TPointerEvent& aPointerEvent)

	{

//	CCoeEnv* coeEnv = CCoeEnv::Static();

//	CTestClckUi* theApplication = (CTestClckUi*) (coeEnv->AppUi());

	switch (aPointerEvent.iType)

		{

	case TPointerEvent::EButton1Down:

		if (aPointerEvent.iModifiers&EModifierShift)

			{

			iDigitalClock0Position=aPointerEvent.iPosition;

			iDigitalClock0->SetPositionAndSize(iDigitalClock0Position, iDigitalClock0Size);

			}

		else

			{

			iAnalogClock0Position=aPointerEvent.iPosition;

			iAnalogClock0->SetPositionAndSize(iAnalogClock0Position, iAnalogClock0Size);

			}

		break;

	default: // dummy default to prevent gcc compiler warning

		break;

		}

	}

void CClkControl::Draw(const TRect&) const

	{

	CGraphicsContext& systemGc=SystemGc();

	systemGc.SetPenStyle(CGraphicsContext::ENullPen);

	systemGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

	systemGc.SetBrushColor(iBackgroundColor);

	systemGc.DrawRect(Rect());

	}

void CClkControl::TestForDegenerateClockCreationL()

	{

	// test deleting partially created clocks

	TestClosingPartiallyCreatedDigitalClocksL();

	TestClosingPartiallyCreatedAnalogClocksL();

	// test for panics

	/**

	TBool oldJustInTimeDebugging=User::JustInTime();

	User::SetJustInTime(EFalse);

	SPanickingFunctionData data;

	data.iMainWindowGroup=iCoeEnv->RootWin().Identifier();

	data.iFunction=ECreateDigitalClockWithNoConstructCall;

	FireOffNewThreadAndTestForPanicL(&data);

	data.iFunction=ECreateDigitalClockWithTooManyConstructCalls;

	FireOffNewThreadAndTestForPanicL(&data);

	data.iFunction=ECreateDigitalClockWithNoTextSections;

	FireOffNewThreadAndTestForPanicL(&data);

	data.iFunction=ECreateDigitalClockWithTooManyTextSections;

	FireOffNewThreadAndTestForPanicL(&data);

	data.iFunction=ECreateDigitalClockWithNonNormalizedRect;

	FireOffNewThreadAndTestForPanicL(&data);

	data.iFunction=ECreateAnalogClockWithNoConstructCall;

	FireOffNewThreadAndTestForPanicL(&data);

	data.iFunction=ECreateAnalogClockWithTooManyConstructCalls;

	FireOffNewThreadAndTestForPanicL(&data);

	data.iFunction=ECreateAnalogClockWithNoHands;

	FireOffNewThreadAndTestForPanicL(&data);

	data.iFunction=ECreateAnalogClockWithTooManyHands;

	FireOffNewThreadAndTestForPanicL(&data);

	data.iFunction=ECreateAnalogClockWithHandWithNoFeatures;

	FireOffNewThreadAndTestForPanicL(&data);

	User::SetJustInTime(oldJustInTimeDebugging);*/

	}

void CClkControl::TestClosingPartiallyCreatedDigitalClocksL()

	{

	CWsScreenDevice* screenDevice=iCoeEnv->ScreenDevice();

	TRgb color(97, 97, 97);

	TPoint position(35, -35);

	TSize size(100, 50);

	TMargins margins;

	margins.iLeft=0;

	margins.iRight=0;

	margins.iTop=0;

	margins.iBottom=0;

	RDigitalClock tempDigitalClock0(iAnimDll, Window());

	tempDigitalClock0.Close();

	RDigitalClock tempDigitalClock1(iAnimDll, Window());

	RDigitalClock tempDigitalClock2(iAnimDll, Window());

	STimeDeviceShadow tempDigitalClock2Shadow;

	tempDigitalClock2Shadow.iIsOn=EFalse;

	tempDigitalClock2.ConstructL(TTimeIntervalSeconds(20*60), position, size, margins, tempDigitalClock2Shadow,

																color, 3);

	RDigitalClock tempDigitalClock3(iAnimDll, Window());

	STimeDeviceShadow tempDigitalClock3Shadow;

	tempDigitalClock3Shadow.iIsOn=EFalse;

	tempDigitalClock3.ConstructL(TTimeIntervalSeconds(20*60), position, size, margins, tempDigitalClock2Shadow,

																color, 3);

	TBuf<64> tempDigitalClock3Format0=_L("");

	tempDigitalClock3Format0.Append(_L("%*J"));

	tempDigitalClock3Format0.Append(TChar(EDigitalDisplayLayoutCharFlashingBlockDelimiter));

	tempDigitalClock3Format0.Append(_L("%:1"));

	tempDigitalClock3Format0.Append(TChar(EDigitalDisplayLayoutCharFlashingBlockDelimiter));

	tempDigitalClock3Format0.Append(_L("%T"));

	tempDigitalClock3Format0.Append(TChar(EDigitalDisplayLayoutCharFlashingBlockDelimiter));

	tempDigitalClock3Format0.Append(_L("%:2"));

	tempDigitalClock3Format0.Append(TChar(EDigitalDisplayLayoutCharFlashingBlockDelimiter));

	tempDigitalClock3Format0.Append(_L("%S %B"));

	CDestructableFont* tempDigitalClock3Font0=new(ELeave) CDestructableFont(screenDevice);

	tempDigitalClock3Font0->ConstructL(TFontSpec(_L("arial"), screenDevice->VerticalPixelsToTwips(60)));

	tempDigitalClock3.AddTextSectionL(TDigitalDisplayTextSection(tempDigitalClock3Font0->Handle(), TRgb(0, 0, 0),

																EDigitalDisplayHorizontalTextAlignmentCenter,

																EDigitalDisplayVerticalTextAlignmentCenterExclDescent,

																0, 0, tempDigitalClock3Format0));

	RDigitalClock tempDigitalClock4(iAnimDll, Window());

	STimeDeviceShadow tempDigitalClock4Shadow;

	tempDigitalClock4Shadow.iIsOn=EFalse;

	tempDigitalClock4.ConstructL(TTimeIntervalSeconds(20*60), position, size, margins, tempDigitalClock4Shadow,

																color, 3);

	RDigitalClock tempDigitalClock5(iAnimDll, Window());

	STimeDeviceShadow tempDigitalClock5Shadow;

	tempDigitalClock5Shadow.iIsOn=EFalse;

	tempDigitalClock5.ConstructL(TTimeIntervalSeconds(20*60), position, size, margins, tempDigitalClock2Shadow,

																color, 3);

	TBuf<64> tempDigitalClock5Format0=_L("");

	tempDigitalClock5Format0.Append(_L("%*J"));

	tempDigitalClock5Format0.Append(TChar(EDigitalDisplayLayoutCharFlashingBlockDelimiter));

	tempDigitalClock5Format0.Append(_L("%:1"));

	tempDigitalClock5Format0.Append(TChar(EDigitalDisplayLayoutCharFlashingBlockDelimiter));

	tempDigitalClock5Format0.Append(_L("%T"));

	tempDigitalClock5Format0.Append(TChar(EDigitalDisplayLayoutCharFlashingBlockDelimiter));

	tempDigitalClock5Format0.Append(_L("%:2"));

	tempDigitalClock5Format0.Append(TChar(EDigitalDisplayLayoutCharFlashingBlockDelimiter));

	tempDigitalClock5Format0.Append(_L("%S %B"));

	CDestructableFont* tempDigitalClock5Font0=new(ELeave) CDestructableFont(screenDevice);

	tempDigitalClock5Font0->ConstructL(TFontSpec(_L("arial"), screenDevice->VerticalPixelsToTwips(60)));

	tempDigitalClock5.AddTextSectionL(TDigitalDisplayTextSection(tempDigitalClock5Font0->Handle(), TRgb(0, 0, 0),

																EDigitalDisplayHorizontalTextAlignmentCenter,

																EDigitalDisplayVerticalTextAlignmentCenterExclDescent,

																0, 0, tempDigitalClock5Format0));

	tempDigitalClock2.Close();

	tempDigitalClock1.Close();

	tempDigitalClock3.Close();

	tempDigitalClock4.Close();

	tempDigitalClock5.Close();

	delete tempDigitalClock3Font0;

	delete tempDigitalClock5Font0;

	}

void CClkControl::TestClosingPartiallyCreatedAnalogClocksL()

	{

	TRgb color(234, 234, 234);

	TPoint position(0, 0);

	TSize size(2, 0);

	RWindow& window=Window();

	TMargins margins;

	margins.iLeft=0;

	margins.iRight=0;

	margins.iTop=0;

	margins.iBottom=0;

	RAnalogClock tempAnalogClock0(iAnimDll, window);

	tempAnalogClock0.Close();

	RAnalogClock tempAnalogClock1(iAnimDll, window);

	RAnalogClock tempAnalogClock2(iAnimDll, window);

	STimeDeviceShadow tempAnalogClock2Shadow;

	tempAnalogClock2Shadow.iIsOn=EFalse;

	CFbsBitmap* tempAnalogClock2Face=new(ELeave) CFbsBitmap;

	User::LeaveIfError(tempAnalogClock2Face->Load(TCLCK0_MBM, CLOCK));

	tempAnalogClock2.ConstructL(TTimeIntervalSeconds(20*60), position, size, margins, tempAnalogClock2Shadow,

																tempAnalogClock2Face->Handle(), 0, 3);

	RAnalogClock tempAnalogClock3(iAnimDll, window);

	STimeDeviceShadow tempAnalogClock3Shadow;

	tempAnalogClock3Shadow.iIsOn=EFalse;

	CFbsBitmap* tempAnalogClock3Face=new(ELeave) CFbsBitmap;

	User::LeaveIfError(tempAnalogClock3Face->Load(TCLCK0_MBM, CLOCK));

	tempAnalogClock3.ConstructL(TTimeIntervalSeconds(20*60), position, size, margins, tempAnalogClock3Shadow,

																tempAnalogClock3Face->Handle(), 0, 3);

	TAnalogDisplayHand tempAnalogClock3Hand(EAnalogDisplayHandOneRevPerMinute);

	CArrayFix<TPoint>* tempAnalogClock3HandPointList=new(ELeave) CArrayFixFlat<TPoint>(2);

	tempAnalogClock3HandPointList->AppendL(TPoint(-10000, -10000));

	tempAnalogClock3HandPointList->AppendL(TPoint(10000, 10000));

	tempAnalogClock3Hand.AddPolyLine(CGraphicsContext::EDottedPen, color, TSize(50, 50),

																CGraphicsContext::ESolidBrush, TRgb(12, 12, 12),

																ETrue, tempAnalogClock3HandPointList);

	tempAnalogClock3Hand.AddCircle(CGraphicsContext::EDashedPen, TRgb(77, 77, 77), TSize(0, 0), CGraphicsContext::ESolidBrush,

																TRgb(77, 77, 77), TPoint(-20, 20), 9000);

	tempAnalogClock3.AddHandL(tempAnalogClock3Hand);

	tempAnalogClock3.AddHandL(tempAnalogClock3Hand); // try adding the same hand more than once

	RAnalogClock tempAnalogClock4(iAnimDll, window);

	STimeDeviceShadow tempAnalogClock4Shadow;

	tempAnalogClock4Shadow.iIsOn=ETrue;

	tempAnalogClock4Shadow.iColor=TRgb(123, 123, 123);

	tempAnalogClock4Shadow.iOffset.SetXY(1000, 1000);

	CFbsBitmap* tempAnalogClock4Face=new(ELeave) CFbsBitmap;

	User::LeaveIfError(tempAnalogClock4Face->Load(TCLCK0_MBM, CLOCK));

	tempAnalogClock4.ConstructL(TTimeIntervalSeconds(20*60), position, size, margins, tempAnalogClock4Shadow,

																tempAnalogClock4Face->Handle(), 0, /* this parameter is aNumHands: */3);

	RAnalogClock tempAnalogClock5(iAnimDll, window);

	STimeDeviceShadow tempAnalogClock5Shadow;

	tempAnalogClock5Shadow.iIsOn=ETrue;

	tempAnalogClock5Shadow.iColor=TRgb(123, 123, 123);

	tempAnalogClock5Shadow.iOffset.SetXY(1000, 1000);