/*

* Copyright (c) 2008-2008 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:  Application configuration composer

*

*/

// System includes

#include <s32file.h>

#include <utf.h>

// User includes

#include "xncomposer.h"

#include "xnplugindata.h"

#include "xnrootdata.h"

#include "xnviewdata.h"

#include "xnodt.h"

#include "xnproperty.h"

#include "xnresource.h"

#include "xndomdocument.h"

#include "xndomnode.h"

#include "xndomlist.h"

#include "xndomattribute.h"

#include "xnpanic.h"

#include "xnplugindefs.h"

#include "xnviewmanager.h"

#include "xnappuiadapter.h"

#include "xnviewadapter.h"

#include "xnbackgroundmanager.h"

// Constants

_LIT8( KStateError, "Error" );

_LIT8( KXmluiml, "xmluiml" );

_LIT8( KApp, "application" );

_LIT8( KViews, "views" );

_LIT8( KWidget, "widget" );

_LIT8( KUseEmptyWidget, "use_empty_widget" );

_LIT8( KEmptyWidgetUid, "0x2001F47F" );

_LIT( KCDrive, "C:" );

_LIT8( KTagXuikon, "xuikon" );

using namespace hspswrapper;

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

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

// ItemValueL

// Get property value from configuration.

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

//

static HBufC* ItemValueL( CHspsConfiguration& aConfiguration, 

    const TDesC8& aItemId,

    const TDesC8& aName,

    const TBool aUseUtfConversion = EFalse )

    {

    HBufC* ret = NULL;

    RPointerArray<CItemMap>& settingsList = aConfiguration.Settings();    

    for( TInt i = 0; i < settingsList.Count(); i++ )

        {

        CItemMap* setting = settingsList[i];

        if( !setting )

            {

            continue;

            }

        if( setting->ItemId() == aItemId )

            {

            RPointerArray<CPropertyMap>& properties = setting->Properties();

            for( TInt j = 0; j < properties.Count(); j++ )

                {

                CPropertyMap* property = properties[j];

                if( !property )

                    {

                    continue;

                    }

                if( property->Name() == aName )

                    {

                    if( aUseUtfConversion )

                        {

                        ret = CnvUtfConverter::ConvertToUnicodeFromUtf8L( property->Value() );

                        }

                    else

                        {

                        ret = HBufC::NewL( property->Value().Length() );

                        ret->Des().Copy( property->Value() );

                        }

                    break;

                    }

                }            

            break;

            }    

        }        

    return ret;

    }

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

// Finds recursively node by name

// @return    returns pointer to desired node, NULL if nothing found 

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

//

static CXnDomNode* FindNodeByName( CXnDomNode* aNode, const TDesC8& aName )

    {

    if ( !aNode )

        {        

        return NULL;

        }

    if ( aNode->Name() == aName )

        {

        return aNode;

        }

    CXnDomList& list( aNode->ChildNodes() );

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

        {

        CXnDomNode* retval( FindNodeByName(

                static_cast< CXnDomNode* >( list.Item( i ) ), aName ) );

        if ( retval )

            {

            return retval;

            }

        }

    return NULL;

    }

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

// Finds template publisher name

//  

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

//

static const TDesC8& FindTemplatePublisherName( CXnDomNode* aNode )

    {

    if ( !aNode )

        {        

        return KNullDesC8();

        }

    CXnDomList& list( aNode->ChildNodes() );

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

        {

        CXnDomNode* node = static_cast< CXnDomNode* >( list.Item( i ) );

        // Find <configuration> element

        if ( node->Name() == KConfigurationModel )

            {

            CXnDomList& attributes( node->AttributeList() );

            CXnDomAttribute* name(

                static_cast< CXnDomAttribute* >(

                    attributes.FindByName( XnPropertyNames::action::KName ) ) );

            // Find attribute name="publisher" 

            if ( name && name->Value() == KPublisher )

                {

                CXnDomAttribute* value(

                    static_cast< CXnDomAttribute* >(

                        attributes.FindByName( XnPropertyNames::action::KValue ) ) );

                if ( value )

                    {                    

                    return value->Value();

                    }

                }            

            }

        }

    return KNullDesC8();

    }

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

