/*

* 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: smilparser implementation

*

*/

#include "smilparser.h"

#include "smilsequence.h"

#include "smilparallel.h"

#include "smilexclusive.h"

#include "smilmedia.h"

#include "smilregion.h"

#include "smilrootregion.h"

#include "smilpresentation.h"

#include "smilanchor.h"

#include "smilarea.h"

#include "smila.h"

#include "smiltransition.h"

#include "smilprefetch.h"

#include "smilmediafactoryinterface.h"

#include "smilliterals.h"

#include "smillinkedlist.h"

// maximum number of elements allowed in the timegraph

#define MAX_TIMEGRAPH_SIZE 80

// what it says. only used for resolving the content control attribute

#define SYSTEM_SCREEN_DEPTH 16

//#define PARSER_DEBUG

// defined elsewhere

void ParseXmlL( CSmilParser* parser, const TDesC& aSource );

void ParseDomL( CSmilParser* parser, CMDXMLDocument* aSource );

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

// CSmilParser::CSmilParser

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

//

CSmilParser::CSmilParser()

    {    

    }

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

// CSmilParser::~CSmilParser

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

//

CSmilParser::~CSmilParser()

    {

    delete iSwitchStack;

    delete iCurrent; // not yet part of a presentation!

    delete iCurrentRegion;

    if ( iNamespaces )

        {

        CLinkedList<Namespace>::Iter nsi( *iNamespaces );

        while( nsi.HasMore() )

            {

            Namespace& ns = nsi.Next();

            delete ns.name;

            delete ns.uri;

            }

        }

    delete iNamespaces;

    }

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

// CSmilParser::NewL

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

//

EXPORT_C CSmilParser* CSmilParser::NewL( MSmilPlayer* aPlayer )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aPlayer );

    CleanupStack::Pop( self );

    return self;    

    }

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

// CSmilParser::ConstructL

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

//

void CSmilParser::ConstructL( MSmilPlayer* aPlayer )

    {

    iPlayer = aPlayer;

    iCurrent = 0;

    iCurrentRegion = 0;

    iSwitchStack = new( ELeave ) CLinkedList<Switch>();

    iNamespaces = new( ELeave ) CLinkedList<Namespace>();

    }

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

// CSmilParser::Init

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

//

void CSmilParser::Init()

    {

    iState = EInitial;

    delete iCurrent;  //might be some leftovers from a failed parsi

    iCurrent = 0;

    iTimeContainer = 0;

    delete iCurrentRegion;

    iCurrentRegion = 0;

    iCurrentTransition = 0;

    if ( iAnchor )

        {

        iAnchor->Close();

        iAnchor = 0;

        }

    CLinkedList<Namespace>::Iter nsi( *iNamespaces );

    while ( nsi.HasMore() )

        {

        Namespace& ns = nsi.Next();

        delete ns.name;

        delete ns.uri;

        }

    iNamespaces->Empty();

    iArea = 0;

    iIgnoreDepth = 0;

    iDepth = 0;

    iSwitchStack->Empty();

    iSkipContent = ETrue;

    iUnknownElement = EFalse;

    iTag.Set( TPtrC() );

    iParamName.Set( TPtrC() );

    iParamValue.Set( TPtrC() );

    iTimegraphSize = 0;

    }

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

// CSmilParser::ParseL

// 

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

//

EXPORT_C CSmilPresentation* CSmilParser::ParseL( const TDesC& /*aSmil*/, 

                                                 const TDesC& /*aBaseUrl*/ )

    {

#if 0

    // can't parse descriptor with current Symbian DOM parser!!!

#ifdef PARSER_DEBUG

    RDebug::Print(_L("ParseL(): %S"), &aSmil);

#endif    

    Init();

    CSmilPresentation* tempPresentationPointer = CSmilPresentation::NewL( iPlayer );

    // Everything constructed during parsing is owned by the presentation

    // (directly or indirectly) and added there immediatly after construction.

    // Thus it is enough to take care that the presentation gets deleted if 

    // a leave occurs.

    CleanupStack::PushL( tempPresentationPointer );    

    tempPresentationPointer->SetBaseUrlL( aBaseUrl );    

    tempPresentationPointer->SetMaxDownUpScaling( iDown, iUp );    

    iPlayer->GetMediaFactory(tempPresentationPointer)->SetBaseUrlL( aBaseUrl );    

    iPresentation = tempPresentationPointer;    

    TBool ok = ParseXml( this, aSmil ); //parse! (see smilparser_cxml.cpp etc.)

    if ( ok && iState == ESmilFinished )

        {

#ifdef PARSER_DEBUG

        RDebug::Print(_L("Parsed succesfully"));

#endif

        tempPresentationPointer->Ready();    

#ifdef PARSER_DEBUG

        tempPresentationPointer->PrintDebug();    

#endif

        CleanupStack::Pop(); // tempPresentationPointer

        }

    else

        {

#ifdef PARSER_DEBUG

        RDebug::Print(_L("Parsing failed, leaving"));

#endif        

        User::Leave( KErrUnknown );

        }

    return tempPresentationPointer;    

#endif

    return 0;

    }

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

