// 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);

	}