// FindNodeById

// Finds recursively node by id

// @return    returns pointer to desired node, NULL if nothing found 

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

//

static CXnDomNode* FindNodeById( CXnDomNode* aNode, const TDesC8& aId )

    {

    if ( !aNode )

        {        

        return NULL;

        }

    CXnDomList& attributes( aNode->AttributeList() );

    CXnDomAttribute* id(

        static_cast< CXnDomAttribute* >(

                attributes.FindByName( XnPropertyNames::common::KId ) ) );

    if ( id && id->Value() == aId )

        {

        return aNode;

        }

    CXnDomList& list( aNode->ChildNodes() );

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

        {

        CXnDomNode* retval( FindNodeById(

                static_cast< CXnDomNode* >( list.Item( i ) ), aId ) );

        if ( retval )

            {

            return retval;

            }

        }

    return NULL;

    }

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

// UpdateResourcesPathL

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

//

static void UpdateResourcesPathL( CArrayPtrSeg< CXnResource >& aList, 

    TPtrC aNewPath )

    {

    TFileName newFilename;

    for ( TInt i = 0; i < aList.Count(); i++ )

        {

        CXnResource& res( *aList[i] );

        const TDesC& filename( res.FileName() );

        TParsePtrC fileParser( filename );

        TPtrC nameAndExt( fileParser.NameAndExt() );

        newFilename = aNewPath;

        newFilename.Append( nameAndExt );

        res.SetFileNameL( newFilename );

        }

    }

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

// UpdateSettingsL

// 

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

//

static void UpdateSettingsL( const TDesC8& aElementId,

    RPointerArray< CPropertyMap >& aProperties, CXnDomNode& aRootNode )

    {    

    CXnDomNode* node( FindNodeById( &aRootNode, aElementId ) );

    if( !node )

        {

        return;

        }

    CXnDomStringPool* sp( node->StringPool() );

    for ( TInt i = 0; i < aProperties.Count(); i++ )

        {

        CPropertyMap* property( aProperties[i] );

        const TDesC8& name( property->Name() );

        const TDesC8& value( property->Value() );

        CXnDomList& attributes( node->AttributeList() );

        CXnDomAttribute* attribute(

            static_cast< CXnDomAttribute* >( attributes.FindByName( name ) ) );

        if ( attribute )

            {

            // Update current attribute

            attribute->SetValueL( value );

            }

        else

            {

            // Need to create new attribute

            attribute = CXnDomAttribute::NewL( name, sp );

            CleanupStack::PushL( attribute );

            attribute->SetValueL( value );

            node->AttributeList().AddItemL( attribute );

            CleanupStack::Pop( attribute );

            }

        }

    }

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

// UpdatePluginFromSettingsL()

// Updates plugin from settings

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

//

static void UpdatePluginFromSettingsL( CHspsConfiguration& aConfiguration,

    CXnDomNode& aRootNode )

    {

    RPointerArray< CItemMap >& settings( aConfiguration.Settings() );

    for ( TInt i = 0; i < settings.Count(); i++ )

        {

        CItemMap* setting( settings[i] );

        const TDesC8& itemId( setting->ItemId() );

        RPointerArray< CPropertyMap >& properties( setting->Properties() );

        UpdateSettingsL( itemId, properties, aRootNode );

        }

    }

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

// MergeLD()

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

//