// CSmilParser::ParseL

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

//

EXPORT_C CSmilPresentation* CSmilParser::ParseL( const CMDXMLDocument* aSmilDoc, 

                                                 const TDesC& aBaseUrl )

    {

#ifdef PARSER_DEBUG

    RDebug::Print(_L("ParseL(): parsing DOM"));

#endif

    Init();

    CSmilPresentation* tempPresentationPointer = CSmilPresentation::NewL( iPlayer );

    // Everything constructed during parsing is owned by the presentation

    // (directly or indirectly) and added there immediatly after construction.

    // Thus it is enough to take care that the presentation gets deleted if 

    // a leave occurs.

    CleanupStack::PushL( tempPresentationPointer );    

    tempPresentationPointer->SetBaseUrlL( aBaseUrl );    

    tempPresentationPointer->SetMaxDownUpScaling( iDown, iUp );    

    iPlayer->GetMediaFactory(tempPresentationPointer)->SetBaseUrlL( aBaseUrl );    

    iPresentation = tempPresentationPointer;    

    ParseDomL( this, const_cast<CMDXMLDocument*>( aSmilDoc ) ); //parse! (see smilparser_dom.cpp)

    if ( iState == ESmilFinished )

        {

#ifdef PARSER_DEBUG

        RDebug::Print(_L("Parsed succesfully"));

#endif

        tempPresentationPointer->ReadyL();    

#ifdef PARSER_DEBUG

        tempPresentationPointer->PrintDebug();    

#endif

        CleanupStack::Pop(); // tempPresentationPointer

        }

    else

        {

#ifdef PARSER_DEBUG

        RDebug::Print(_L("Parsing failed, leaving"));

#endif    

        User::Leave( KErrUnknown );

        }

    return tempPresentationPointer;

    }

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

// CSmilParser::BeginElementL

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

//

