--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/gdi/sgdi/PICTURE.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,290 @@
+// Copyright (c) 1998-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 <gdi.h>
+#include "GDIPANIC.h"
+
+_LIT(KGdiCPicturePanicCategory,"CPicture");
+
+EXPORT_C TPictureHeader::TPictureHeader():
+	iPicture(NULL),
+	iPictureType(KNullUid),
+	iSize()
+/** Constructs a default picture header. */
+	{}
+
+EXPORT_C void TPictureHeader::DeletePicture()
+/** Deletes the internalised picture.
+
+The picture can only be deleted if the picture has been internalized. */
+	{
+	if (iPicture.IsPtr())
+		{
+		delete iPicture.AsPtr();
+		iPicture=NULL;
+		}
+	}
+
+
+// Persist this object
+// Does not take responsibility for storing the picture
+//
+EXPORT_C void TPictureHeader::ExternalizeL(RWriteStream& aStream)const
+/** Externalises a picture header object to a write stream. 
+
+The presence of this function means that the standard templated stream operator<<() 
+is available to externalise objects of this class.
+
+@param aStream The write stream. */
+    {
+    aStream<< iPictureType;
+    aStream<< iPicture;
+	aStream.WriteInt32L(iSize.iWidth);
+	aStream.WriteInt32L(iSize.iHeight);
+    }
+
+
+// Restore this object from the specified stream
+// Does not take responsibility for restoring the picture
+//
+EXPORT_C void TPictureHeader::InternalizeL(RReadStream& aStream)
+/** Internalises a picture header object from a read stream.
+
+The presence of this function means that the standard templated stream operator>>() 
+is available to internalise objects of this class.
+
+@param aStream The read stream. */
+    {
+    aStream>> iPictureType;
+    aStream>> iPicture;
+	iSize.iWidth=aStream.ReadInt32L();
+	iSize.iHeight=aStream.ReadInt32L();
+    }
+
+EXPORT_C CPicture::CPicture():
+	CBase()
+	{
+	__DECLARE_NAME(_S("CPicture"));
+	}
+
+EXPORT_C CPicture::~CPicture()
+/** Frees all resources owned by the object prior to its destruction. */
+	{}
+
+EXPORT_C TPictureCapability CPicture::Capability() const
+/** Gets the picture's capabilities.
+
+These include whether it is scalable and croppable.
+
+@return The capabilities of the picture. */
+	{
+	return TPictureCapability(TPictureCapability::ENotScaleable,EFalse);
+	}
+
+// Assumes everything goes into the head stream.
+// (Must be replaced by concrete pictures that have components)
+//
+EXPORT_C TStreamId CPicture::StoreL(CStreamStore& aStore) const
+/** Stores the picture to the specified store.
+
+The default implementation assumes that the content of the picture is externalized 
+to a single stream. The implementation may need to be changed for those derived 
+classes that have components.
+
+@param aStore The store. 
+@return The ID of the (head) stream used to store the picture. */
+	{
+	RStoreWriteStream stream;
+	TStreamId id=stream.CreateLC(aStore);
+	ExternalizeL(stream);  // provided by the concrete picture stream.CommitL();
+	stream.CommitL();
+	CleanupStack::PopAndDestroy();
+	return id;
+	}
+
+EXPORT_C void CPicture::ResetToOriginal()
+/** Resets the picture's scaling and cropping attributes to their original values. */
+	{
+	TMargins cropInTwips;
+	cropInTwips.iLeft=0;
+	cropInTwips.iRight=0;
+	cropInTwips.iTop=0;
+	cropInTwips.iBottom=0;
+	SetCropInTwips(cropInTwips);
+	SetScaleFactor(1000,1000);
+	}
+
+EXPORT_C void CPicture::GetSizeInPixels(MGraphicsDeviceMap* aMap,TSize& aSize) const
+/** Gets the picture's size in pixels. 
+
+This is calculated from the original size of the picture, taking cropping 
+and scaling into account.
+
+@param aMap The pixels to twips mapping interface of the graphics device 
+@param aSize The size of the picture, in pixels. */
+	{
+	GDI_ASSERT_ALWAYS_GENERAL(aMap!=NULL,User::Panic(KGdiCPicturePanicCategory,KErrNotFound));
+	TSize size;
+	GetSizeInTwips(size);
+	aSize.iWidth = aMap->HorizontalTwipsToPixels(size.iWidth);
+	aSize.iHeight = aMap->VerticalTwipsToPixels(size.iHeight);
+	}
+
+EXPORT_C void CPicture::SetSizeInPixels(MGraphicsDeviceMap* aMap,const TSize& aSize)
+/** Sets the picture's size in pixels.
+
+@param aMap The pixels to twips mapping interface of the graphics device. 
+@param aSize The size of the picture, in pixels. */
+	{
+	GDI_ASSERT_ALWAYS_GENERAL(aMap!=NULL,User::Panic(KGdiCPicturePanicCategory,KErrNotFound));
+	TSize size;
+	size.iWidth = aMap->HorizontalPixelsToTwips(aSize.iWidth);
+	size.iHeight = aMap->VerticalPixelsToTwips(aSize.iHeight);
+	SetSizeInTwips(size);
+	}
+
+EXPORT_C void CPicture::SetScaleFactor(TInt /*aScaleFactorWidth*/,TInt /*aScaleFactorHeight*/)
+/** Sets the picture's scale factors.
+	
+	@param aScaleFactorWidth The width scale factor, in percent. 
+	@param aScaleFactorHeight The height scale factor, in percent. */
+	{
+	}
+
+EXPORT_C TInt CPicture::ScaleFactorWidth() const
+/** Gets the picture's width scale factor.
+
+@return The width scale factor, in percent. */
+	{
+	return 1000; // no scaling
+	}
+
+EXPORT_C TInt CPicture::ScaleFactorHeight() const
+/** Gets the pictures height scale factor.
+
+@return The height scale factor, in percent. */
+	{
+	return 1000; // no scaling
+	}
+
+EXPORT_C void CPicture::GetCropInTwips(TMargins& aCrop) const
+/** Gets the cropping margins of a picture in twips.
+	
+These margins are relative to the original unscaled size of the picture.
+	
+@param aMargins The cropping margins of the picture, in twips */
+    {
+	aCrop.iLeft=0;
+	aCrop.iRight=0;
+	aCrop.iTop=0;
+	aCrop.iBottom=0;
+	}
+
+EXPORT_C void CPicture::SetCropInTwips(const TMargins& /*aMargins*/)
+/** Sets the cropping margins of a picture in twips.
+	
+These are relative to the original unscaled size of the picture.
+	
+@param aMargins The cropping margins of the picture, in twips. */
+	{
+	}
+
+
+EXPORT_C TBool CPicture::LineBreakPossible(TUint /*aClass*/,TBool /*aBeforePicture*/,TBool /*aHaveSpaces*/) const
+/** States whether a line break is possible, either before or after a picture.
+	
+The default implementation returns ETrue, implying that there is a break opportunity 
+both before and after the picture, whether or not a space is present.
+
+This may be overridden for special types of pictures.
+
+@param aClass The line breaking class of the adjacent character. Line breaking 
+classes are defined in the header file, tagma.h
+@param aBeforePicture ETrue, if the adjacent character is before the picture; 
+EFalse, if the adjacent character is afterwards.
+@param aHaveSpaces ETrue, if spaces occur between the adjacent character and 
+the picture; EFalse, otherwise.
+@return ETrue, if a line break is possible; EFalse, otherwise. */
+	{
+	return TRUE;
+	}
+
+
+
+EXPORT_C TBool CPicture::NativePixelSize(TSize&)
+/** Derived classes might be implemented as bitmaps, in that case it might 
+be interesting to now the native pixel size of the bitmap. */
+	{
+	return EFalse;
+	}
+
+EXPORT_C void CPicture::GetSizeInTwips(TSize& aSize) const
+/** Gets the picture's size, in twips.
+
+This size is calculated from the original size of the picture, taking cropping 
+and scaling into account.
+
+@param aSize The size of the picture, in twips. */
+	{
+	TSize originalSizeInTwips;
+	GetOriginalSizeInTwips(originalSizeInTwips);
+	TMargins cropInTwips;
+	GetCropInTwips(cropInTwips);
+	aSize.iWidth = (ScaleFactorWidth()*(originalSizeInTwips.iWidth-cropInTwips.iLeft-cropInTwips.iRight))/1000;
+	aSize.iHeight = (ScaleFactorHeight()*(originalSizeInTwips.iHeight-cropInTwips.iTop-cropInTwips.iBottom))/1000;
+	}
+
+EXPORT_C void CPicture::SetSizeInTwips(const TSize& aSize)
+/** Sets the picture's size, in twips
+
+@param aSize The size of the picture, in twips. */
+	{
+	TSize originalSizeInTwips;
+	GetOriginalSizeInTwips(originalSizeInTwips);
+	TMargins cropInTwips;
+	GetCropInTwips(cropInTwips);
+	TSize size;
+	size.iWidth  = originalSizeInTwips.iWidth-cropInTwips.iLeft-cropInTwips.iRight;
+	size.iHeight = originalSizeInTwips.iHeight-cropInTwips.iTop-cropInTwips.iBottom;
+	TSize scalefactor;
+	if(size.iWidth!=0) scalefactor.iWidth=1000*aSize.iWidth/size.iWidth;
+	if(size.iHeight!=0) scalefactor.iHeight=1000*aSize.iHeight/size.iHeight;
+	SetScaleFactor(scalefactor.iWidth,scalefactor.iHeight);
+ 	}
+
+EXPORT_C void CPicture::AddCropInPixels(MGraphicsDeviceMap* aMap,const TMargins& aMargins)
+/** Adds pixel cropping margins to the picture.
+
+@param aMap The pixels to twips mapping interface of the graphics device 
+@param aMargins The additional pixel cropping margins for the picture, in pixels. */
+	{
+	GDI_ASSERT_ALWAYS_GENERAL(aMap!=NULL,User::Panic(KGdiCPicturePanicCategory,KErrNotFound));
+	TMargins cropInTwips;
+	GetCropInTwips(cropInTwips);
+	TInt scaleFactorWidth=ScaleFactorWidth();
+	if(scaleFactorWidth!=0)
+		{
+		cropInTwips.iLeft += (1000*aMap->HorizontalPixelsToTwips(aMargins.iLeft))/scaleFactorWidth;
+		cropInTwips.iRight += (1000*aMap->HorizontalPixelsToTwips(aMargins.iRight))/scaleFactorWidth;
+		}
+	TInt scaleFactorHeight=ScaleFactorHeight();
+	if(scaleFactorHeight!=0)
+		{
+		cropInTwips.iTop += (1000*aMap->VerticalPixelsToTwips(aMargins.iTop))/scaleFactorHeight;
+		cropInTwips.iBottom += (1000*aMap->VerticalPixelsToTwips(aMargins.iBottom))/scaleFactorHeight;
+		}
+	SetCropInTwips(cropInTwips);
+	}
+