--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lafagnosticuifoundation/clockanim/src/DISPLAY.CPP	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,550 @@
+// Copyright (c) 1997-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:
+//
+
+#include "CL_STD.H"
+
+_LIT(KFormatText,"%*A");
+
+// DDisplay
+
+DDisplay::DDisplay(const TPoint& aPosition, const TSize& aSize, const TMargins& aMargins, const STimeDeviceShadow& aShadow)
+	:iShadow(aShadow),
+	 iPosition(aPosition),
+	 iSize(aSize),
+	 iVisible(EFalse),
+	 iMargins(aMargins)
+	{
+	__DECLARE_NAME(_S("DDisplay"));
+	}
+
+void DDisplay::DrawP(MAnimWindowFunctions& aFunctions, CAnimGc& aGc) const
+	{
+	DrawClippedToDisplayRegionP(aFunctions, aGc);
+	}
+
+void DDisplay::UpdateLP(DAnimWithUtils::TFunctions& aFunctions, CAnimGc& aGc, const TTime& aTime)
+	{
+	aFunctions.iWindowFunctions.ActivateGc();
+#if defined(__SHOW_UPDATE_REGION__)
+	DrawClippedToDisplayRegionP(aFunctions, aGc);
+#endif
+	RRegionBuf10 region;
+	TRAPD(error, UpdateDisplayDataAndDrawClippedToDisplayRegionP(aFunctions, aGc, aTime, IsVisibleAndNotHidden(aFunctions.iWindowFunctions)? &region: NULL));
+	region.Close();
+	if (error!=KErrNone)
+		{
+		__ASSERT_DEBUG(error==KPanicClientFromServer, Panic(EClockServerPanicUnexpectedError));
+		User::Leave(error);
+		}
+	}
+
+TRect DDisplay::RectDrawnTo() const
+	{
+	return TRect(iPosition, iSize);
+	}
+
+TRect DDisplay::RectToInvalidate() const
+	{
+	TRect rect=RectDrawnTo();
+	rect.iTl.iX-=iMargins.iLeft;
+	rect.iTl.iY-=iMargins.iTop;
+	rect.iBr.iX+=iMargins.iRight;
+	rect.iBr.iY+=iMargins.iBottom;
+	return rect;
+	}
+
+void DDisplay::HandleCommandLP(DAnimWithUtils::TFunctions& aFunctions, CAnimGc& aGc, const TTime& aTime, TInt aOpcode, TAny* aArgs)
+	{
+	TPoint position=iPosition;
+	TSize size=iSize;
+	switch (aOpcode)
+		{
+	case EDisplayCommandSetVisible:
+		{
+		SDisplayCommandSetVisibleArgs* displayArgs=(SDisplayCommandSetVisibleArgs*)aArgs;
+		if (iVisible!=displayArgs->iVisible)
+			{
+			iVisible=displayArgs->iVisible;
+			aFunctions.iWindowFunctions.Invalidate(RectToInvalidate());
+			}
+		}
+		break;
+	case EDisplayCommandSetPositionAndSize:
+		{
+		SDisplayCommandSetPositionAndSizeArgs* displayArgs=(SDisplayCommandSetPositionAndSizeArgs*)aArgs;
+		position=displayArgs->iPosition;
+		size=displayArgs->iSize;
+		}
+		goto setPositionAndOrSize;
+	case EDisplayCommandSetPosition:
+		{
+		SDisplayCommandSetPositionArgs* displayArgs=(SDisplayCommandSetPositionArgs*)aArgs;
+		position=displayArgs->iPosition;
+		}
+		goto setPositionAndOrSize;
+	case EDisplayCommandSetSize:
+		{
+		SDisplayCommandSetSizeArgs* displayArgs=(SDisplayCommandSetSizeArgs*)aArgs;
+		size=displayArgs->iSize;
+		}
+		goto setPositionAndOrSize;
+	setPositionAndOrSize:
+		if ((iPosition!=position) || (iSize!=size))
+			{
+			TRect oldRectToInvalidate=RectToInvalidate();
+			iPosition=position;
+			iSize=size;
+			PositionOrSizeHasChanged();
+			TRect newRectToInvalidate=RectToInvalidate();
+			if (newRectToInvalidate.Intersects(oldRectToInvalidate))
+				newRectToInvalidate.BoundingRect(oldRectToInvalidate);
+			else
+				if (iVisible)
+					aFunctions.iWindowFunctions.Invalidate(oldRectToInvalidate);
+			aFunctions.iWindowFunctions.SetRect(newRectToInvalidate);
+			if (iVisible)
+				aFunctions.iWindowFunctions.Invalidate(newRectToInvalidate);
+			}
+		break;
+	case EDisplayCommandUpdateDisplay:
+		UpdateLP(aFunctions, aGc, aTime);
+		break;
+	case EDisplayCommandDraw:
+		aFunctions.iWindowFunctions.ActivateGc();
+		DrawP(aFunctions.iWindowFunctions, aGc);
+		break;
+	default:
+		PanicClientFromServer();
+		break;
+		}
+	}
+
+void DDisplay::PositionOrSizeHasChanged()
+	{
+	}
+
+void DDisplay::SetPosition(const TPoint& aPosition)
+	{
+	iPosition=aPosition;
+	}
+
+void DDisplay::DrawClippedToDisplayRegionP(MAnimWindowFunctions& aFunctions, CAnimGc& aGc, TRegion* aRegion) const
+	{
+	if (IsVisibleAndNotHidden(aFunctions))
+		{
+		TRect rectDrawnTo=RectDrawnTo();
+		const TRegionFix<1> regionDrawnTo=rectDrawnTo;
+		const TRegion* clippingRegion=NULL;
+		TBool fullDrawRequired=ETrue;
+		if (aRegion!=NULL)
+			{
+			aRegion->Intersect(regionDrawnTo);
+			aRegion->Tidy();
+			if (aRegion->CheckError()==KErrNone)
+				{
+				clippingRegion=aRegion;
+				fullDrawRequired=EFalse;
+				}
+			}
+		if (clippingRegion==NULL)
+			clippingRegion=&regionDrawnTo;
+		if (!clippingRegion->IsEmpty())
+			{
+#if defined(__SHOW_UPDATE_REGION__)
+			aGc.SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);
+			aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+			aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+			aGc.DrawRect(rectDrawnTo);
+#endif
+			TRect clippingRegionBoundingRect=clippingRegion->BoundingRect();
+			aGc.SetClippingRect(clippingRegionBoundingRect);
+			aGc.SetClippingRegion(*clippingRegion); // N.B. cannot fail
+			DoDrawP(aGc, fullDrawRequired, clippingRegionBoundingRect);
+			aGc.CancelClippingRegion();
+			aGc.CancelClippingRect();
+			}
+		}
+	}
+
+void DDisplay::UpdateDisplayDataAndDrawClippedToDisplayRegionP(DAnimWithUtils::TFunctions& aFunctions, CAnimGc& aGc, const TTime& aTime, TRegion* aRegion)
+	{
+	UpdateDisplayDataP(aFunctions.iFunctions, aTime, aRegion);
+	DrawClippedToDisplayRegionP(aFunctions.iWindowFunctions, aGc, aRegion);
+	}
+
+TBool DDisplay::IsVisibleAndNotHidden(MAnimWindowFunctions& aFunctions) const
+	{
+	return iVisible && !aFunctions.IsHidden();
+	}
+
+// DDigitalDisplay
+
+DDigitalDisplay::DDigitalDisplay(const TPoint& aPosition, const TSize& aSize, const TMargins& aMargins, const STimeDeviceShadow& aShadow, TRgb aBackgroundColor, TInt aNumTextSections)
+	:DDisplay(aPosition, aSize, aMargins, aShadow),
+	 iBackgroundColor(aBackgroundColor),
+	 iFlashStateOn(ETrue)
+#pragma warning (disable: 4705)
+	{
+#pragma warning (default: 4705)
+	__DECLARE_NAME(_S("DDigitalDisplay"));
+
+	__ASSERT_ALWAYS((aNumTextSections>0) && (aNumTextSections<=KMaxTInt16), PanicClientFromServer());
+	iTextSections.iNumTextSections=(TInt16)aNumTextSections;
+	__ASSERT_DEBUG(iTextSections.iNumTextSectionsAdded==0, Panic(EClockServerPanicNotInitializedToNULL1));
+	__ASSERT_DEBUG(iTextSections.iTextSections==NULL, Panic(EClockServerPanicNotInitializedToZero1));
+	}
+
+void DDigitalDisplay::AddTextSectionLP(DDigitalDisplayTextSection* aTextSection)
+	{
+	__ASSERT_ALWAYS(iTextSections.iNumTextSectionsAdded<iTextSections.iNumTextSections, PanicClientFromServer());
+	if (iTextSections.iTextSections==NULL)
+		iTextSections.iTextSections=new(ELeave) DDigitalDisplayTextSection*[iTextSections.iNumTextSections];
+
+	iTextSections.iTextSections[iTextSections.iNumTextSectionsAdded++]=aTextSection; // ownership is only taken after everything that can leave has succeeded
+	}
+
+void DDigitalDisplay::SetInitialTimeP(const TTime& aTime)
+	{
+	__ASSERT_ALWAYS(iTextSections.iNumTextSectionsAdded==iTextSections.iNumTextSections, PanicClientFromServer());
+	for (TInt i=0; i<iTextSections.iNumTextSections; ++i)
+		iTextSections.iTextSections[i]->SetInitialTimeP(aTime,iTimeResolutionLimitedToMinutes);
+	}
+
+DDigitalDisplay::~DDigitalDisplay()
+	{
+	if (iTextSections.iTextSections!=NULL)
+		{
+		for (TInt i=0; i<iTextSections.iNumTextSectionsAdded; ++i)
+			delete iTextSections.iTextSections[i];
+		delete [] iTextSections.iTextSections;
+		}
+	}
+
+void DDigitalDisplay::HandleCommandLP(DAnimWithUtils::TFunctions& aFunctions, CAnimGc& aGc, const TTime& aTime, TInt aOpcode, TAny* aArgs)
+	{
+	switch (aOpcode)
+		{
+	case EDigitalDisplayCommandSetBackgroundColor:
+		{
+		SDigitalDisplayCommandSetBackgroundColorArgs* digitalDisplayArgs=(SDigitalDisplayCommandSetBackgroundColorArgs*)aArgs;
+		if ((iBackgroundColor!=digitalDisplayArgs->iBackgroundColor) || (iShadow.iColor!=digitalDisplayArgs->iShadowColor))
+			{
+			iBackgroundColor=digitalDisplayArgs->iBackgroundColor;
+			iShadow.iColor=digitalDisplayArgs->iShadowColor;
+			aFunctions.iWindowFunctions.ActivateGc();
+			DrawP(aFunctions.iWindowFunctions, aGc);
+			}
+		}
+		break;
+	case EDigitalDisplayCommandSetTextColor:
+		{
+		SDigitalDisplayCommandSetTextColorArgs* digitalDisplayArgs=(SDigitalDisplayCommandSetTextColorArgs*)aArgs;
+		for (TInt i=0; i<iTextSections.iNumTextSections; ++i)
+			iTextSections.iTextSections[i]->SetTextColor(digitalDisplayArgs->iTextColor);
+//		aFunctions.ActivateGc();
+//		DrawP(aFunctions, aGc);
+		}
+		break;
+	default:
+		DDisplay::HandleCommandLP(aFunctions, aGc, aTime, aOpcode, aArgs);
+		break;
+		}
+	}
+
+void DDigitalDisplay::DoDrawP(CAnimGc& aGc, TBool, const TRect&) const
+	{
+	__ASSERT_ALWAYS(iTextSections.iNumTextSectionsAdded==iTextSections.iNumTextSections, PanicClientFromServer());
+	TRect rectDrawnTo=RectDrawnTo();
+	aGc.SetDrawMode(CGraphicsContext::EDrawModePEN);
+	aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+	aGc.SetBrushColor(iBackgroundColor);
+	aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+	aGc.SetPenColor(iBackgroundColor);
+	aGc.DrawRect(rectDrawnTo);
+	if (iShadow.iIsOn)
+		{
+		TRect shadowRect=rectDrawnTo;
+		shadowRect.Move(iShadow.iOffset);
+		for (TInt i=0; i<iTextSections.iNumTextSections; ++i)
+			iTextSections.iTextSections[i]->DrawP(aGc, shadowRect, iFlashStateOn, &iShadow.iColor);
+		}
+	for (TInt i=0; i<iTextSections.iNumTextSections; ++i)
+		iTextSections.iTextSections[i]->DrawP(aGc, rectDrawnTo, iFlashStateOn);
+	}
+
+void DDigitalDisplay::UpdateDisplayDataP(MAnimGeneralFunctions& aFunctions, const TTime& aTime, TRegion* aRegion)
+	{
+	__ASSERT_ALWAYS(iTextSections.iNumTextSectionsAdded==iTextSections.iNumTextSections, PanicClientFromServer());
+	TBool flashStateIsChanging=EFalse;
+	TBool flashStateOn=aFunctions.FlashStateOn();
+	if ((!iFlashStateOn)!=(!flashStateOn)) // "logical-not" both sides before comparing for inequality
+		{
+		iFlashStateOn=flashStateOn;
+		flashStateIsChanging=ETrue;
+		}
+	TRect rectDrawnTo=RectDrawnTo();
+	for (TInt i=0; i<iTextSections.iNumTextSections; ++i)
+		iTextSections.iTextSections[i]->UpdateDisplayDataP(rectDrawnTo, iShadow, aTime, flashStateIsChanging, aRegion,iTimeResolutionLimitedToMinutes);
+	}
+
+// DAnalogDisplay
+
+DAnalogDisplay::DAnalogDisplay(const TPoint& aPosition, const TSize& aSize, const TMargins& aMargins, const STimeDeviceShadow& aShadow, TInt aNumHands)
+	:DDisplay(aPosition, aSize, aMargins, aShadow)
+#pragma warning (disable: 4705)
+	{
+#pragma warning (default: 4705)
+	__DECLARE_NAME(_S("DAnalogDisplay"));
+
+	__ASSERT_DEBUG(iFace==NULL, Panic(EClockServerPanicNotInitializedToNULL2));
+	__ASSERT_DEBUG(iFaceMask==NULL, Panic(EClockServerPanicNotInitializedToNULL3));
+	__ASSERT_ALWAYS((aNumHands>0) && (aNumHands<=KMaxTInt16), PanicClientFromServer());
+	iHands.iNumHands=(TInt16)aNumHands;
+	__ASSERT_DEBUG(iHands.iNumHandsAdded==0, Panic(EClockServerPanicNotInitializedToNULL4));
+	__ASSERT_DEBUG(iHands.iHands==NULL, Panic(EClockServerPanicNotInitializedToZero2));
+	__ASSERT_DEBUG(iAmPm==NULL, Panic(EClockServerPanicNotInitializedToNULL5));
+	}
+
+void DAnalogDisplay::ConstructL(MAnimGeneralFunctions& aFunctions, TInt aFaceHandle, TInt aFaceMaskHandle)
+	{
+	iFace=aFunctions.DuplicateBitmapL(aFaceHandle);
+	if (aFaceMaskHandle!=0)
+		iFaceMask=aFunctions.DuplicateBitmapL(aFaceMaskHandle);
+	}
+
+void DAnalogDisplay::AddHandLP(DAnalogDisplayHand* aHand)
+	{
+	__ASSERT_ALWAYS(iHands.iNumHandsAdded<iHands.iNumHands, PanicClientFromServer());
+	if (iHands.iHands==NULL)
+		iHands.iHands=new(ELeave) DAnalogDisplayHand*[iHands.iNumHands];
+
+	iHands.iHands[iHands.iNumHandsAdded++]=aHand; // ownership is only taken after everything that can leave has succeeded
+	}
+
+void DAnalogDisplay::AddAmPmLP(MAnimGeneralFunctions& aFunctions, const TPoint& aPositionRelativeToFace, const TSize& aSize, const STimeDeviceShadow& aShadow, TRgb aBackgroundColor, TInt aFontHandle, TRgb aTextColor)
+	{
+	__ASSERT_ALWAYS((iAmPm==NULL) && (iFace!=NULL), PanicClientFromServer());
+	iAmPmPositionRelativeToFace=aPositionRelativeToFace;
+	TMargins margins;
+	margins.iLeft=0;
+	margins.iRight=0;
+	margins.iTop=0;
+	margins.iBottom=0;
+	iAmPm=new(ELeave) DAmPmDisplay(AmPmPosition(), aSize, margins, aShadow, aBackgroundColor);
+	iAmPm->ConstructLP(aFunctions, aTextColor, aFontHandle);
+	}
+
+void DAnalogDisplay::SetInitialTimeP(const TTime& aTime)
+	{
+	__ASSERT_ALWAYS(iHands.iNumHandsAdded==iHands.iNumHands, PanicClientFromServer());
+	if (iAmPm!=NULL)
+		iAmPm->SetInitialTimeP(aTime);
+	for (TInt i=0; i<iHands.iNumHands; ++i)
+		iHands.iHands[i]->SetInitialTimeP(aTime);
+	}
+
+DAnalogDisplay::~DAnalogDisplay()
+	{
+	delete iFace;
+	delete iFaceMask;
+	delete iAmPm;
+	if (iHands.iHands!=NULL)
+		{
+		for (TInt i=0; i<iHands.iNumHandsAdded; ++i)
+			delete iHands.iHands[i];
+		delete [] iHands.iHands;
+		}
+	}
+
+void DAnalogDisplay::PositionOrSizeHasChanged()
+	{
+	if (iAmPm!=NULL)
+		iAmPm->SetPosition(AmPmPosition());
+	}
+
+TRect DAnalogDisplay::FaceRect() const
+	{
+	TRect rectDrawnTo=RectDrawnTo();
+	TSize sizeDrawnTo=rectDrawnTo.Size();
+	TSize faceSize=iFace->SizeInPixels();
+	TPoint facePosition=rectDrawnTo.iTl+TPoint((sizeDrawnTo.iWidth-faceSize.iWidth)/2, (sizeDrawnTo.iHeight-faceSize.iHeight)/2);
+	return TRect(facePosition, faceSize);
+	}
+
+// Function to stop a the specified hand types from being displayed
+void DAnalogDisplay::DisableHands(TBool aHourHand, TBool aMinuteHand, TBool aSecondHand)
+	{
+	if(aHourHand)
+		iHands.iHandsDisabled|=EHourHand;
+	if(aMinuteHand)
+		iHands.iHandsDisabled|=EMinuteHand;
+	if(aSecondHand)
+		iHands.iHandsDisabled|=ESecondHand;
+
+	}
+
+// Function to re-enable the displaying of the specified hand types after a call to DisableHands()
+void DAnalogDisplay::EnableHands(TBool aHourHand, TBool aMinuteHand, TBool aSecondHand)
+	{
+	if(aHourHand)
+		iHands.iHandsDisabled&= ~EHourHand;
+	if(aMinuteHand)
+		iHands.iHandsDisabled&= ~EMinuteHand;
+	if(aSecondHand)
+		iHands.iHandsDisabled&= ~ESecondHand;
+	}
+
+void DAnalogDisplay::DoDrawP(CAnimGc& aGc, TBool aFullDrawRequired, const TRect& aClippingRect) const
+	{
+	__ASSERT_ALWAYS(iHands.iNumHandsAdded==iHands.iNumHands, PanicClientFromServer());
+	aGc.SetDrawMode(CGraphicsContext::EDrawModePEN);
+	TRect rectDrawnTo=RectDrawnTo();
+	TRect rectDrawnToRelativeToFace=rectDrawnTo;
+	rectDrawnToRelativeToFace.Move(-FaceRect().iTl);
+	if ((iFaceMask!=NULL) && aFullDrawRequired)
+		aGc.BitBltMasked(rectDrawnTo.iTl, iFace, rectDrawnToRelativeToFace, iFaceMask, EFalse);
+	else
+		aGc.BitBlt(rectDrawnTo.iTl, iFace, rectDrawnToRelativeToFace);
+	if (iAmPm!=NULL)
+		{
+		TRect temp=iAmPm->RectDrawnTo();
+		if (temp.Intersects(aClippingRect))
+			{
+			temp.Intersection(aClippingRect);
+			aGc.SetClippingRect(temp);
+			iAmPm->DoDrawP(aGc, aFullDrawRequired, temp);
+			aGc.SetClippingRect(aClippingRect);
+			}
+		}
+	TPoint handCenter=HandCenter();
+	if (iShadow.iIsOn)
+		{
+		TPoint shadowHandCenter=handCenter+iShadow.iOffset;
+		DrawHands(aGc, shadowHandCenter, &iShadow.iColor);
+		}
+	DrawHands(aGc, handCenter);
+	}
+	
+void DAnalogDisplay::DrawHands(CAnimGc& aGc, const TPoint& aCenter,  const TRgb* aShadowColour) const
+	{
+	for (TInt i=0; i<iHands.iNumHands; ++i)
+		{
+		// Only draw enabled hands
+		if( ((iHands.iHands[i]->Type() == EAnalogDisplayHandOneRevPer12Hours)&&(!(iHands.iHandsDisabled&EHourHand)))
+			||((iHands.iHands[i]->Type() == EAnalogDisplayHandOneRevPerHour)&&(!(iHands.iHandsDisabled&EMinuteHand)))
+			||((iHands.iHands[i]->Type() == EAnalogDisplayHandOneRevPerMinute)&&(!(iHands.iHandsDisabled&ESecondHand))) )
+			{
+			iHands.iHands[i]->DrawP(aGc, aCenter, aShadowColour);
+			}
+		}
+	}
+
+void DAnalogDisplay::UpdateDisplayDataP(MAnimGeneralFunctions& aFunctions, const TTime& aTime, TRegion* aRegion)
+	{
+	__ASSERT_ALWAYS(iHands.iNumHandsAdded==iHands.iNumHands, PanicClientFromServer());
+	if (iAmPm)
+		iAmPm->UpdateDisplayDataP(aFunctions, aTime, aRegion);
+	for (TInt i=0; i<iHands.iNumHands; ++i)
+		{
+		if( ((iHands.iHands[i]->Type() == EAnalogDisplayHandOneRevPer12Hours)&&(!(iHands.iHandsDisabled&EHourHand)))
+			||((iHands.iHands[i]->Type() == EAnalogDisplayHandOneRevPerHour)&&(!(iHands.iHandsDisabled&EMinuteHand)))
+			||((iHands.iHands[i]->Type() == EAnalogDisplayHandOneRevPerMinute)&&(!(iHands.iHandsDisabled&ESecondHand))) )
+			{
+			iHands.iHands[i]->UpdateDisplayDataP(aTime, HandCenter(), iShadow, aRegion);
+			}
+		else
+			{
+			// When a hand is Disabled in needs to be cleared immediately, in some circumstances
+			// the time will be the same as the last time the hand was drawn and this results
+			// in the region not being updated (because no change has occured)
+			// We need to force the update by tricking the updtae code into thinking the hand has moved
+			// This is done by adding 1 to the time.
+			TTime tempTime = aTime+TTimeIntervalSeconds(1);
+			iHands.iHands[i]->UpdateDisplayDataP(tempTime, HandCenter(), iShadow, aRegion);
+			}
+		}
+	}
+
+TPoint DAnalogDisplay::HandCenter() const
+	{
+	return FaceRect().Center();
+	}
+
+TPoint DAnalogDisplay::AmPmPosition() const
+	{
+	return FaceRect().iTl+iAmPmPositionRelativeToFace;
+	}
+
+// DAnalogDisplay::DAmPmDisplay
+
+DAnalogDisplay::DAmPmDisplay::DAmPmDisplay(const TPoint& aPosition, const TSize& aSize, const TMargins& aMargins, const STimeDeviceShadow& aShadow, TRgb aBackgroundColor)
+	:DDigitalDisplay(aPosition, aSize, aMargins, aShadow, aBackgroundColor, 1)
+	{
+	}
+
+void DAnalogDisplay::DAmPmDisplay::ConstructLP(MAnimGeneralFunctions& aFunctions, TRgb aTextColor, TInt aFontHandle)
+	{
+	DDigitalDisplayTextSection* textSection=new(ELeave) DDigitalDisplayTextSection(aFunctions, aTextColor,
+																EDigitalDisplayHorizontalTextAlignmentCenter,
+																EDigitalDisplayVerticalTextAlignmentCenterExclDescent, 0, 0);
+	CleanupStack::PushL(textSection);
+	textSection->ConstructL(KFormatText, aFontHandle);
+	AddTextSectionLP(textSection);
+	CleanupStack::Pop(); // pop off textSection
+	}
+
+void DAnalogDisplay::DAmPmDisplay::DoDrawP(CAnimGc& aGc, TBool aFullDrawRequired, const TRect& aClippingRect) const
+	{
+	DDigitalDisplay::DoDrawP(aGc, aFullDrawRequired, aClippingRect);
+	}
+
+void DAnalogDisplay::DAmPmDisplay::UpdateDisplayDataP(MAnimGeneralFunctions& aFunctions, const TTime& aTime, TRegion* aRegion)
+	{
+	DDigitalDisplay::UpdateDisplayDataP(aFunctions, aTime, aRegion);
+	}
+
+
+void DAnalogDisplay::HandleCommandLP(DAnimWithUtils::TFunctions& aFunctions, CAnimGc& aGc, const TTime& aTime, TInt aOpcode, TAny* aArgs)
+	{
+	switch (aOpcode)
+		{
+	case EDigitalDisplayCommandSetBackgroundColor:
+	case EDigitalDisplayCommandSetTextColor:
+		if (iAmPm)
+			iAmPm->HandleCommandLP(aFunctions,aGc,aTime,aOpcode,aArgs);
+		break;
+	case EAnalogDisplayCommandSetPenColor:
+		{
+		SAnalogDisplayHandFeaturesPenColorArgs* analogDisplayArgs=(SAnalogDisplayHandFeaturesPenColorArgs*)aArgs;
+		for (TInt i=0; i<iHands.iNumHands; ++i)
+			iHands.iHands[i]->SetPenColor(analogDisplayArgs->iPenColor);
+		}
+		break;
+	case EAnalogDisplayCommandSetBrushColor:
+		{
+		SAnalogDisplayHandFeaturesBrushColorArgs* analogDisplayArgs=(SAnalogDisplayHandFeaturesBrushColorArgs*)aArgs;
+		for (TInt i=0; i<iHands.iNumHands; ++i)
+			iHands.iHands[i]->SetBrushColor(analogDisplayArgs->iBrushColor);
+//		iBrushColor=analogDisplayArgs->iBrushColor;
+//		aFunctions.ActivateGc();
+//		DrawP(aFunctions, aGc);
+		}
+		break;
+	default:
+		DDisplay::HandleCommandLP(aFunctions, aGc, aTime, aOpcode, aArgs);
+		break;
+		}
+	}
+//!>