/*

* 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:  View Manager

*

*/

// System includes

#include <AknUtils.h>

#include <AknsWallpaperUtils.h>

#include <AknSkinsInternalCRKeys.h>

#include <StringLoader.h>

#include <xnuiengine.rsg>

#include <aknnotewrappers.h>

#if 0 // MSK icon change

#include <AknsConstants.h>

#include <avkon.mbg>

#endif // MSK icon change

// User includes

#include "xnapplication.h"

#include "xnuiengine.h"

#include "xnproperty.h"

#include "xndomnode.h"

#include "xndomlist.h"

#include "xnnode.h"

#include "xncomposer.h"

#include "xneditor.h"

#include "xnrootdata.h"

#include "xnviewdata.h"

#include "xnappuiadapter.h"

#include "xncontroladapter.h"

#include "xnviewnodeimpl.h"

#include "xnviewadapter.h"

#include "xnodt.h"

#include "xndomdocument.h"

#include "xntype.h"

#include "xntext.h"

#include "xnpanic.h"

#include "xnmenu.h"

#include "xnmenuadapter.h"

#include "xncomponentnodeimpl.h"

#include "xnnodepluginif.h"

#include "xnoomsyshandler.h"

// Constants

_LIT8( KEmptyWidgetUid, "0x2001f47f" );

_LIT8( KViewSwitcherText, "switcher_text" );

_LIT8( KStateError, "Error" );

_LIT8( KMax, "max" );

_LIT8( KTemplateViewUID, "0x20026f50" );

enum

    {

    EFirstPassDrawComplete,

    EDataPluginsComplete,

    EViewIsValid,       

    };

const TInt KMinPages = 1;

#if 0 // MSK icon change

const TInt KIconIds[] = {

        EMbmAvkonQgnQgn_home_page_11,

        EMbmAvkonQgnQgn_home_page_21,

        EMbmAvkonQgnQgn_home_page_22,

        EMbmAvkonQgnQgn_home_page_31,

        EMbmAvkonQgnQgn_home_page_32,

        EMbmAvkonQgnQgn_home_page_33,

        EMbmAvkonQgnQgn_home_page_41,

        EMbmAvkonQgnQgn_home_page_42,

        EMbmAvkonQgnQgn_home_page_43,

        EMbmAvkonQgnQgn_home_page_44,

        EMbmAvkonQgnQgn_home_page_51,

        EMbmAvkonQgnQgn_home_page_52,

        EMbmAvkonQgnQgn_home_page_53,

        EMbmAvkonQgnQgn_home_page_54,

        EMbmAvkonQgnQgn_home_page_55,

        EMbmAvkonQgnQgn_home_page_61,

        EMbmAvkonQgnQgn_home_page_62,

        EMbmAvkonQgnQgn_home_page_63,

        EMbmAvkonQgnQgn_home_page_64,

        EMbmAvkonQgnQgn_home_page_65,

        EMbmAvkonQgnQgn_home_page_66

        };

const TInt KMaskIds[] = {

        EMbmAvkonQgnQgn_home_page_11_mask,

        EMbmAvkonQgnQgn_home_page_21_mask,

        EMbmAvkonQgnQgn_home_page_22_mask,

        EMbmAvkonQgnQgn_home_page_31_mask,

        EMbmAvkonQgnQgn_home_page_32_mask,

        EMbmAvkonQgnQgn_home_page_33_mask,

        EMbmAvkonQgnQgn_home_page_41_mask,

        EMbmAvkonQgnQgn_home_page_42_mask,

        EMbmAvkonQgnQgn_home_page_43_mask,

        EMbmAvkonQgnQgn_home_page_44_mask,

        EMbmAvkonQgnQgn_home_page_51_mask,

        EMbmAvkonQgnQgn_home_page_52_mask,

        EMbmAvkonQgnQgn_home_page_53_mask,

        EMbmAvkonQgnQgn_home_page_54_mask,

        EMbmAvkonQgnQgn_home_page_55_mask,

        EMbmAvkonQgnQgn_home_page_61_mask,

        EMbmAvkonQgnQgn_home_page_62_mask,

        EMbmAvkonQgnQgn_home_page_63_mask,

        EMbmAvkonQgnQgn_home_page_64_mask,

        EMbmAvkonQgnQgn_home_page_65_mask,

        EMbmAvkonQgnQgn_home_page_66_mask

        };

const TAknsItemID KSkinIds[] = {            

        KAknsIIDQgnHomePage11,

        KAknsIIDQgnHomePage21,

        KAknsIIDQgnHomePage22,

        KAknsIIDQgnHomePage31,

        KAknsIIDQgnHomePage32,

        KAknsIIDQgnHomePage33,

        KAknsIIDQgnHomePage41,

        KAknsIIDQgnHomePage42,

        KAknsIIDQgnHomePage43,

        KAknsIIDQgnHomePage44,

        KAknsIIDQgnHomePage51,

        KAknsIIDQgnHomePage52,

        KAknsIIDQgnHomePage53,

        KAknsIIDQgnHomePage54,

        KAknsIIDQgnHomePage55,

        KAknsIIDQgnHomePage61,

        KAknsIIDQgnHomePage62,

        KAknsIIDQgnHomePage63,

        KAknsIIDQgnHomePage64,

        KAknsIIDQgnHomePage65,

        KAknsIIDQgnHomePage66

        };

