/*

* Copyright (c) 2002-2004 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:  ODT parser

*

*/

#include <aisystemuids.hrh>

#include <xnextrenderingpluginadapter.h>

#include <ecom/ecom.h>

#include <ecom/implementationinformation.h>

#include "xnextrenderingpluginwrapper.h"

#include "xnodt.h"

#include "xndomdocument.h"

#include "xndomnode.h"

#include "xndomattribute.h"

#include "xndomlist.h"

#include "xnnode.h"

#include "xnecomhandler.h"

#include "xnuiengine.h"

#include "xntype.h"

#include "xncontroladapter.h"

#include "xnpopupcontroladapter.h"

#include "xnwidgetextensionadapter.h"

#include "xnscrollablecontroladapter.h"

#include "xnlistquerydialogadapter.h"

#include "xncomponent.h"

#include "xncomponentnodeimpl.h"

#include "xnviewnodeimpl.h"

#include "xnviewsnodeimpl.h"

#include "xnproperty.h"

#include "xncomponentfactory.h"

#include "xnarray.h"

#include "xnviewmanager.h"

#include "xnplugindata.h"

#include "xnrootdata.h"

#include "xnviewdata.h"

#include "xnodtparser.h"

_LIT8( KWidgetBgSkinId, "SKIN(268458534 9916)" );

// CONSTANTS

_LIT8( KXMLUIMLNodeName, "xmluiml" );

_LIT8( KViewsNodeName, "views" );

_LIT8( KViewNodeName, "view" );

_LIT8( KBoxNodeName, "box" );

_LIT8( KButtonNodeName, "button" );

_LIT8( KStylusPopupNodeName, "styluspopup" );

_LIT8( KImageNodeName, "image" );

_LIT8( KTooltipNodeName, "tooltip" );

_LIT8( KMenuBarNodeName, "menubar" );

_LIT8( KMenuNodeName, "menu" );

_LIT8( KMenuItemNodeName, "menuitem" );

_LIT8( KDynMenuItemNodeName, "dynmenuitem" );

_LIT8( KWidgetMenuItemNodeName, "widgetmenuitem" );

_LIT8( KActionsNodeName, "actions" );

_LIT8( KActionNodeName, "action" );

_LIT8( KTriggerNodeName, "trigger" );

_LIT8( KEventNodeName, "event" );

_LIT8( KTextNodeName, "text" );

_LIT8( KMarqueeNodeName, "marquee" );

_LIT8( KObjectNodeName, "object" );

_LIT8( KTracksterNodeName, "trackster" );

_LIT8( KPropertyNodeName, "property" );

_LIT8( KConfigurationNodeName, "configuration" );

_LIT8( KNewstickerNodeName, "newsticker" );

_LIT8( KAttributeNodeName, "attribute" );

_LIT8( KItemNodeName, "item" );

_LIT8( KDescNodeName, "desc" );

_LIT8( KTextZoomNodeName, "textzoom" );

_LIT8( KVolumeControlNodeName, "volumecontrol" );

_LIT8( KPluginNodeName, "plugin" );

_LIT8( KWidgetNodeName, "widget" );

_LIT8( KSliderNodeName, "slider" );

_LIT8( KClockNodeName, "clock" );

_LIT8( KSoftkeyNodeName,"softkey" );

_LIT8( KConditionalTrigger,"conditional" );

_LIT8( KCondtionalOn, "true" );

_LIT8( KListQueryDialogNodeName, "listquerydialog" );

_LIT8( KSettingsConfigurationNodeName, "settingsconfiguration" );

_LIT8( KContentSourceNodeName, "contentsource" );

_LIT8( KMenuExtensionNodeName, "menuextension" );

_LIT8( KWidgetExtensionNodeName, "widgetextension" );

_LIT8( KTextEditorNodeName, "texteditor" );

_LIT8( KActionsHandlerNodeName, "actionshandler" );

_LIT8( KScrollableBoxNodeName, "scrollablebox" );

_LIT8( KPopUpNodeName, "popup" );

// LOCAL FUNCTION PROTOTYPES

#ifdef _XN3_DEBUG_

#include <flogger.h>

#include <utf.h>

static void PrintDomL( CXnDomDocument* aDomDocument );

#endif

static CXnNode* BuildRootNodeL( CXnUiEngine& aEngine );         

static CXnNode* FindAncestorWhoActAsParent( CXnDomNode& aSource );

static TBool CreateTriggerInLayoutNodeTree( CXnDomNode& aSource );