void CSmilParser::BeginElementL( const TDesC& aName )

    {

#ifdef PARSER_DEBUG

    RDebug::Print(_L("BeginElement: %S"), &aName);

#endif

    iDepth++;

    if ( iIgnoreDepth > 0 )

        {

        iIgnoreDepth++;

        return;

        }

    if ( !iSwitchStack->IsEmpty() && 

         iSwitchStack->Peek().depth == iDepth - 1 && 

         iSwitchStack->Peek().done )

        {

        iIgnoreDepth = 1;

        return;

        }

    if ( aName.CompareF( KSmilTag ) == 0 )

        {        

        if ( iState != EInitial )

            {

            User::Leave( KErrGeneral );

            }

        iState = ESmil;

        iTag.Set( KSmilTag );

        // we need root layout even if there is no <layout> element

        CSmilRootRegion* root = CSmilRootRegion::NewL( iPresentation );

        iPresentation->SetLayout( root );        

        }

    else if ( aName.CompareF( KRegionTag ) == 0 )

        {

        if ( iState != ELayout )

            {

            User::Leave( KErrGeneral );

            }

        iTag.Set( KRegionTag );

        CSmilRegion* r = CSmilRegion::NewL( iPresentation );

        iCurrentRegion = r;

        }

    else if ( aName.CompareF( KHeadTag ) == 0 )

        {

        if (iState != ESmil)

            {

            User::Leave( KErrGeneral );

            }

        iState = EHead;

        iTag.Set( KHeadTag );

        }

    else if ( aName.CompareF( KLayoutTag ) == 0 )

        {

        if ( iState != EHead )

            {

            User::Leave( KErrGeneral );

            }

        iState = ELayout;

        iTag.Set( KLayoutTag );

        iPresentation->GetLayout()->SetDefaultLayout( EFalse );

        }

    else if ( aName.CompareF( KRootLayoutTag ) == 0 && 

              iState == ELayout )

        {

        if ( iState != ELayout )

            {

            User::Leave( KErrGeneral );

            }

        iTag.Set( KRootLayoutTag );

        iCurrentRegion = iPresentation->GetLayout();

        }    

    else if ( aName.CompareF( KBodyTag ) == 0 )

        {        

        if ( iState != ESmil && 

             iState != EHeadFinished )

            {

            User::Leave( KErrGeneral );

            }

        iTag.Set( KBodyTag );

        CSmilSequence* body = CSmilSequence::NewL( iPresentation );

        iPresentation->SetTimegraph( body );

        iCurrent = body;

        iState = EBody;

        }

    else if ( aName.CompareF( KSeqTag ) == 0 )

        {

        if ( iState != EBody )

            {

            User::Leave(KErrGeneral);

            }

        iTag.Set( KSeqTag );

        iCurrent = CSmilSequence::NewL( iPresentation );

        }    

    else if ( aName.CompareF( KParTag ) == 0 )

        {

        if ( iState != EBody )

            {

            User::Leave(KErrGeneral);

            }

        iTag.Set( KParTag );

        iCurrent = CSmilParallel::NewL( iPresentation );        

        }

    else if ( aName.CompareF( KExclTag ) == 0 )

        {

        if ( iState != EBody )

            {

            User::Leave( KErrGeneral );

            } 

        iTag.Set( KExclTag );

        iCurrent = CSmilExclusive::NewL( iPresentation );

        }

    else if ( aName.CompareF( KTransitionTag ) == 0 )

        {

        if ( iState != EHead && 

             iState != ELayoutFinished )

            {

            User::Leave( KErrGeneral );

            }

        iTag.Set( KTransitionTag );

        iCurrentTransition = new (ELeave) CSmilTransition();

        iPresentation->AddTransitionL( iCurrentTransition );

        }

    else if ( aName.CompareF( KImageTag ) == 0 ||

              aName.CompareF( KTextTag ) == 0 ||

              aName.CompareF( KAudioTag ) == 0 ||

              aName.CompareF( KRefTag ) == 0 ||

              aName.CompareF( KTextStreamTag ) == 0 ||

              aName.CompareF( KAnimationTag ) == 0 ||

              aName.CompareF( KVideoTag ) == 0 )

        {

        if ( iState != EBody )

            {

            User::Leave(KErrGeneral);

            }

        iTag.Set( KRefTag );

        iCurrent = CSmilMedia::NewL( iPresentation );    

        if ( iAnchor )

            {

            iCurrent->SetAnchor( iAnchor );

            }

        }

    else if ( aName.CompareF( KParamTag ) == 0 )

        {

        iTag.Set( KParamTag );

        }

    else if ( aName.CompareF( KSwitchTag ) == 0 )

        {

        iTag.Set( KSwitchTag );

        Switch sw;

        sw.depth = iDepth;

        sw.done = EFalse;

        iSwitchStack->PushL( sw );

        }

    else if ( aName.CompareF( KATag ) == 0 )

        {

        iTag.Set( KATag );

        if ( iAnchor )

            {

            iAnchor->Close();

            iAnchor = 0;

            }

        iAnchor = new( ELeave ) CSmilAnchor();

        }

    else if ( aName.CompareF( KAreaTag ) == 0 || 

              aName.CompareF( KAnchorTag ) == 0)

        {

        iTag.Set( KAreaTag );

        iArea = CSmilArea::NewL( iPresentation );    

        iArea->SetTimeContainer( iTimeContainer );

        iCurrent = iArea;

        }

    else if ( aName.CompareF( KPrefetchTag ) == 0 )

        {

        if ( iState != EBody )

            {

            User::Leave(KErrGeneral);

            }

        iTag.Set( KPrefetchTag );

        iCurrent = CSmilPrefetch::NewL( iPresentation );

        }    

    else

        {

        if ( iState != EInitial )

            {

            iUnknownElement = ETrue;

            }

        }

    return;

    }

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

// CSmilParser::EndElementL

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

//

void CSmilParser::EndElementL( const TDesC& aName )

    {

#ifdef PARSER_DEBUG

    RDebug::Print( _L( "EndElement: %S" ), &aName );

#endif

    iDepth--;

    if ( iIgnoreDepth > 0 )

        {

        iIgnoreDepth--;

        return;

        }

    if ( aName.CompareF( KSmilTag ) == 0 )

        {

        if ( iPresentation && 

             iPresentation->GetTimegraph() && 

             iPresentation->GetLayout() )

            {

            iState = ESmilFinished;

            }

        } 

    else if ( aName.CompareF( KHeadTag ) == 0 )

        {

        iState = EHeadFinished;

        } 

    else if ( aName.CompareF( KTransitionTag ) == 0 )

        {

        iCurrentTransition = 0;

        }

    else if ( aName.CompareF( KLayoutTag ) == 0 )

        {

        iState = ELayoutFinished;

        iCurrentRegion = 0;

        }

    else if ( aName.CompareF( KSwitchTag ) == 0 )