#endif // MSK icon change

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

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

// BuildTriggerL

// Builds a trigger node

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

//

static CXnNode* BuildTriggerL( CXnUiEngine& aUiEngine,

    const TDesC8& aStringValue )

    {

    CXnNode* node = CXnNode::NewL();

    CleanupStack::PushL( node );

    CXnType* type = CXnType::NewL( XnPropertyNames::action::KTrigger );

    CleanupStack::PushL( type );

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

    CleanupStack::Pop( type );

    node->SetImpl( impl );

    node->SetUiEngine( aUiEngine );

    CXnDomStringPool& sp( aUiEngine.ODT()->DomDocument().StringPool() );

    CXnProperty* name = CXnProperty::NewL(

        XnPropertyNames::action::trigger::KName, aStringValue,

        CXnDomPropertyValue::EString, sp );

    CleanupStack::PushL( name );

    node->SetPropertyL( name );

    CleanupStack::Pop( name );

    CXnProperty* value = CXnProperty::NewL(

        XnPropertyNames::action::KValue,

        KNullDesC8, CXnDomPropertyValue::EString, sp );

    CleanupStack::PushL( value );

    node->SetPropertyL( value );

    CleanupStack::Pop( value );

    CleanupStack::Pop( node ); 

    return node;

    }

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

// SetOnlineStateL

// 

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

//

static void SetOnlineStateL( CXnAppUiAdapter& aAdapter, 

    CXnViewData& aViewData )

    {

    if( !aViewData.Active() )

        {

        // Only active view can change online/offline state

        return;

        }

    RPointerArray< CXnNode > nodes;

    CleanupClosePushL( nodes );

    RPointerArray< CXnNodeAppIf > list;

    CleanupClosePushL( list );

    aViewData.ContentSourceNodesL( nodes );

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

        {

        list.AppendL( &nodes[i]->AppIfL() );

        }

    aAdapter.SetOnlineStateL( list );

    CleanupStack::PopAndDestroy( 2, &nodes ); // &list                                                 

    }

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

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

// CXnViewManager::NewL()

// Two-phased constructor.

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

//

CXnViewManager* CXnViewManager::NewL( CXnAppUiAdapter& aAdapter )    

    {

    CXnViewManager* self = CXnViewManager::NewLC( aAdapter );

    CleanupStack::Pop( self );

    return self;

    }

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

// CXnViewManager::NewLC()

// Two-phased constructor.

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

//