static void CopyPropertiesFromDomNodeToNodeL(

    CXnNode& aTarget,

    CXnDomNode& aSource,

    CXnDomStringPool& aStringPool );

static CXnNode* ConstructNodeFromPluginL(

    CXnEcomHandler& aEcomHandler,

    CXnDomNode& aSource );

static CXnNode* ConstructKnownBuiltinNodeL( CXnDomNode& aSource );

static CXnNode* ConstructGeneralNodeL( CXnDomNode& aSource );

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

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

// CleanupResetAndDestroy()

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

//

template<class T>

static void CleanupResetAndDestroy( TAny* aObj )

    {

    if( aObj )

        {

        static_cast<T*>( aObj )->ResetAndDestroy();

        }

    }  

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

// CleanupResetAndDestroyPushL

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

//

template<class T>

static void CleanupResetAndDestroyPushL(T& aArray)

    {

    CleanupStack::PushL( TCleanupItem( &CleanupResetAndDestroy<T>, &aArray ) );

    }  

#ifdef _XN3_DEBUG_

_LIT( KLogFolder," xnlayoutengine" );

_LIT( KLogDom, "dom.log" );

#define _LOGT( aDescription ) RFileLogger::Write( \

    KLogFolder, KLogDom, EFileLoggingModeOverwrite, aDescription );

#define _LOGTFRM1( a, b ) RFileLogger::WriteFormat( \

    KLogFolder, KLogDom, EFileLoggingModeOverwrite, ( a ), ( b ) )

#define _LOGTFRM2( a, b, c ) RFileLogger::WriteFormat( \

    KLogFolder, KLogDom, EFileLoggingModeOverwrite, ( a ), ( b ), ( c ) );

#define _LOGTFRM3( a, b, c, d ) RFileLogger::WriteFormat( \

    KLogFolder, KLogDom, EFileLoggingModeOverwrite, ( a ), ( b ), ( c ), ( d ) );

static const TInt GetNodeDepth( CXnDomNode *aNode )

    {

    TInt depth = 0;

    CXnDomNode* node( aNode );

    while ( node )

        {

        node = node->Parent();

        if ( node )

            {

            depth++;

            }

        }

    return depth;

    }

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

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

//

static HBufC8* GetFixedTextLC(

    const TDesC8& aText,

    const TInt aDepth,

    const TDesC8& aDelim )

    {

    HBufC8 *buf = HBufC8::NewL( aDepth * aDelim.Length() + aText.Length() + 1 );

    TInt i = 0;

    for ( ; i < aDepth; i++ )

        {

        buf->Des().Append( aDelim );

        }

    buf->Des().Append( aText );

    return buf;

    }

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

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

//

static void PrintDomL( CXnDomDocument* aDomDocument )

    {

__UHEAP_MARK;

    TInt attrCount( 0 );

    TInt propCount( 0 );

    CXnDomDepthIterator* iter = 

            CXnDomDepthIterator::NewL( *aDomDocument->RootNode() );

    CleanupStack::PushL( iter );

    _LIT8( KDelim, "\t" );

    CXnDomNode* nodeParent( NULL );

    CXnDomNode* node = iter->First();

    while ( node )

        {

        const TInt depth = GetNodeDepth( node );

        HBufC8 *nameBuf = GetFixedTextLC( node->Name(), depth, KDelim );

        CleanupStack::PushL( nameBuf );

        const TDesC8& name = nameBuf->Des();

        HBufC8 *nsBuf = GetFixedTextLC( node->Namespace(), depth, KDelim );

        CleanupStack::PushL( nsBuf );

        const TDesC8& ns = nsBuf->Des();

        _LOGTFRM2( _L8( "%S -------------------------- %S\n" ), &name, &ns );

        CXnDomList& attrList = node->AttributeList();

        TInt length( attrList.Length() );

        attrCount += length;

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

            {

            CXnDomAttribute* attr = static_cast< CXnDomAttribute* >(

                attrList.Item( i ) );

            HBufC8 *attrBuf = GetFixedTextLC( attr->Name(), depth,  KDelim );

            CleanupStack::PushL( attrBuf );

            const TDesC8& attrName = attrBuf->Des();

            const TDesC8& attrValue = attr->Value();

            _LOGTFRM2( _L8( "%S=%S\n" ), &attrName, &attrValue );

            CleanupStack::PopAndDestroy( attrBuf );

            }

        if ( node->Parent() )

            {

            nodeParent = node;

            }

        node = iter->NextL();

        CleanupStack::PopAndDestroy( nsBuf );

        CleanupStack::PopAndDestroy( nameBuf );

        }

    CleanupStack::PopAndDestroy( iter );

    _LOGTFRM1( _L8( "****DOM Size: %d ****\n" ), aDomDocument->Size() );

    _LOGTFRM1( _L8( "****DOM Node Count: %d ****\n" ), aDomDocument->DomNodeCount() );

    _LOGTFRM1( _L8( "****DOM Attribute Count: %d ****\n" ), attrCount );

__UHEAP_MARKEND;

    }

