/*

* Copyright (c) 2003 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:  SVG Implementation source file

 *

*/

#if !defined(__E32BASE_H__)

#include <e32base.h>

#endif

#include "SVGTextElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGEngineImpl.h"

#include "SVGSchemaData.h"

#include "SVGFloatCssValueImpl.h"

#include "SVGStrCssValueImpl.h"

#include "SVGIntCssValueImpl.h"

#include "SVGPaintCssValueImpl.h"

#include "GfxLine2D.h"

#include "GfxStroke.h"

#include "GfxColor.h"

#include "GfxAffineTransform.h"

#include "SVGStringTokenizer.h"

#include "GfxGeneralPath.h"

#include "SVGGlyphElementImpl.h"

//#include "SvgDefaultFont.h"

#include "SVGErrorImpl.h"

#include "SVGFourPointRect.h"

#include "hal.h"

#include "hal_data.h"

#define KDefaultFontSize 10

#define KOne 1

#define KDefaultUnitsPerEm 1000

_LIT( KGlyphNameNone, "GlyphNameNone");

_LIT( KDefaultFont, "serif" ); // Similar changes should be applied to Gfx2dGcOpenVg.cpp file

// ---------------------------------------------------------------------------

// Two phase construction

// ---------------------------------------------------------------------------

CSvgTextElementImpl* CSvgTextElementImpl::NewL(  const TUint8 aElemID,

                                                CSvgDocumentImpl* aDoc )

    {

    CSvgTextElementImpl*self    = new ( ELeave ) CSvgTextElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL(  aElemID );

    CleanupStack::Pop();

    return self;

    }

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

CSvgTextElementImpl* CSvgTextElementImpl::NewLC(  const TUint8 aElemID,

                                                CSvgDocumentImpl* aDoc )

    {

    CSvgTextElementImpl*self    = new ( ELeave ) CSvgTextElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL( aElemID );

    return self;

    }

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

CSvgTextElementImpl::CSvgTextElementImpl( CSvgDocumentImpl* aDoc ): iOffset(0)

    {

    SetOwnerDocument(aDoc);

    }

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

void CSvgTextElementImpl::ConstructL(  const TUint8 aElemID )

    {

    CSvgElementImpl::InitializeL(  aElemID );

    iArrayX = new ( ELeave ) CArrayFixFlat<TFloatFixPt>( 1 );

    iArrayY = new ( ELeave ) CArrayFixFlat<TFloatFixPt>( 1 );

	#ifdef SVG_FLOAT_BUILD

    iArrayX->AppendL( TFloatFixPt(0) );

    iArrayY->AppendL( TFloatFixPt(0) );

    iPoint.iX = TFloatFixPt( 0 );

    iPoint.iY = TFloatFixPt( 0 );

	#else

    iArrayX->AppendL( TFloatFixPt( 0 , ETrue) );

    iArrayY->AppendL( TFloatFixPt( 0 , ETrue) );

    iPoint.iX = TFloatFixPt( 0 ,ETrue);

    iPoint.iY = TFloatFixPt( 0 ,ETrue);

	#endif

    iText = HBufC::NewL( 2 );

   // *iText = _L( " " );

    iG1 = HBufC::NewL( 0 );

    iG2 = HBufC::NewL( 0 );

    iU1 = HBufC::NewL( 0 );

    iU2 = HBufC::NewL( 0 );

    iSvgStyleProperties = new(ELeave) RPointerArray<CCssValue>(KCSS_MAX_ATTR);

     User::LeaveIfError( iSvgStyleProperties->Append( NULL ) );

	iSvgStyleProperties->Remove( 0 );

	iTriedLoadingSVGFonts = EFalse;

	iNeedToCacheGlyphs = EFalse;

    iSvgTransformable = CSvgTransformableImpl::NewL();

	//set in the default font...just in case

	SetFontFamilyL(KDefaultFont ); //_L("DefaultFont"));

	iEditable = EFalse;

	if (OwnerDocument())

	{

	((CSvgDocumentImpl*)OwnerDocument())->AddInternalMouseListener( this );

	}

	//gets the default font that the graphics context holds at the start

	//should be whatever the client side specified as the initial fontspec

	//GetCurrentFontScaled(iBitmapFont, iBitmapFontSpec);

    }

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

