/*

* 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 Engine source file

 *

*/

#include "SVGContentHandler.h"

#include "SVGSchemaData.h"

#include "SVGDocumentImpl.h"

#include "SVGEngineImpl.h"

#include "SVGSvgElementImpl.h"

#include "SVGStringTokenizer.h"

#include "SVGUseElementImpl.h"

#include "SVGAnimationElementImpl.h"

#include "rxmlreader.h"

#include "SVGPaintCssValueImpl.h"

#include "SVGPathElementImpl.h"

#include "GfxGeneralPath.h"

#include "SVGUriReferenceImpl.h"

#include "SVGGradientElementImpl.h"

#include "SVGAnimationBase.h"

#include "SVGTextAreaElementImpl.h"

#include "SVGTextElementImpl.h"

#include "SVGScriptElementImpl.h"

#include "SVGImageElementImpl.h"

#include "SVGMediaElementBase.h"

#include "SVGFontFaceElementImpl.h"

#include <languages.hrh>

//#ifdef RD_SVGT_MEDIAANIMATION_SUPPORT

#include "SVGMediaAnimationElementImpl.h"

//#endif

_LIT(WIDTH, "width");

_LIT(HEIGHT, "height");

_LIT(BEGIN, "begin");

_LIT(END, "end");

_LIT(MOUSEDOWN, "mousedown");

_LIT(MOUSEUP, "mouseup");

_LIT(MOUSEOVER, "mouseover");

_LIT(MOUSEMOVE, "mousemove");

_LIT(MOUSEOUT, "mouseout");

_LIT(FOCUSIN, "focusin");

_LIT(FOCUSOUT, "focusout");

_LIT(ACTIVATE, "activate");

_LIT(CLICK, "click");

_LIT(FILL, "fill");

_LIT(STROKE, "stroke");

_LIT(COLOR, "color");

_LIT(STOP_COLOR, "stop-color");

_LIT(ACCESS,"accessKey");

_LIT(OFFSET, "offset");

_LIT(ZEROVALUE, "0");

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

// Constructor

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

CSvgContentHandler::CSvgContentHandler() : iRootElement( NULL ),

                                           iIsColorAnim( EFalse ),

                                           iRemoveFalseSwitchElements( ETrue )

    {

    iCancelRequested = EFalse;

    }

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

// Destructor

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

CSvgContentHandler::~CSvgContentHandler()

    {

    if(iUseElementArray)

        {

        iUseElementArray->Reset();

        iUseElementArray->Close();

        delete iUseElementArray;

        iUseElementArray = NULL;

        }

    if(iAnimRefElementArray)

        {

        iAnimRefElementArray->Reset();

        iAnimRefElementArray->Close();

        delete iAnimRefElementArray;

        iAnimRefElementArray = NULL;

        }

    if(iSwitchElementArray)

        {

        iSwitchElementArray->Reset();

        iSwitchElementArray->Close();

        delete iSwitchElementArray;

        iSwitchElementArray = NULL;

        }

    if (iReqFetAttSysArray)

        {

        iReqFetAttSysArray->Reset();

        iReqFetAttSysArray->Close();

        delete iReqFetAttSysArray;

        iReqFetAttSysArray = NULL;

        }

    if(iAnimationElementArray)

        {

        iAnimationElementArray->Reset();

        iAnimationElementArray->Close();

        delete iAnimationElementArray;

        }

    if(iCData)

        {

        delete iCData;

        iCData = NULL;

        }

    if ( iSystemLanguage )

        {

        delete iSystemLanguage;

        iSystemLanguage = NULL;

        }

    iImageElements.Close();

    }

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

// CSvgContentHandler* CSvgContentHandler::NewL()

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

CSvgContentHandler* CSvgContentHandler::NewL( TBool aRemoveFalseSwitchElements )

    {

    CSvgContentHandler* self    = new( ELeave ) CSvgContentHandler();

    CleanupStack::PushL( self );

    self->ConstructL( aRemoveFalseSwitchElements );

    CleanupStack::Pop();

    return self;

    }

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