#endif

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

// BuildRootNodeL()

// Builds root node

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

//

static CXnNode* BuildRootNodeL( CXnUiEngine& aEngine )           

    {

    CXnType* type = CXnType::NewL( KXMLUIMLNodeName );

    CleanupStack::PushL( type );

    CXnNodeImpl* impl = CXnNodeImpl::NewL( type ); 

    CleanupStack::Pop( type );

    CleanupStack::PushL( impl );

    CXnNode* node = CXnNode::NewL();

    node->SetRootNodeImpl( impl );

    CleanupStack::Pop( impl );

    node->SetUiEngine( aEngine );

    return node;

    }

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

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

//

CXnNode* FindAncestorWhoActAsParent( CXnDomNode& aSource )

    {

    CXnNode* ret( NULL );

    CXnDomNode* parent = aSource.Parent();

    while ( !ret && parent )

        {

        ret = parent->LayoutNode();

        parent = parent->Parent();

        }

    return ret;

    }

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

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

//

TBool CreateTriggerInLayoutNodeTree( CXnDomNode& aSource )

    {

    TBool ret( EFalse );

    CXnDomAttribute* attribute = static_cast< CXnDomAttribute* >(

        aSource.AttributeList().FindByName( KConditionalTrigger ) );

    if ( attribute && attribute->Value() == KCondtionalOn )

        {

        ret = ETrue;

        }

    return ret;

    }

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

// CopyDomPropertiesFromDomNodeToNodeL

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

//

static void CopyDomPropertiesFromDomNodeToNodeL(

    CXnNode& aTarget,

    CXnDomNode& aSource )

    {

    CXnDomList& propertyList = aSource.PropertyList();

    for ( TInt count = propertyList.Length() - 1; count >= 0; --count )

        {

        CXnDomProperty* domProperty = static_cast< CXnDomProperty* >(

            propertyList.Item( count ) );

        CXnProperty* property = CXnProperty::NewSharedL( domProperty );

        CleanupStack::PushL( property );

        aTarget.InitializePropertyL( property );

        CleanupStack::Pop( property );

        }

    }

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

// CopyDomAtributesFromDomNodeToNodeL

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

//

static void CopyDomAttributesFromDomNodeToNodeL(

    CXnNode& aTarget,

    CXnDomNode& aSource,

    CXnDomStringPool& aStringPool )

    {

    CXnDomList& attributeList = aSource.AttributeList();

    for ( TInt count = attributeList.Length() - 1; count >= 0; --count )

        {

        CXnDomAttribute* attribute = static_cast< CXnDomAttribute* >(

            attributeList.Item( count ) );

#ifdef _DEBUG

        const TDesC8& name = attribute->Name();

        const TDesC8& attrValue = attribute->Value();

#endif

        if ( attribute->ValueStringPoolIndex() == KErrNotFound )

            {

            continue;

            }

        if ( attribute->NameStringPoolIndex() == KErrNotFound )

            {

            continue;

            }

         CXnDomProperty* clone =

            CXnDomProperty::NewL( attribute->NameStringPoolIndex(), &aStringPool );

        CleanupStack::PushL( clone );

        CXnDomPropertyValue* propertyValue =

            CXnDomPropertyValue::NewL( &aStringPool );

        CleanupStack::PushL( propertyValue );

        propertyValue->SetStringPoolIndexL(

            CXnDomPropertyValue::EString, attribute->ValueStringPoolIndex() );

        CXnDomList& propertyList = clone->PropertyValueList();

        propertyList.AddItemL( propertyValue );

        CleanupStack::Pop( propertyValue );

        CXnProperty* property = CXnProperty::NewL( clone );

        CleanupStack::Pop( clone );

        CleanupStack::PushL( property );

        aTarget.InitializePropertyL( property );

        CleanupStack::Pop( property );

        }

    //aSource.DeleteAttributeList();

    // delete attributes from dom node tree

    if ( aSource.Name() != KTriggerNodeName )

        {

        CXnDomList& attrList = aSource.AttributeList();

        while ( attrList.Length() )

            {

            attrList.DeleteItem( attrList.Length() - 1 );

            }

        }

    }

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