static CXnDomNode* MergeLD( CXnDomNode* aRoot,  

    CXnPluginData& aPluginData, TBool aMergeView = EFalse )

    {

    CXnDomNode* parent( aPluginData.Owner() );

    CXnDomNode* childToFind( NULL );

    if ( aMergeView )

        {

        childToFind = FindNodeByName( aRoot, KView );

        }

    else

        {

        childToFind = FindNodeByName( aRoot, KWidget );

        }

    if( !childToFind || aRoot->Name() != KXmluiml )

        {

        delete aRoot;

        return NULL;

        }

    aPluginData.SetNode( childToFind );

    CXnDomList& list( aRoot->ChildNodes() );

    TInt index( list.ItemIndex( *childToFind ) );   

    CXnDomNode* node =

        static_cast< CXnDomNode* >( list.Item( index ) );

    list.RemoveItem( index );

    // sets namespace recursively

    node->SetOwnershipL( aPluginData.PluginId() );

    // Takes ownership

    parent->AddChildL( node );

    delete aRoot;

    aRoot = NULL;

    if ( aMergeView )

        {

        // Return the last view

        TInt index( parent->ChildNodes().Length() - 1 );

        return ( static_cast< CXnDomNode* >(

            parent->ChildNodes().Item( index ) ) );

        }

    else

        {

        // Return <widget>

        return node;

        }

    }

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

// UseEmptyWidget

// Determines whether to use empty widget in this view configuration

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

//

static TBool UseEmptyWidget( CXnDomNode& aView )

    {    

    CXnDomAttribute* attribute(

        static_cast< CXnDomAttribute* >( 

                aView.AttributeList().FindByName( KUseEmptyWidget ) ) );

    if ( attribute && attribute->Value() == XnPropertyNames::KTrue )

        {

        return ETrue;

        }

    return EFalse;

    }

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

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

// CXnComposer::NewL

// Two-phased constructor.

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

//

CXnComposer* CXnComposer::NewL( CHspsWrapper& aWrapper )

    {

    CXnComposer* self = new ( ELeave ) CXnComposer( aWrapper );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CXnComposer::~CXnComposer

// Destructor

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

//

CXnComposer::~CXnComposer()

    {

    iFs.Close();

    }

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

// CXnComposer::CXnComposer

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

// might leave.

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

//

CXnComposer::CXnComposer( CHspsWrapper& aWrapper )

    : iWrapper( aWrapper )

    {

    }

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

// CXnComposer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CXnComposer::ConstructL()

    {

    User::LeaveIfError( iFs.Connect() );

    }

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

// CXnComposer::ComposeRootL()

// Composes the application root configuration

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

//

CXnODT* CXnComposer::ComposeRootL( CXnRootData& aRootData )

    {

    // Not owned

    iODT = NULL;

    // Get application configuration

    CHspsConfiguration* configuration( iWrapper.GetAppConfigurationL() );

    CleanupStack::PushL( configuration );

    const TDesC8& state( configuration->PluginInfo().ConfigurationState() );

    aRootData.SetConfigurationIdL( configuration->ConfId() );

    if ( state.CompareF( KStateError ) == 0 || 

        configuration->Resources().Count() == 0 )

        {

        CleanupStack::PopAndDestroy( configuration );

        return NULL;       

        }

    // Get application configuration odt resource

    CXnODT* odt = CXnODT::NewL();

    CleanupStack::PushL( odt );

    // Save for later usage, not owned

    iODT = odt;

    // Find a resource which can be internalized

    const CObjectMap* resourceObject = FindObject( 

            configuration->Resources(), KTagXuikon() );

    if ( !resourceObject )

        {

        CleanupStack::PopAndDestroy( 2, configuration );

        return NULL;

        }

    CXnDomNode* root( GetOdtL( *resourceObject, aRootData ) );       

    if ( !root )

        {        

        CleanupStack::PopAndDestroy( 2, configuration );

        return NULL;

        }

    odt->DomDocument().SetRootNode( root );

    // "views" node is the owner node of view nodes

    CXnDomNode* views( FindNodeByName( root, KViews ) );

    if ( !views )

        {

        CleanupStack::PopAndDestroy( 2, configuration );

        return NULL;        

        }