Symaptic: os/textandloc/textrendering/texthandling/sconpics/CONPICS.CPP@260cb5ec6c19

     1 /*

     2 * Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    19 #include <e32std.h>

    20 #include <e32base.h>

    22 #include <gdi.h>

    23 #include <s32mem.h>

    24 #include <conpics.h>

    26 #include "TESTPANI.H"

    28 // ***************************************************************************

    29 // MDEMPICTUREHEADERFACTORY IMPLEMENTATION

    30 // ***************************************************************************

    32 EXPORT_C MDemPictureFactory::MDemPictureFactory()

    33 // Fix to force GCC to export the vtable.

    34 //

    35 	{}

    38 EXPORT_C void MDemPictureFactory::NewPictureL(TPictureHeader& aHeader,const CStreamStore& aDeferredPictureStore)const

    39 // From the picture header, instantiates the correct concrete picture, and

    40 // restores it frorm the specified stream.

    41 //

    42 	{

    43 	if (aHeader.iPictureType==KUidXzePictureType)

    44 		aHeader.iPicture=CXzePicture::NewL(aDeferredPictureStore,aHeader.iPicture.AsId());

    45 	else if(aHeader.iPictureType==KUidXzeDoorType)

    46 		aHeader.iPicture=CXzeDoor::NewL(aDeferredPictureStore,aHeader.iPicture.AsId());

    47 	else

    48 		Panic(EPictureTypeNotSupportedByHeader);

    49 	}

    54 // ***************************************************************************

    55 // TEST PICTURE IMPLEMENTATION

    56 // ***************************************************************************

    57 EXPORT_C CXzePicture* CXzePicture::NewL(TChar aLabel)

    58 	{return new(ELeave) CXzePicture(aLabel);}

    61 EXPORT_C CXzePicture* CXzePicture::NewL(const CStreamStore& aStore,TStreamId aId)

    62 // Restoring NewL.

    63 //

    64 	{

    65 	CXzePicture* self=new(ELeave) CXzePicture();

    66 	CleanupStack::PushL(self);

    67 	self->RestoreL(aStore,aId);

    68 	CleanupStack::Pop();

    69 	return self;

    70 	}

    73 EXPORT_C CXzePicture::CXzePicture(TChar aLabel)

    74 // Sets the startup attributes of this picture

    75 //

    76 	: iLabel(aLabel)

    77 	{ResetToOriginal();}

    80 EXPORT_C CXzePicture::CXzePicture()

    81 // Sets the startup attributes of this picture

    82 //

    83 //

    84 	{ResetToOriginal();}

    87 EXPORT_C CXzePicture::~CXzePicture()

    88 	{}

    91 EXPORT_C void CXzePicture::ExternalizeL(RWriteStream& aStream)const

    92 // Save this picture.

    93 // Typically called from the base class StoreL();

    94 //

    95 	{aStream.WriteUint32L(iLabel);}

    98 EXPORT_C void CXzePicture::InternalizeL(RReadStream& aStream)

    99 // Load this picture

   100 //

   101 	{iLabel=(TChar)aStream.ReadUint32L();}

   104 EXPORT_C void CXzePicture::RestoreL(const CStreamStore& aStore,TStreamId aStreamId)

   105 // Create a read-stream over aStore, and open it over the specified stream ID.

   106 // Internalize picture from this stream.

   107 //

   108 	{

   109 	RStoreReadStream stream;

   110 	stream.OpenLC(aStore,aStreamId);

   111 	stream>> *this;

   112 	CleanupStack::PopAndDestroy();

   113 	}

   116 EXPORT_C void CXzePicture::Draw(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aClipRect,MGraphicsDeviceMap* aMap) const

   117 // Draw this simple picture.

   118 //

   119  	{

   120 	aGc.Reset();

   121 	aGc.SetClippingRect(aClipRect);

   122 	TSize size;  // Size of graphics device in pixels

   123 	GetSizeInPixels(aMap,size);

   124 	TRect box;  // The rectangle that exactly fits the picture

   125 	box.iTl=aTopLeft;

   126 	box.iBr.iX=aTopLeft.iX+size.iWidth;

   127 	box.iBr.iY=aTopLeft.iY+size.iHeight;

   128 	TRgb white(255,255,255);

   129 // First draw outer box and fill in rest of box.

   130 	aGc.SetBrushColor(white);

   131 	aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

   132 	aGc.DrawRect(box);

   133 // Now draw label

   134 	CFont* font;

   135 	TFontSpec fontSpec(_L("Arial"),213);

   136 	if (aMap->GetNearestFontInTwips(font,fontSpec)<0)

   137 		{

   138 		return;

   139 		}

   140 	aGc.UseFont(font);

   141 	TBuf<1> label;	label.Append(iLabel);

   142 	TInt baselineOffset=(box.Height()+font->AscentInPixels())/2;

   143 	aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

   144 	aGc.DrawText(label,box,baselineOffset,CGraphicsContext::ECenter);

   145 	aGc.DiscardFont();

   146 	aMap->ReleaseFont(font);

   147 	}

   150 EXPORT_C void CXzePicture::GetOriginalSizeInTwips(TSize& aSize)const

   151 //

   152 	{aSize=iOriginalSizeInTwips;}

   155 EXPORT_C CXzeDoor* CXzeDoor::NewL(TChar aLabel,TBool aAlwaysFailToDetach)

   156 	{return new(ELeave) CXzeDoor(aLabel,aAlwaysFailToDetach);}

   159 EXPORT_C CXzeDoor* CXzeDoor::NewL(const CStreamStore& aStore,TStreamId aId)

   160 // Restoring NewL.

   161 //

   162 	{

   163 	CXzeDoor* self=new(ELeave) CXzeDoor(EFalse);

   164 	CleanupStack::PushL(self);

   165 	self->RestoreL(aStore,aId);

   166 	CleanupStack::Pop();

   167 	return self;

   168 	}

   171 EXPORT_C CXzeDoor::CXzeDoor(TChar aLabel,TBool aAlwaysFailToDetach)

   172 // Sets the startup attributes of this picture

   173 //

   174 	: CXzePicture(aLabel), iAlwaysFailToDetach(aAlwaysFailToDetach)

   175 	{ResetToOriginal();}

   178 EXPORT_C CXzeDoor::CXzeDoor(TBool aAlwaysFailToDetach)

   179 // Sets the startup attributes of this picture

   180 //

   181 //

   182 	: iAlwaysFailToDetach(aAlwaysFailToDetach)

   183 	{ResetToOriginal();}

   186 EXPORT_C void CXzeDoor::DetachFromStoreL(TDetach /*aDegree*/)

   187 //

   188 //

   189 	{

   190 	if (iAlwaysFailToDetach)

   191 		User::Leave(KErrNotSupported);

   192 	}

   194 EXPORT_C void CXzeDoor::ExternalizeL(RWriteStream& aStream)const

   195 // Save this picture.

   196 // Typically called from the base class StoreL();

   197 //

   198 	{

   199 	CXzePicture::ExternalizeL(aStream);

   200 	aStream.WriteUint8L((TUint8)iAlwaysFailToDetach!=EFalse);

   201 	}

   204 EXPORT_C void CXzeDoor::InternalizeL(RReadStream& aStream)

   205 // Load this picture

   206 //

   207 	{

   208 	CXzePicture::InternalizeL(aStream);

   209 	iAlwaysFailToDetach=TBool(aStream.ReadUint8L());

   210 	}

   213 EXPORT_C void CXzeDoor::RestoreL(const CStreamStore& aStore,TStreamId aStreamId)

   214 // Create a read-stream over aStore, and open it over the specified stream ID.

   215 // Internalize picture from this stream.

   216 //

   217 	{

   218 	RStoreReadStream stream;

   219 	stream.OpenLC(aStore,aStreamId);

   220 	stream>> *this;

   221 	CleanupStack::PopAndDestroy();

   222 	}

   225 EXPORT_C CTestPicture* CTestPicture::NewL()

   226 	{return new(ELeave) CTestPicture();}

   229 EXPORT_C CTestPicture::CTestPicture()

   230 	{ResetToOriginal();}

   233 EXPORT_C void CTestPicture::GetOriginalSizeInTwips(TSize& aSize)const

   234 //

   235 	{aSize=iOriginalSizeInTwips;}

   238 EXPORT_C void CTestPicture::Draw(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aClipRect,MGraphicsDeviceMap* /*aMap*/) const

   239 // draw a simple object

   240  {

   241 	aGc.Reset();

   242 	aGc.SetClippingRect(aClipRect);

   243 	TSize size; // Size in pixels

   244 	TSize sizeInner; // In pixels

   245 	TRect box;

   246 	GetSizeInPixels(aGc.Device(),size);

   247 	box.iTl=aTopLeft;

   248 	box.iBr.iX=aTopLeft.iX+size.iWidth;

   249 	box.iBr.iY=aTopLeft.iY+size.iHeight;

   250 	TRgb black(0,0,0);

   251 	TRgb white(255,255,255);

   252 // First draw outer box and fill in rest of box.

   253 	aGc.SetBrushColor(white);

   254 	aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

   255 	aGc.DrawRect(box);

   256 // Inner box.

   257 	sizeInner.iWidth=size.iWidth/3;

   258 	sizeInner.iHeight=size.iHeight/3;

   259 	box.iTl.iX+=sizeInner.iWidth;

   260 	box.iTl.iY+=sizeInner.iHeight;

   261 	box.iBr.iX-=sizeInner.iWidth;

   262 	box.iBr.iY-=+sizeInner.iHeight;

   263 	aGc.SetBrushColor(black);

   264 	aGc.SetBrushStyle(CGraphicsContext::EDiamondCrossHatchBrush);

   265 	aGc.DrawRect(box);

   266 	}

   269 EXPORT_C void CTestPicture::ExternalizeL(RWriteStream& /*aStream*/)const

   270 	{}

   273 ////////////////////////////////////////////////////////////////////////

   275 EXPORT_C CDummyField::CDummyField()

   276 	{

   277 	}

   280 EXPORT_C TInt CDummyField::Value(TPtr& aValueText)

   281 	{

   282 	if (aValueText.MaxLength() < 3)

   283 		return 3;

   284 	else

   285 		{

   286 		aValueText = _L("XXX");

   287 		return 0;

   288 		}

   289 	}

   292 EXPORT_C void CDummyField::ExternalizeL(RWriteStream& aStream)const

   293 	{

   294 	aStream.WriteUint8L(0);  // empty streams cause problems

   295 	}

   298 EXPORT_C void CDummyField::InternalizeL(RReadStream& aStream)

   299 	{

   300 	TUint8 dummy=aStream.ReadUint8L();

   301 	dummy=0;

   302 	}

   305 EXPORT_C TUid CDummyField::Type() const

   306 	{

   307 	return KNullUid;

   308 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--