/*

* Copyright (c) 2005,2006 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:  Main class for this component

*

*/

// INCLUDE FILES

#include    "hspsdefinitionengine.h"

#include    "hspsxmlhandler.h"

#include    "hspsodt.h"

#include    "hspslocaleparser.h"

#include    "hspsdomdocument.h"

#include    "hspsdomnode.h"

#include    "hspsdomattribute.h"

#include    "hspsdomlist.h"

#include    "hspsdomdepthiterator.h"

#include    "hspsdefinitionengineinterface.h"

#include    <f32file.h>

//CONSTANT DEFINITIONS

_LIT8(KRef,     "ref");

_LIT8(KId,      "id");

// ============================ LOCAL FUNCTIONS ===============================

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

// DoBuildRefNodesL Find referred node and build subtree if any.

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

//

static void DoBuildRefNodesL( ChspsDomDocument& aDom, ChspsDomNode& aNode )

    {

    ChspsDomAttribute* refAttr = 

        static_cast<ChspsDomAttribute*>( aNode.AttributeList().FindByName( KRef ) );

    ChspsDomDepthIterator* iter = ChspsDomDepthIterator::NewL( *aDom.RootNode() );

    CleanupStack::PushL( iter );

    ChspsDomNode* node = iter->First();

    TBool found( EFalse );

    while ( node && !found )

        {

        ChspsDomAttribute* attr = 

            static_cast<ChspsDomAttribute*>( node->AttributeList().FindByName( KId ) );

        if ( refAttr && attr )

            {

            if ( refAttr->Value().Compare( attr->Value() ) == 0 &&

                aNode.Name().Compare( node->Name() ) == 0 &&

                aNode.Namespace().Compare( node->Namespace() ) == 0 )

                {

                //If referred node is a referrer parent leave because of illegal structure

                ChspsDomNode* parent = aNode.Parent();

                while ( parent )

                    {

                    if ( node == parent )

                        {

                        User::Leave( KErrArgument );

                        }

                    parent = parent->Parent();    

                    }

                //reference to self is also forbidden

                if ( node == &aNode )

                    {

                    User::Leave( KErrArgument );

                    }

                //Build a sub-tree aggregation of ref nodes if any    

                TInt childCount( node->ChildNodes().Length() );

                ChspsDomNode* refNode = NULL;

                ChspsDomNode* referredNode = NULL;

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

                    {

                    referredNode = 

                        static_cast<ChspsDomNode*>( node->ChildNodes().Item( i ) );

                    refNode = referredNode->CreateRefNodeL();

                    CleanupStack::PushL( refNode );

                    aNode.AddChildL( refNode );

                    CleanupStack::Pop( refNode );

                    }

                found = ETrue;

                }

            }

        node = iter->NextL();

        }

    CleanupStack::PopAndDestroy( iter ); 

    }

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

// BuildRefNodesL Goes through the DOM and creates a ref node to match referred 

// sub-tree if any.

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

//

static void BuildRefNodesL( ChspsDomDocument& aDom )

    {

    ChspsDomDepthIterator* iter = ChspsDomDepthIterator::NewL( *aDom.RootNode() );

    CleanupStack::PushL( iter );

    ChspsDomNode* node = iter->First();

    ChspsDomNode* current = node;

    while ( node )

        {

        // Iterator need to continue iterating previous context, 

        // not from added content. If current node is a ref node, it can only 

        // have siblings before referred sub tree is created. 

        current = node;

        node = iter->NextL(); 

        if ( current->IsRefNode() )

            {

            DoBuildRefNodesL( aDom, *current );

            }

        }

    CleanupStack::PopAndDestroy( iter ); 

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// ChspsDefinitionEngine::ChspsDefinitionEngine

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

ChspsDefinitionEngine::ChspsDefinitionEngine()

    {

    }

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

// ChspsDefinitionEngine::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void ChspsDefinitionEngine::ConstructL()

    {

    ihspsXMLHandler = ChspsXMLHandler::NewL();

    }

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

// ChspsDefinitionEngine::NewL

// Two-phased constructor.

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

//

ChspsDefinitionEngine* ChspsDefinitionEngine::NewL()

    {

    ChspsDefinitionEngine* self = new( ELeave ) ChspsDefinitionEngine;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

ChspsDefinitionEngine::~ChspsDefinitionEngine()

    {

    delete ihspsXMLHandler;

    }

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

// ChspsDefinitionEngine::CreateDOM

// Parse the given XML file, insert all nodes to DOM tree,

// assign all properties to the nodes

// (other items were commented in a header).

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

//

ChspsDefinitionEngineInterface::TError ChspsDefinitionEngine::CreateDOM(

    RFs& aFsSession,

    const TDesC& aXMLFileName,

    ChspsODT& ahspsOdt )

    {

    ChspsDomDocument& dom = ahspsOdt.DomDocument();

    ChspsDefinitionEngineInterface::TError errCode;

    errCode.iDefEngError = KErrNone;

    errCode.iSubComponentError = KErrNone;

    TRAPD( err,ihspsXMLHandler->ParseXmlDocL( aFsSession, aXMLFileName, dom ) );

    if ( err != KErrNone )

        {

        errCode.iDefEngError = KErrXmlParsing;

        errCode.iSubComponentError = err;

        return errCode;

        }

    TRAP( err, BuildRefNodesL( dom ) );

    if ( err != KErrNone )

        {

        errCode.iDefEngError = KErrRefBuilding;

        errCode.iSubComponentError = err;

        return errCode;

        }

    return errCode;

    }

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

// ChspsDefinitionEngine::ApplyLanguageL

// Parse the given XML file, insert all nodes to DOM tree,

// assign all properties to the nodes

// (other items were commented in a header).

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

//

void ChspsDefinitionEngine::ApplyLanguageL(

    RFs& aFsSession,

    const TDesC& aDTDFileName,

    ChspsODT& ahspsOdt )

    {

    ChspsLocaleParser* localeParser =  ChspsLocaleParser::NewL();

    CleanupStack::PushL( localeParser );

    localeParser->ApplyDtdToDomL( aFsSession, aDTDFileName, ahspsOdt.DomDocument() );

    CleanupStack::PopAndDestroy( localeParser );   

    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

//  End of File