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