/*

* Copyright (c) 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:  Data class to hold widget info

*

*/

// System includes

#include <utf.h>

// User includes

#include <aifwdefs.h>

#include "xnappuiadapter.h"

#include "xncomposer.h"

#include "xnodtparser.h"

#include "xnresource.h"

#include "xnodt.h"

#include "xnnode.h"

#include "xnplugindata.h"

#include "xnviewdata.h"

#include "xnpublisherdata.h"

#include "xnviewmanager.h"

#include "xnoomsyshandler.h"

#include "xnpanic.h"

#include "debug.h"

// Constants

_LIT8( KLockingStatusLocked, "locked" );

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

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

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

// CXnPluginData::NewL()

// Two-phased constructor.

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

//

CXnPluginData* CXnPluginData::NewL( CXnPluginData& aParent )    

    {

    CXnPluginData* self = CXnPluginData::NewLC( aParent );

    CleanupStack::Pop( self );

    return self;

    }

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

// CXnPluginData::NewLC()

// Two-phased constructor.

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

//

CXnPluginData* CXnPluginData::NewLC( CXnPluginData& aParent )    

    {

    CXnPluginData* self = new ( ELeave ) CXnPluginData( aParent );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CXnPluginData::CXnPluginData()

// C++ constructor

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

//

CXnPluginData::CXnPluginData( CXnPluginData& aParent )     

    : iParent( &aParent ), iManager( iParent->ViewManager() )       

    {

    // Plugin data is removable by default    

    iFlags.Set( EIsRemovable );

    }

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

// CXnPluginData::CXnPluginData()

// C++ constructor

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

//

CXnPluginData::CXnPluginData( CXnViewManager& aManager )     

    : iParent( NULL ), iManager( aManager )

    {

    // This constructor overload is used by CXnRootData

    }

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

// CXnPluginData::~CXnPluginData()

// C++ default destructor.

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

//

CXnPluginData::~CXnPluginData()

    {

    Flush();

    }

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

// CXnPluginData::ConstructL()

// 2nd phase constructor

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

//

void CXnPluginData::ConstructL()

    {    

    }

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

// CXnPluginData::Load()

//

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

//

TInt CXnPluginData::Load()

    {        

    if ( Occupied() )

        {

        return KErrInUse;

        }

    if ( !CXnOomSysHandler::HeapAvailable( WIDGET_MIN_MEM ) )

        {                

        return KErrNoMemory;

        }

    iFlags.Clear( EIsEmpty );

    TInt err( KErrNone );

    TRAP( err, err = iManager.Composer().ComposeWidgetL( *this ) );

    if ( err == KErrNone )

        {

        TRAP( err, iManager.Parser().LoadWidgetL( *this ) );       

        }

    if ( err == KErrNone )

        {                     

        // Succesfully composed, try schedule publishers' loading

        LoadPublishers( EAiFwPluginStartup );                  

        }    

    else if ( err == KXnErrWidgetPluginFailure )

        {

        // Widget's configuration is broken, remove it

        TRAP_IGNORE( iManager.UnloadWidgetFromPluginL( *this, ETrue ) );                        

        }      

    return err;

    }

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

// CXnPluginData::Destroy()

//

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

//

void CXnPluginData::Destroy()

    {       

    if ( Occupied() )

        {

        DestroyPublishers( EAiFwPluginShutdown );

        TRAP_IGNORE( iManager.Parser().DestroyWidgetL( *this ) );                                       

        }

    Flush();

    }

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

// CXnPluginData::LoadPublishers()

// 

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

//

void CXnPluginData::LoadPublishers( TInt aReason )

    {           

    __PRINTS( "*** CXnPluginData::LoadPublishers" );

    if ( !Active() || !Occupied() )

        {

        __PRINTS( "*** CXnPluginData::LoadPublishers - done, !Active() || !Occupied()" );

        return;

        }

    TInt count( iPublishers.Count() );

    if ( count == 0 )

        {

        TRAP_IGNORE( NotifyPublisherReadyL() );

        }

    else

        {

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

            {

            iPublishers[i]->Load( aReason );        

            }    

        }

    __PRINTS( "*** CXnPluginData::LoadPublishers - done" );

    }

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

// CXnPluginData::NotifyPublisherReadyL()

//

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

//

void CXnPluginData::NotifyPublisherReadyL()          

    {       

    if ( iParent )

        {

        // Forward to parent

        iParent->NotifyPublisherReadyL();

        }

    }

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

// CXnPluginData::DestroyPublishers

// 

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

//

void CXnPluginData::DestroyPublishers( TInt aReason )

    {    

    __PRINTS( "*** CXnPluginData::DestroyPublishers" );

    if ( !Occupied() )

        {

        __PRINTS( "*** CXnPluginData::DestroyPublishers - done, !Occupied()" );

        return;

        }    

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

        {

        iPublishers[i]->Destroy( aReason );        

        }

    __PRINTS( "*** CXnPluginData::DestroyPublishers - done" );

    }

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

// CXnPluginData::SetConfigurationIdL()

//

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

//

void CXnPluginData::SetConfigurationIdL( const TDesC8& aConfigurationId )

    {

    delete iConfigurationId;

    iConfigurationId = NULL;

    iConfigurationId = aConfigurationId.AllocL();

    }

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

// CXnPluginData::SetPluginIdL()

//

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

//

void CXnPluginData::SetPluginIdL( const TDesC8& aPluginId )

    {

    delete iPluginId;

    iPluginId = NULL;

    iPluginId = aPluginId.AllocL();

    }

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

// CXnPluginData::SetPluginUidL()

//

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

//

void CXnPluginData::SetPluginUidL( const TDesC8& aPluginUid )

    {

    delete iPluginUid;

    iPluginUid = NULL;

    iPluginUid = aPluginUid.AllocL();

    }

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

// CXnPluginData::SetPluginNameL()

//

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

//

void CXnPluginData::SetPluginNameL( const TDesC8& aPluginName )

    {

    delete iPluginName;

    iPluginName = NULL;

    iPluginName = aPluginName.AllocL();

    }

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

// CXnPluginData::SetPublisherName ()

// Set the publisher name

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

//

void CXnPluginData::SetPublisherNameL( const TDesC8& aPublisherName )

    {

    delete iPublisherName;

    iPublisherName = NULL;

    iPublisherName = 

        CnvUtfConverter::ConvertToUnicodeFromUtf8L( aPublisherName );

    }

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

// CXnPluginData::SetPublisherName()

// Set the publisher name

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

//

void CXnPluginData::SetPublisherNameL( const TDesC& aPublisherName )

    {

    delete iPublisherName;

    iPublisherName = NULL;

    iPublisherName = aPublisherName.AllocL();

    }

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

// CXnPluginData::SetPluginTypeL()

//

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

//

void CXnPluginData::SetPluginTypeL( const TDesC8& aPluginType )

    {

    delete iPluginType;

    iPluginType = NULL;

    iPluginType = aPluginType.AllocL();

    }

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

// CXnPluginData::SetResources()

//

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

//

void CXnPluginData::SetResources( CArrayPtrSeg< CXnResource >* aResources )

    {    

    if ( iResources )

        {

        iResources->ResetAndDestroy();

        delete iResources;

        iResources = NULL;

        }

    iResources = aResources;    

    }

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

// CXnPluginData::ResourcesL()

//

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

//

void CXnPluginData::ResourcesL( CArrayPtrSeg< CXnResource >& aList ) const

    {    

    for ( TInt i = 0; iResources && i < iResources->Count(); i++ )

        {

        aList.AppendL( iResources->At(i) );

        }

    }

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

// CXnPluginData::SetControlL()

//

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

//

void CXnPluginData::SetControlL( CXnNode* aNode )

    {

    CXnControlAdapter* control( aNode->Control() );

    if ( control )

        {

        User::LeaveIfError( iControls.InsertInAddressOrder( control ) );

        }

    }

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

// CXnPluginData::ControlsL()

//

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

//

void CXnPluginData::ControlsL( RPointerArray< CXnControlAdapter >& aList ) const

    {

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

        {

        aList.AppendL( iControls[i] );

        }

    }

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

// CXnPluginData::SetContentSourceNodeL()

//

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

//

void CXnPluginData::SetContentSourceNodeL( CXnNode* aNode )

    {        

    if ( !aNode )

        {

        return;

        }

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

        {        

        if ( *iPublishers[i] == *aNode )

            {

            // Duplicate entries not allowed

            return;

            }

        }

    CXnPublisherData* publisher = 

        CXnPublisherData::NewLC( *this, *aNode );       

    iPublishers.AppendL( publisher );    

    CleanupStack::Pop( publisher );   

    }

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

// CXnPluginData::ContentSourceNodesL()

//

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

//

void CXnPluginData::ContentSourceNodesL( RPointerArray< CXnNode >& aList ) const

    {

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

        {

        aList.AppendL( iPublishers[i]->ContentSource() );

        }

    }

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

// CXnPluginData::Publishers()

//

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

//

void CXnPluginData::PublishersL( RPointerArray< CXnPublisherData >& aList ) const

    {

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

        {

        aList.AppendL( iPublishers[i] );

        }

    }

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

// CXnPluginData::SetAppearanceNodeL()

//

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

//

void CXnPluginData::SetAppearanceNodeL( CXnNode* aNode )

    {

    User::LeaveIfError( iAppearanceNodes.InsertInAddressOrder( aNode ) );

    }

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

// CXnPluginData::AppearanceNodesL()

//

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

//

void CXnPluginData::AppearanceNodesL( RPointerArray< CXnNode >& aList ) const

    {

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

        {

        aList.AppendL( iAppearanceNodes[i] );

        }

    }

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

// CXnPluginData::SetInitialFocusNodeL()

//

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

//

void CXnPluginData::SetInitialFocusNodeL( CXnNode* aNode )

    {

    User::LeaveIfError( iInitialFocusNodes.InsertInAddressOrder( aNode ) );

    }

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

// CXnPluginData::InitialFocusNodesL()

//

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

//

void CXnPluginData::InitialFocusNodesL( RPointerArray< CXnNode >& aList ) const

    {

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

        {

        aList.AppendL( iInitialFocusNodes[i] );

        }

    }

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

// CXnPluginData::Flush()

// Flushes this plugins data

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

//

void CXnPluginData::Flush()

    {

    // Don't touch to iOwner, because this plugin might be reused later

    iFlags.ClearAll();

    // This is default

    iFlags.Set( EIsRemovable );    

    iNode = NULL;

    delete iConfigurationId;

    iConfigurationId = NULL;

    delete iPluginId;

    iPluginId = NULL;

    delete iPluginUid;

    iPluginUid = NULL;

    delete iPluginName;

    iPluginName = NULL;

    delete iPluginType;

    iPluginType = NULL;

    delete iPublisherName;

    iPublisherName = NULL;

    if ( iResources )

        {

        iResources->ResetAndDestroy();