// CSvgContentHandler* CSvgContentHandler::NewLC()

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

CSvgContentHandler* CSvgContentHandler::NewLC()

    {

    CSvgContentHandler* self    = new( ELeave ) CSvgContentHandler();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// void CSvgContentHandler::ConstructL()

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

void CSvgContentHandler::ConstructL( TBool aRemoveFalseSwitchElements )

    {

    /*Arrays added to support Forward referencing in Animation and Use elements*/

    iUseElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

    iAnimRefElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

    // added to hold switch element handles so we can go back and delete false children of the switch

    iSwitchElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

    // Arrays added to reset event listeners for animation element

    iAnimationElementArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

    //added to hold elements with required features, attributes, or sys language

    //so we can go back and delete the ones that dont pass at the start.

    iReqFetAttSysArray = new (ELeave)RPointerArray<CSvgElementImpl> (1);

    // Create a 1KB buffer for CData -- this will expand as needed

    iCData = HBufC::NewL( 1024 );

    iSystemLanguage = HBufC::NewL( 5 );

		iRemoveFalseSwitchElements = aRemoveFalseSwitchElements;

    }

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

// CSvgElementImpl* CSvgContentHandler::ParseByteData( CSvgDocumentImpl* aDocument,

//                                                    const TDesC8& aByteData,

//                                                    CSvgErrorImpl& aError )

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

CSvgElementImpl* CSvgContentHandler::ParseByteData( CSvgDocumentImpl* aDocument,

                                                    const TDesC8& aByteData,

                                                    CSvgErrorImpl& aError )

    {

    iDocument = aDocument;

    iSvgError = &aError;

    aError.SetErrorCode( ESvgNoError );

    // Create XML reader

    RXMLReader xmlReader;

    TInt error = KErrNone;

    TRAP( error, xmlReader.CreateL() );

    if ( error != KErrNone )

        {

        _LIT(OUTMEMORY, "Out of memory");

        aError.SetErrorCode( ESvgNoMemory );

        aError.SetDescription( OUTMEMORY );

        aError.SetIsWarning( EFalse );

        return iRootElement;

        }

    // Parse content

    xmlReader.SetContentHandler( this );

    TRAPD( parseError, xmlReader.ParseL( aByteData ) );

    xmlReader.Destroy();

    if ( !iCancelRequested && parseError != KErrNone )

        {

        if ( iSvgError->HasError() )

            return iRootElement;

        aError.SetErrorCode( ESvgUnknown );

        if ( parseError == -4 )

            {

            _LIT(OUTMEMORY, "Out of memory");

            aError.SetDescription( OUTMEMORY );

            }

        else

            {

            _LIT(STRING, "Parsing SVG document failed.");

            aError.SetDescription( STRING );

            }

        aError.SetIsWarning( EFalse );

        aError.SetSystemErrorCode( parseError );

        return iRootElement;

        }

    if ( iRootElement == NULL )

        {

        _LIT(STRING, "Invalid SVG Document.");

        aError.SetErrorCode( ESvgDocumentNotValid );

        aError.SetDescription( STRING );

        aError.SetIsWarning( EFalse );

        return iRootElement;

        }

    else if ( !iCancelRequested )

        {

        SetForwardReferences(aError);

        PostParseProcessing();

        }

    return iRootElement;

    }

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

// CSvgElementImpl* CSvgContentHandler::Parse16BitData( CSvgDocumentImpl* aDocument,

//                                                    const TDesC8& aByteData,

//                                                    CSvgErrorImpl& aError )

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

CSvgElementImpl* CSvgContentHandler::Parse16BitData( CSvgDocumentImpl* aDocument,

                                                    const TDesC16& aSvgString,

                                                    CSvgErrorImpl& aError )

    {

    iDocument = aDocument;

    iSvgError = &aError;

    aError.SetErrorCode( ESvgNoError );

    // Create XML reader

    RXMLReader xmlReader;

    TInt error = KErrNone;

    TRAP( error, xmlReader.CreateL() );

    if ( error != KErrNone )

        {

        _LIT(OUTMEMORY, "Out of memory");

        aError.SetErrorCode( ESvgNoMemory );

        aError.SetDescription( OUTMEMORY );

        aError.SetIsWarning( EFalse );

        return iRootElement;

        }

    // Parse content

    xmlReader.SetContentHandler( this );

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

    //THIS IS TEMPORARY

    //convert to 8 bit here temporary until I get 16 bit parsing method...

    //TRAPD( parseError, xmlReader.ParseXML( aSvgString ) );

    //convert 16 to 8 bit characters

    HBufC8* lString8 = NULL;

    lString8 = HBufC8::New( aSvgString.Length() );

	if(NULL==lString8)

	{

		_LIT(OUTMEMORY, "Out of memory");

		aError.SetErrorCode( ESvgNoMemory );

        aError.SetDescription( OUTMEMORY );

        aError.SetIsWarning( EFalse );

		return iRootElement;

	}

    lString8->Des().Copy(aSvgString);

    TRAPD( parseError, xmlReader.ParseL( *lString8 ) );

    delete lString8 ; 

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

    xmlReader.Destroy();

    if ( !iCancelRequested && parseError != KErrNone )

        {

        if ( iSvgError->HasError() )

            return iRootElement;

        aError.SetErrorCode( ESvgUnknown );

        if ( parseError == -4 )

            {

            _LIT(OUTMEMORY, "Out of memory");

            aError.SetDescription( OUTMEMORY );

            }

        else

            {

            _LIT(STRING, "Parsing SVG document failed.");

            aError.SetDescription( STRING );

            }

        aError.SetIsWarning( EFalse );

        aError.SetSystemErrorCode( parseError );

        return iRootElement;

        }

    if ( iRootElement == NULL )

        {

        _LIT(STRING, "Invalid SVG Document.");

        aError.SetErrorCode( ESvgDocumentNotValid );

        aError.SetDescription( STRING );

        aError.SetIsWarning( EFalse );

        return iRootElement;

        }

    else if ( !iCancelRequested )

        {

        //POST PARSING PROCESSING

        SetForwardReferences(aError);

        RemoveFalseElementsOrMakeInvisible();

        RemoveFalseSwitchCasesOrMakeInvisible();

        if ( !iSvgError->HasError())

        {

        LoadImages();

        }

        }

    return iRootElement;

    }

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

// CSvgElementImpl* CSvgContentHandler::ParseFile( CSvgDocumentImpl* aDocument,

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

CSvgElementImpl* CSvgContentHandler::ParseFile( CSvgDocumentImpl* aDocument,

                                                    const TDesC& aFileName,

                                                    CSvgErrorImpl& aError )

    {

    iDocument = aDocument;

    iSvgError = &aError;

    aError.SetErrorCode( ESvgNoError );

    RFs session;

    TInt serror = session.Connect ();

    if( serror != KErrNone)

        {

        _LIT(STRING, "Cannot create a session to read the file.");

        aError.SetErrorCode ( ESvgUnknown );

        aError.SetDescription( STRING );

        aError.SetIsWarning( EFalse );

        return NULL;

        }

    // Create XML reader

    RXMLReader xmlReader;

    TInt error = KErrNone;

    TRAP( error, xmlReader.CreateL() );

    if ( !iCancelRequested && error != KErrNone )

        {

        _LIT(OUTMEMORY, "Out of memory");

        aError.SetErrorCode( ESvgNoMemory );

        aError.SetDescription( OUTMEMORY );

        aError.SetIsWarning( EFalse );

        return iRootElement;

        }

    // Parse content

    xmlReader.SetContentHandler( this );

    TRAP( error, xmlReader.ParseL( session, aFileName) );

    xmlReader.Destroy();

    if ( error != KErrNone || iRootElement == NULL )

        {

        _LIT(STRING, "Invalid SVG Document.");

        aError.SetErrorCode( ESvgDocumentNotValid );

        aError.SetDescription( STRING );

        aError.SetIsWarning( EFalse );

        }

    else if ( !iCancelRequested )

        {

        SetForwardReferences(aError);

        PostParseProcessing();

        }

    session.Close();

    return iRootElement;

    }

void CSvgContentHandler::PostParseProcessing()

{

    // This situation occurs when parsing is done in a separate thread then the draw thread

    // Wait for drawing to complete or invalid element pointer may occur during drawing

    if ( iDocument->iIsRendering )

        {

        TInt waitCount = 0;

        // total of 1 seconds

        while ( waitCount++ < 200000 && iDocument->iIsRendering )

            {

            User::After( 50 ); // 50 microseconds

            }

        // Cannot wait any longer, prevent being stuck here

        if ( iDocument->iIsRendering )

            {

            return;

            }

        }

    iDocument->iIsPruningTree = ETrue;

    RemoveFalseElementsOrMakeInvisible();

    RemoveFalseSwitchCasesOrMakeInvisible();

    iDocument->iIsPruningTree = EFalse;

    iDocument->SetImageElementsCount(iImageElements.Count());

    if ( (!iSvgError->HasError())  || iSvgError->IsWarning() )

        {

    LoadImages();

        }

}

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

// TInt CSvgContentHandler::RemoveInternalReferences( CSvgElementImpl* )

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

void CSvgContentHandler::RemoveInternalReferences( CSvgElementImpl* aElement )

    {

    // Remove the references of aElement in content handler's lists

    // Use Elements 

    TInt lIndex = 0;

    if ( aElement->ElemID() == KSvgUseElement )

        {

        lIndex = iUseElementArray->Find( aElement );

        if ( lIndex != KErrNotFound )

            {

            iUseElementArray->Remove( lIndex );

            }

        }

    else if ( aElement->ElemID() == KSvgImageElement )

        {

        // Image elements

        lIndex = iImageElements.Find( (CSvgImageElementImpl* )aElement );

        if ( lIndex != KErrNotFound )

            {

            iImageElements.Remove( lIndex );

            }

        }

    else if ( aElement->ElemID() == KSvgSwitchElement )

        {

        // Switch Elements    

        lIndex = iSwitchElementArray->Find( aElement );

        if ( lIndex != KErrNotFound )

            {

            iSwitchElementArray->Remove( lIndex );

            }

        }

    else if ( aElement->IsAnimatedElement() )

        {

        // Animation elements include animate* elements, set, 

        // "animation",  audio elements etc.

        lIndex = iAnimationElementArray->Find( aElement );

        if ( lIndex != KErrNotFound )

            {

            iAnimationElementArray->Remove( lIndex );

            }        

        lIndex = iAnimRefElementArray->Find( aElement );

        if ( lIndex != KErrNotFound )

            {

            iAnimRefElementArray->Remove( lIndex );

            }

        }

    // Elements with test attributes - requiredFeatures, 

    // requiredExtensions, systemLanguage

    lIndex = iReqFetAttSysArray->Find( aElement );

    if ( lIndex != KErrNotFound )

        {

        iReqFetAttSysArray->Remove( lIndex );

        }

    // Remove Internal references of subtree elements as well

    CSvgElementImpl* lChild = ( CSvgElementImpl* )aElement->FirstChild();

    while ( lChild != NULL )

        {

        RemoveInternalReferences( lChild );

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

        }

    }

/************* Start of MXMLContentHandler methods ************/

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

// TInt CSvgContentHandler::StartDocument()

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

TInt CSvgContentHandler::StartDocument()

    {

    if ( iCancelRequested )

        {

        return EFalse;

        }