/*

* 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>

// 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"

// Constants

_LIT8( KStateWaitConfirmation, "WaitForConfirmation" );

_LIT8( KStateError, "Error" );

_LIT8( KXmluiml, "xmluiml" );

_LIT8( KApp, "application" );

_LIT8( KViews, "views" );

_LIT8( KWidget, "widget" );

_LIT8( KUseEmptyWidget, "use_empty_widget" );

_LIT8( KRemovable, "removable" );

_LIT8( KEmptyWidgetUid, "0x2001F47F" );

_LIT( KCDrive, "C:" );

_LIT8( KTagXuikon, "xuikon" );

using namespace hspswrapper;

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

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

// Finds recursively node by name

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

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

//

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;

    }

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

// FindNodeById

// Finds recursively node by id

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

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

//

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;

        }

    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;

    }

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

// Removable

// Determines whether this plugin is removable

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

//

static TBool Removable( CXnDomNode& aPlugin )

    {    

    CXnDomAttribute* attribute(

        static_cast< CXnDomAttribute* >( 

                aPlugin.AttributeList().FindByName( KRemovable ) ) );

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

        {

        return EFalse;

        }

    return ETrue;

    }

// ======== 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;        

        }

    CPluginInfo& info( configuration->PluginInfo() );

    aRootData.SetOwner( root );

    aRootData.SetNode( views );

    aRootData.SetPluginNameL( info.Name() );

    aRootData.SetPluginUidL( info.Uid() );

    aRootData.SetPluginTypeL( KApp );

    aRootData.SetMaxPages( info.MaxChild() );

    // Get plugins (= views) in this application configuration

    RPointerArray< CPluginMap >& plugins( configuration->PluginMaps() );

    if ( ( plugins.Count() == 0 ) || ( aRootData.MaxPages() <= 0 ) )

        {

        CleanupStack::PopAndDestroy( 2, configuration );

        return NULL;

        }

    RPointerArray< CXnPluginData >& array( aRootData.PluginData() );

    TInt index( 0 );

    for ( TInt i = 0; ( i < plugins.Count() ) && ( i < aRootData.MaxPages() );

        i++ )

        {

        CPluginMap* plugin( plugins[i] );

        CXnViewData* view = CXnViewData::NewLC( aRootData );

        // Give view data ownership to CXnRootData

        array.AppendL( view );                                 

        CleanupStack::Pop( view );

        view->SetOwner( views );  

        view->SetPluginIdL( plugin->PluginId() );

        if ( plugin->ActivationState() )

            {            

            index = i;            

            }

        view->SetLockingStatus( plugin->LockingStatus() );

        }