CXnViewManager* CXnViewManager::NewLC( CXnAppUiAdapter& aAdapter )

    {

    CXnViewManager* self = new( ELeave ) CXnViewManager( aAdapter );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CXnViewManager::CXnViewManager()

// C++ default constructor

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

//

CXnViewManager::CXnViewManager( CXnAppUiAdapter& aAdapter ) 

    : iAppUiAdapter( aAdapter ), 

      iApplicationUid( iAppUiAdapter.Application()->AppDllUid() )

    {

    }

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

// CXnViewManager::~CXnViewManager()

// C++ default destructor.

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

//

CXnViewManager::~CXnViewManager()

    {

    iObservers.Reset();

    delete iRootData;

    delete iWidgetAmountTrigger;       

    if ( iResources )

        {

        iResources->Reset();

        }

    delete iResources;

    iControls.Reset();

    iAppearanceNodes.Reset();

    iFailedPlugins.Reset();

    delete iComposer;

    delete iEditor;

    delete iOomSysHandler;

    }

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

// CXnViewManager::ConstructL()

// 2nd phase constructor

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

//

void CXnViewManager::ConstructL()

    {

    iOomSysHandler = CXnOomSysHandler::NewL();

    // Create resource list

    iResources = new ( ELeave ) CArrayPtrSeg< CXnResource > ( 16 );

    const TInt KMaxUidLength( 10 );

    _LIT8( KUint, "%u" );

    TBuf8< KMaxUidLength > uid;

    uid.Format( KUint, iApplicationUid.iUid );

    iEditor = CXnEditor::NewL( *this, uid );

    iHspsWrapper = &iEditor->HspsWrapper();

    iComposer = CXnComposer::NewL( *iHspsWrapper );

    }

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

// CXnViewManager::LoadUiL()

// Loads the application UI and initial view

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

//

void CXnViewManager::LoadUiL()

    {

    iUiEngine->DisableRenderUiLC();

    // Load application root configuration

    iRootData = CXnRootData::NewL( *this, iApplicationUid );

    // Load root configuration and initial view.

    iRootData->LoadL();

    CleanupStack::PopAndDestroy(); // DisableRenderUiLC();

    }

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

// CXnViewManager::ReloadUiL()

// Reloads the application UI and initial ivew

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

void CXnViewManager::ReloadUiL()  

    {

#ifdef _XN_PERFORMANCE_TEST_

    RDebug::Print( _L( "CXnViewManager::ReloadUiL() - start" ) );

#endif //_XN_PERFORMANCE_TEST_

    NotifyViewDeactivatedL( ActiveViewData() );

    delete iWidgetAmountTrigger;

    iWidgetAmountTrigger = NULL;

    // Destroy active view data

    ActiveViewData().Destroy();

    // Schedule application configuration destroyal

    iRootData->Destroy();

    iRootData = NULL;

    iFlags.ClearAll();

    User::Heap().Compress();

    LoadUiL();

    // Activate first view from the new configuration

    iAppUiAdapter.ViewAdapter().ActivateContainerL( ActiveViewData() );    

#ifdef _XN_PERFORMANCE_TEST_

    RDebug::Print( _L( "CXnViewManager::ReloadUiL() - end" ) );

#endif //_XN_PERFORMANCE_TEST_

    }

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

// CXnViewManager::LoadWidgetToPluginL()

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

//

TInt CXnViewManager::LoadWidgetToPluginL( CHsContentInfo& aContentInfo,

    CXnPluginData& aPluginData )

    {

    // Plugin must not have widget when about to add

    if ( aPluginData.Occupied() )

        {

        return KErrAlreadyExists;

        }

    CXnViewData& viewData( 

        static_cast< CXnViewData& >( *aPluginData.Parent() ) );

    TBool emptyInUse( viewData.UseEmptyWidget() );

    // By default widget is added to active view configuration

    const TDesC8& configurationId( viewData.ConfigurationId() );

    TInt retval( KErrGeneral );

    if ( emptyInUse && aPluginData.Empty() )

        {

        retval = iHspsWrapper->ReplacePluginL( 

            aPluginData.PluginId(), aContentInfo.Uid() );   

        if( retval == KErrDiskFull )

            {

            ShowDiskFullMessageL();

            }

        }

    else

        {

        TInt index( viewData.PluginData().Find( &aPluginData ) );

        CAddPluginResult* result = iHspsWrapper->AddPluginL( 

            configurationId, aContentInfo.Uid(), index );

        CleanupStack::PushL( result );

        retval = result->Status();        

        if ( retval == KErrNone )

            {

            aPluginData.SetPluginIdL( result->PluginId() );

            }

        else if( retval == KErrDiskFull )

            {

            ShowDiskFullMessageL();

            }        

        CleanupStack::PopAndDestroy( result ); 

        }

    if ( retval == KErrNone )

        {              

        iUiEngine->DisableRenderUiLC();

        NotifyConfigureWidgetL( aContentInfo, aPluginData );

        aPluginData.LoadL();

        UpdateCachesL();

        NotifyWidgetAdditionL( aPluginData );

        // Report widget amount in the view

        ReportWidgetAmountL( viewData );

        CleanupStack::PopAndDestroy(); // DisableRenderUiLC

        }

    return retval;

    }

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

// CXnViewManager::UnloadWidgetFromPluginL()

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

//

TInt CXnViewManager::UnloadWidgetFromPluginL( CXnPluginData& aPluginData )    

    {          

    TBool error( aPluginData.PluginState().CompareF( KStateError ) == 0 );

    // Plugins in error state are always removed

    if ( !error && !aPluginData.Occupied() )

        {

        // Plugin must have widget when about to remove

        return KErrNotFound;            

        }

    CXnViewData& viewData( 

        static_cast< CXnViewData& >( *aPluginData.Parent() ) );

    TBool emptyInUse( viewData.UseEmptyWidget() );

    TInt retval( KErrGeneral );

    // Save temporary

    TBuf8< 32 > id( aPluginData.PluginId() );

    if ( emptyInUse )

        {

        retval = iHspsWrapper->ReplacePluginL( 

            aPluginData.PluginId(), KEmptyWidgetUid );                       

        }

    else 

        {        

        retval = iHspsWrapper->RemovePluginL( aPluginData.PluginId() );

        }

    if ( retval == KErrNone )

        {

        TBool active( aPluginData.Active() );

        iUiEngine->DisableRenderUiLC();

        NotifyWidgetRemovalL( aPluginData );

        aPluginData.Destroy();

        if ( emptyInUse )

            {

            // Write id back for for later usage

            aPluginData.SetEmptyL( id );

            }

        else

            {

            // Reorder plugindata array

            RPointerArray< CXnPluginData >& plugins( viewData.PluginData() ); 

            TInt index( plugins.Find( &aPluginData ) );

            plugins.Remove( index );

            plugins.Insert( &aPluginData, plugins.Count() - 1 );                                           

            }

        UpdateCachesL();

        // Report widget amount in the view 

        ReportWidgetAmountL( viewData );

        if ( active )

            {            

            iUiEngine->RenderUIL();

            SetOnlineStateL( iAppUiAdapter, ActiveViewData() );

            }

        CleanupStack::PopAndDestroy(); // DisableRenderUiLC               

        }

    return retval;