CSvgTextElementImpl::~CSvgTextElementImpl()

    {

    iGlyphElements.Close();

    if ( iFamilies )

        {

        iFamilies->Reset();

        delete iFamilies;

        iFamilies = NULL;

        }

    if ( iArrayX )

        {

        iArrayX->Reset();

        delete iArrayX;

        iArrayX = NULL;

        }

    if ( iArrayY )

        {

        iArrayY->Reset();

        delete iArrayY;

        iArrayY = NULL;

        }

    if ( iArrayRotate )

        {

        iArrayRotate->Reset();

        delete iArrayRotate;

        iArrayRotate = NULL;

        }

    if ( iText )

        {

        delete iText;

        iText = NULL;

        }

    if ( iG1 )

        {

        delete iG1;

        iG1 = NULL;

        }

    if ( iG2 )

        {

        delete iG2;

        iG2 = NULL;

        }

    if ( iU1)

        {

        delete iU1;

        iU1 = NULL;

        }

    if ( iU2 )

        {

        delete iU2;

        iU2 = NULL;

        }

        ((CSvgDocumentImpl*)OwnerDocument())->RemoveInternalMouseListener( this );

    // The Font is owned by TextElement

    // now as each text element may have its own specific font

    // and keeping one copy at Gc level will not work.

    // Gc is just refering to the Font from Textelement, so

    // need to free it here. Note the iWsSceenDevice initialisation

    // was done in draw as it needs to happens in main thread in case

    // of progressive rendering.

    //

    if (iBitmapFont)

    {

    	 CSvgBitmapFontProvider *tempBitmapFontProvider = ((CSvgDocumentImpl*)iOwnerDocument)->GetBitmapFontProvider();

    	 tempBitmapFontProvider->ReleaseFont(iBitmapFont);

    	 iBitmapFont = NULL;

	}

    if ( iSvgStyleProperties )

        {

        iSvgStyleProperties->Close();

        delete iSvgStyleProperties;

        iSvgStyleProperties = NULL;

        }

    }

// *******************************************************

// From SVG DOM

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

TInt32 CSvgTextElementImpl::NumberOfChars()

    {

    return iText->Length();

    }

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

void CSvgTextElementImpl::GetX( CArrayFix<TFloatFixPt>* aX )

    {

    	if (aX->Count() > 0)

    	{

    aX->At( 0 ) = iPoint.iX;

    	}

    }

// ---------------------------------------------------------------------------

//

// ---------------------------------------------------------------------------

void CSvgTextElementImpl::GetY( CArrayFix<TFloatFixPt>* aY )

    {

    	if (aY->Count() > 0 )

    	{

    aY->At( 0 ) = iPoint.iY;

    	}

    }

// *******************************************************

// SVG Implementation

TBool CSvgTextElementImpl::IsNumberAttributeValid( const TDesC& aValue )

    {

        TBool lValidAttr = EFalse;

        if ( aValue.Length() > 0 )

        {

        TLex    lInput ( aValue );

        TChar tmpchar;

        while ( lInput.Peek() != 0 )

        {

        tmpchar = lInput.Get();

        if( !(tmpchar.IsDigit()) && !(tmpchar == '.') && !(tmpchar == '-') && !(tmpchar == ' ') )

            {

            lValidAttr = EFalse;

            break;

            }

            lValidAttr = ETrue;

        }

        }

        return lValidAttr;

}

// ---------------------------------------------------------------------------

// xml:space is an inheritable attribute which can have one of two values:

//

// default (the initial/default value for xml:space) - When xml:space="default":

//      - Remove all newline characters.

//      - Convert all tab characters into space characters.

//      - Strip off all leading and trailing space characters.

//      - All contiguous space characters will be consolidated.

//

// preserve - When xml:space="preserve" :

//      - Convert all newline and tab characters into space characters.

// ---------------------------------------------------------------------------

