// Copyright (c) 2005-2010 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:

// Contains client-side shaper functionality.

// 

//

#include "ShapeImpl.h"

#include "ShapeInfo.h"

#include <textbase.h>

#include "TextBasePanic.h"

GLREF_C void TextBasePanic(TInt aError);

/** Construct an RShapeInfo. */

/** @internalComponent */

EXPORT_C RShapeInfo::RShapeInfo()

	: iFont(0), iHeader(0), iEndOfShapedText(-1), iContextualProcessFunc(0) {}

/** Perform shaping on the text in aText between aStartOfTextToShape and

aEndOfTextToShape, based on the script conventions implied by aScriptCode.

@param aFont The font to use for the shaping.

@param aText The text, including context.

@param aStartOfTextToShape

	The start position within aText of the text to be shaped.

@param aEndOfTextToShape

	The end position within aText of the text to be shaped.

@param aScriptCode The script code for the script being shaped.

@param aLanguageCode The language code for the language being shaped.

@return

	KErrNone if the text was successfully shaped, KErrNotSupported if aFont has

	no shaper, KErrCouldNotConnect if the font bitmap server has not been

	started.

*/

TInt RShapeInfo::Open(const CFont* aFont, const TDesC& aText,

	TInt aStartOfTextToShape, TInt aEndOfTextToShape,

	TInt aScriptCode, TInt aLanguageCode)

	{

	TEXTBASE_ASSERT_DEBUG(0 <= aStartOfTextToShape,

		ETextBasePanic_InvalidInputParam);

	TEXTBASE_ASSERT_DEBUG(aStartOfTextToShape <= aEndOfTextToShape,

		ETextBasePanic_InvalidInputParam);

	TEXTBASE_ASSERT_DEBUG(aEndOfTextToShape <= aText.Length(),

		ETextBasePanic_InvalidInputParam);

	iFont = aFont;

	TFontShapeFunctionParameters param;

	param.iText = &aText;

	param.iStart = aStartOfTextToShape;

	param.iEnd = aEndOfTextToShape;

	param.iScript = aScriptCode;

	param.iLanguage = aLanguageCode;

	const TInt r = aFont->ExtendedFunction(KFontGetShaping, &param);

	iHeader = r == KErrNone ? param.iShapeHeaderOutput : 0;

	if(iHeader)

		iEndOfShapedText = aEndOfTextToShape;

	return r;

	}

/** Frees the memory associated with this shaping information. */

/** @internalComponent */

EXPORT_C void RShapeInfo::Close()

	{

	if (iHeader)

		{

		TFontShapeDeleteFunctionParameters param;

		param.iShapeHeader = iHeader;

		iFont->ExtendedFunction(KFontDeleteShaping, &param);

		iHeader = NULL;

		iEndOfShapedText = -1;

		// We don't reset iSingleContextChar because we want the context to remain throughout,

		// even when the session is closed. It would eventually simply go out of scope.

		}

	}

/** Returns the number of glyphs in the shaped output.

@return The number of glyphs. Also equal to the size of the Glyphs() array and

the GlyphPositions() array. */

TInt RShapeInfo::GlyphCount() const

	{

	TEXTBASE_ASSERT_ALWAYS(iHeader, ETextBasePanic_Invariant);

	return iHeader->iGlyphCount;

	}

/** Returns the array of glyphs. These must be ORed with 0x80000000 to make

glyph numbers that functions like CFbsFont::Rasterize can accept to avoid

confusing glyph numbers with Unicode character numbers.

@return The glyph array. The size of this array is RShapeInfo::GlyphCount

@see GlyphCount */

const TInt32* RShapeInfo::Glyphs() const

	{

	TEXTBASE_ASSERT_ALWAYS(iHeader, ETextBasePanic_Invariant);

	return reinterpret_cast<const TInt32*>(iHeader->iBuffer);

	}

/** Returns the array of positions for the glyphs returned by Glyphs, and the

total advance for the text.

@return

	Array of glyph positions in pixels, relative to the pen position before

	the glyphs are drawn. The array has GlyphCount() + 1 entries, as the

	last entry represents the total advance of the text. */

const RShapeInfo::TPoint16* RShapeInfo::GlyphPositions() const

	{

	TEXTBASE_ASSERT_ALWAYS(iHeader, ETextBasePanic_Invariant);

	return reinterpret_cast<const RShapeInfo::TPoint16*>(iHeader->iBuffer

		+ ((iHeader->iGlyphCount) << 2));

	}

/** Returns the pen advance these glyphs require.

@return The pen advance; where to move the pen after drawing all the glyphs. */

RShapeInfo::TPoint16 RShapeInfo::Advance() const

	{

	TEXTBASE_ASSERT_ALWAYS(iHeader, ETextBasePanic_Invariant);

	RShapeInfo::TPoint16 r;

	r.iX = *reinterpret_cast<const TInt16*>(iHeader->iBuffer

		+ (iHeader->iGlyphCount << 3));

	r.iY = *reinterpret_cast<const TInt16*>(iHeader->iBuffer

		+ (iHeader->iGlyphCount << 3) + 2);

	return r;

	}

/** Returns the array of indices.

@return

	Indices[n] is the position in the input text that produced Glyphs[n].

*/

const TInt16* RShapeInfo::Indices() const

	{

	TEXTBASE_ASSERT_ALWAYS(iHeader, ETextBasePanic_Invariant);

	return reinterpret_cast<const TInt16*>(iHeader->iBuffer

		+ (iHeader->iGlyphCount << 3) + 4);

	}

TInt RShapeInfo::EndOfShapedText()

	{

	return iEndOfShapedText;

	}

/** Checks if this shaping information is still occupying memory. */

EXPORT_C TBool RShapeInfo::IsOpen()

	{

	if(iHeader && iHeader->iGlyphCount >= 0 && iHeader->iCharacterCount >=0)

		return ETrue;

	else

		return EFalse;

	}

void RShapeInfo::SetContext(TAny* aContextualProcessFunc)

	{

	iContextualProcessFunc = aContextualProcessFunc;

	}

TAny* RShapeInfo::GetContext()

	{

	return iContextualProcessFunc;

	}