// CopyPropertiesFromDomNodeToNodeL

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

//

static void CopyPropertiesFromDomNodeToNodeL(

    CXnNode& aTarget,

    CXnDomNode& aSource,

    CXnDomStringPool& aStringPool )

    {

    CopyDomPropertiesFromDomNodeToNodeL( aTarget, aSource );

    CopyDomAttributesFromDomNodeToNodeL( aTarget, aSource, aStringPool );

    }

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

// ConstructNodeFromPluginL

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

//

static CXnNode* ConstructNodeFromPluginL(

    CXnEcomHandler& aEcomHandler,

    CXnDomNode& aSource )

    {

    CXnNode* returnValue = NULL;

    const TDesC8& name = aSource.Name();

    CXnArray* componentFactories = CXnArray::NewL();

    CleanupStack::PushL( componentFactories );

    TUid interfaceUid = { AI3_RENDERING_PLUGIN_ECOM_FACTORY_UID };

    aEcomHandler.PluginsL( interfaceUid, name, *componentFactories );

    TInt count = componentFactories->Container().Count();

    TBool componentNodeImplNeeded = ETrue;

    // invoke factory chain

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

        {

        MXnComponentFactory* factory = static_cast< MXnComponentFactory* >(

            componentFactories->Container()[i] );

        componentNodeImplNeeded = factory->DoesNodeNeedComponentImplL( name );

        }

    CleanupStack::PopAndDestroy( componentFactories );

    if ( componentNodeImplNeeded )

        {

        CXnType* type = CXnType::NewL( name );

        CleanupStack::PushL( type );

        CXnComponentNodeImpl* impl = CXnComponentNodeImpl::NewL( type );

        CleanupStack::Pop( type );

        CleanupStack::PushL( impl );

        returnValue = CXnNode::NewL();

        returnValue->SetComponentNodeImpl( impl );

        CleanupStack::Pop( impl );

        }

    else

        {

        if ( name == KActionsNodeName ||

             name == KActionNodeName ||

             name == KEventNodeName ||

             name == KTriggerNodeName ||

             name == KMenuNodeName ||

             name == KMenuItemNodeName ||

             name == KPropertyNodeName ||

             name == KSoftkeyNodeName )

            {

            return ConstructGeneralNodeL( aSource );

            }

        }

    return returnValue;

    }

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

// ConstructKnownBuiltinNodeL

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

//

static CXnNode* ConstructKnownBuiltinNodeL( CXnDomNode& aSource )

    {

    CXnNode* returnValue = NULL;

    const TDesC8& name = aSource.Name();

    if ( name == KMenuNodeName ||

         name == KMenuItemNodeName ||

         name == KPropertyNodeName ||

         name == KSoftkeyNodeName ||

         name == KTriggerNodeName )

        {

        return ConstructGeneralNodeL( aSource );

        }

    CXnType* type = CXnType::NewL( name );

    CleanupStack::PushL( type );

    if ( name == KViewsNodeName )

        {

        CXnViewsNodeImpl* impl = CXnViewsNodeImpl::NewL( type );

        CleanupStack::Pop( type );

        CleanupStack::PushL( impl );

        returnValue = CXnNode::NewL();

        returnValue->SetViewsNodeImpl( impl );

        CleanupStack::Pop( impl );

        }

    else if ( name == KViewNodeName )

        {

        CXnViewNodeImpl* impl = CXnViewNodeImpl::NewL( type );

        CleanupStack::Pop( type );

        CleanupStack::PushL( impl );

        returnValue = CXnNode::NewL();

        returnValue->SetViewNodeImpl( impl );

        CleanupStack::Pop( impl );

        }

              name == KButtonNodeName ||

              name == KImageNodeName ||

              name == KMenuBarNodeName ||

              name == KTooltipNodeName ||

              name == KMarqueeNodeName ||

              name == KTextNodeName ||

              name == KObjectNodeName ||

              name == KTracksterNodeName ||

              name == KNewstickerNodeName ||

              name == KSliderNodeName ||

              name == KClockNodeName ||

              name == KStylusPopupNodeName ||

              name == KPopUpNodeName ||

              name == KWidgetExtensionNodeName ||

              name == KTextEditorNodeName )

        {

        CXnComponentNodeImpl* impl = CXnComponentNodeImpl::NewL( type );

        CleanupStack::Pop( type ) ;

        CleanupStack::PushL( impl );

        returnValue = CXnNode::NewL();

        returnValue->SetComponentNodeImpl( impl );

        CleanupStack::Pop( impl );

        }

    else

        {

        CleanupStack::PopAndDestroy( type );