void CSvgTextElementImpl::SetTextL( const TDesC& aText )

    {

    _LIT( KPreserve, "preserve" );

    _LIT( KDefault, "default");

    if ( iText )

        {

        delete iText;

        iText = NULL;

        }

    iText = aText.AllocL();

    TPtr textDes = iText->Des();

    TBool def = ETrue;

    // Get the xml:space value.

    TBuf<20> lXmlspace;    

    if(XMLSpace() == KPreserve)

    	{

    	lXmlspace=KPreserve;

    	def=EFalse;

    	}

    else if(XMLSpace() == KDefault)

    	{

    	lXmlspace=KDefault;

    	}

    // xml:space is inherited if not specified

    if ( lXmlspace!= KPreserve && lXmlspace != KDefault) 

        {

		// Traverse to the nearest parent element which has the xml:space 

		// If no xml:space then render using xml:space="default"

	    CSvgElementImpl *lRoot=(CSvgElementImpl *)this->ParentNode();

	 	while(lRoot)

	 		{

	 		if ((lRoot->XMLSpace() == KPreserve))

	    		{

	    		def = EFalse;

	    		break;

	        	}

	        else if(lRoot->XMLSpace()==KDefault)

	        	{

	        	break;	

	        	}

	        lRoot=(CSvgElementImpl *)lRoot->ParentNode();

	 		}

        }

    _LIT(KSpace, " ");

    // default    

    if ( def && lXmlspace != KPreserve )

        {

        // Remove leading, trailing and contiguous spaces

        textDes.TrimAll();

        for (TInt i = textDes.Length() - 1; i >= 0; i--)

        	{

        	// Remove new line character

        	if (textDes[i] == '\n' ||

        	    textDes[i] == '\r') 

       			{

          		textDes.Delete(i,1);

       			}

          	// Tab to be replaced with space.

          	if(textDes[i] == '\t')

          		{

          		textDes.Replace(i,1,KSpace);

          		}           	

        	}

        }

    // preserve

    else

        {

        for ( TInt i = 0; i < textDes.Length(); i++ )

            {

            // ms-dos carriage return contains two characters: 13, 10

           	const TInt KCarriageReturn1 = 13;

           	const TInt KCarriageReturn2 = 10;

           	if ( i + 1 < textDes.Length() &&

           	 	(TInt)textDes[i] == KCarriageReturn1 && 

           	 	(TInt)textDes[i+1] == KCarriageReturn2 )

              	{

                textDes[i] = ' ';

                textDes.Delete( i+1, 1 );

       		    }

			// New line and tab should be replaced by space character.         

           	if (textDes[i] == '\n' ||textDes[i] == '\t')

              	{

                textDes.Replace(i,1, KSpace);

               	}

            }

        }

        iUseDefaultSVGFont = IsMostBasicLatin();

        iNeedToCacheGlyphs = ETrue;

    }

void CSvgTextElementImpl::CacheGlyphsForText()

{

	if (!iNeedToCacheGlyphs || iText == NULL || iText->Length() == 0 || iSVGFont == NULL)

	{

		return;

	}

    // Reset the cache first

    iGlyphElements.Reset();

	//initialize the glyph elements cache array...this seems expensive any other way to do this

	TInt textLength = iText->Length();

	for (TInt j = 0; j < textLength; j++)

	{

		//it might actually be better to put a ptr to missing glyph in here instead of null

		iGlyphElements.Append(NULL);

	}

	//we have an svg font...

    if ( iSVGFont->HasChildNodes() )

    {

    	/*******************************/

    	/* Text Caching functionality, */

    	/*******************************/

        CSvgElementImpl* lFirstChild = ( CSvgElementImpl * ) iSVGFont->FirstChild();

        while ( lFirstChild != NULL )

        {

        	/***********************/

    		/*CACHING HKERN ELEMENT*/

    		/***********************/

            if( lFirstChild->ElemID() == KSvgHkernElement)

            {

            	//1 per font

            	iHkernElement = lFirstChild;

            }

    		/******************************/

    		/*CACHING MISSINGGLYPH ELEMENT*/

    		/******************************/

            if ( lFirstChild->ElemID() == KSvgMissingglyphElement)

            {

            	//1 per font

              	iMissingGlyphElement = lFirstChild;

            }

    		/***********************/

    		/* FONTFACE ELEMENT    */

    		/***********************/

            if ( lFirstChild->ElemID() == KSvgFontfaceElement )

            {

            	//1 per font

				iFontFaceElement = lFirstChild;

            }

            /***********************/

            /* CACHE GLYPH ELEMENT */

            /***********************/

        	if ( lFirstChild->ElemID() == KSvgGlyphElement)

                {

                TPtrC16 lUnicode;

                lFirstChild->GetAttributeDes( KAtrUnicode, lUnicode );

                TPtr textDes = iText->Des();

                TPtrC  lLangCode;

                TInt    langCodeFound = 0;

                TInt checkErrorLangCode = lFirstChild->GetAttributeDes( KAtrLang, lLangCode);

                if (checkErrorLangCode !=  KErrNoAttribute)

                    {

                    TPtrC lXmlLangAttr(this->XMLLang());

                    langCodeFound = lLangCode.CompareF( lXmlLangAttr );

                    }

                TInt textLength = iText->Length();

                for (TInt i=0; i < textLength; i++)

                    {

                    	//this probably isnt right i think one of these is a string that needs to be an int

                    if ( textDes[i] == lUnicode[0] && langCodeFound == 0)

                    	{

                    		//then this text string uses this glyph and we need to cache it in each spot it is used

                    		iGlyphElements[i] = lFirstChild;

                    	}

                    }

                }

      		lFirstChild = ( CSvgElementImpl* ) lFirstChild->NextSibling();

    	}

    }

    iNeedToCacheGlyphs = EFalse;

}

TBool CSvgTextElementImpl::IsMostBasicLatin()

{

	//check to see if all basic latin characters