/*

* 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:  Manages Ai3 personalization

*

*/

// System includes

#include <StringLoader.h>

#include <aknlistquerydialog.h> 

#include <aknnotewrappers.h>

#include <utf.h>

#include <AknsWallpaperUtils.h>

#include <centralrepository.h>

#include <AknSkinsInternalCRKeys.h>

#include "../../../inc/ai3.hrh"

#include <xnuiengine.rsg>

#include <hscontentcontrolui.h>

#include <hscontentcontrol.h>

#include <activeidle2domaincrkeys.h>

// User includes

#include "xnuiengine.h"

#include "xnproperty.h"

#include "xnnode.h"

#include "xntype.h"

#include "xntext.h"

#include "xnappuiadapter.h"

#include "xndomnode.h"

#include "xndomproperty.h"

#include "xndompropertyvalue.h"

#include "xndomlist.h"

#include "xndomattribute.h"

#include "hspssapi.h"

#include "cpssapi.h"

#include "xneditmode.h"

#include "xndomdocument.h"

#include "xnnodeimpl.h"

#include "xnodt.h"

#include "xnplugindefs.h"

#include "xnviewmanager.h"

#include "xnplugindata.h"

#include "xnrootdata.h"

#include "xnviewdata.h"

#include "xnwallpaperview.h"

#include "xnbackgroundmanager.h"

#include "xneditor.h"

#include "xnpanic.h"

using namespace hspswrapper;

using namespace cpswrapper;

// LOCAL CONSTANTS AND MACROS

_LIT8( KEventPluginUnInstalled, "PluginUninstalled" );

_LIT8( KEventRootConfActivated, "AppConfActivated" );

_LIT8( KEventPluginUpdated, "PluginUpdated" );

_LIT8( KEventPluginInstalled, "PluginInstalled" );

_LIT8( KEmptyWidgetUid, "0x2001F47F" );

_LIT8( KDownload, "Editor/DownloadCaption" );

_LIT8( KSingle, "single" );

_LIT8( KMulti, "multi" );

const TInt32 KMultiInstanceUnlimitedValue = -1;

const TUid KDummyUid = { 0x0000000 };

const TUint32 KAICCPluginUIDKey = 0x00003010;

const TInt32 KOpaQDataLen = 10;

enum

    {

    ECanBeAdded = 0x01,

    ECanBeRemoved

    };

// ====================== LOCAL FUNTION PROTOTYPES ============================

static void DeletePluginInfos( TAny* aObject );

static void DeleteItemMaps( TAny* aObject );

static void DeleteWidgetInfo( TAny* aObject );

static TPtrC ParseWidgetName( const CHsContentInfo& aContentInfo );

static void SetPropertyL( CXnNode& aNode, const TDesC8& aAttribute, 

                          const TDesC8& aValue );    

static void ShowErrorNoteL( const TDesC& aMsg );      

static CXnPluginData* DeterminePlugin( CXnViewManager& aViewManager, 

                                         CXnNode* aPredicate = NULL );

static CXnPluginData* DeterminePlugin( 

                            RPointerArray< CXnPluginData >& aPlugins,                            

                            const CHsContentInfo& aContentInfo );

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

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

// DeletePluginInfos

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

// 

static void DeletePluginInfos( TAny* aObject )

    {

    reinterpret_cast<

        RPointerArray< hspswrapper::CPluginInfo >* >(

            aObject )->ResetAndDestroy();

    }

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

// DeleteItemMaps

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

// 

static void DeleteItemMaps( TAny* aObject )

    {

    reinterpret_cast<

        RPointerArray< hspswrapper::CItemMap >* >(

            aObject )->ResetAndDestroy();

    }

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

// DeleteWidgetInfo

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

// 

static void DeleteWidgetInfo( TAny* aObject )    

    {

    reinterpret_cast<

        RPointerArray< CHsContentInfo >* >( aObject )->ResetAndDestroy();

    }

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

// ParseWidgetName

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

// 

static TPtrC ParseWidgetName( const CHsContentInfo& aContentInfo )

    {

    TPtrC retval( aContentInfo.Name() );

    TInt pos( retval.Locate( ':' ) );

    if ( pos != KErrNotFound )

        {

        retval.Set( retval.Right( retval.Length() - pos - 1 ) );

        }

    return retval;

    }

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

// SetPropertyL

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

// 

static void SetPropertyL( CXnNode& aNode, 

    const TDesC8& aAttribute, const TDesC8& aValue )

    {

    CXnDomNode* node( aNode.DomNode() );

    if ( node )

        {

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

        // create new property

        CXnDomPropertyValue* value = CXnDomPropertyValue::NewL( sp );

        CleanupStack::PushL( value );

        value->SetStringValueL( CXnDomPropertyValue::EString, aValue );

        CXnProperty* prop = CXnProperty::NewL( aAttribute, value, *sp );

        CleanupStack::Pop( value );

        CleanupStack::PushL( prop );

        aNode.SetPropertyL( prop );

        CleanupStack::Pop( prop );

        }

    }

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

// ShowErrorNoteL

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

// 

static void ShowErrorNoteL( const TDesC& aMsg )

    {

    CAknErrorNote* note = new ( ELeave ) CAknErrorNote;

    CleanupStack::PushL( note );

    note->ExecuteLD( aMsg );

    CleanupStack::Pop( note );    

    }

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

// DeterminePlugin

// Determinates target plugin where widget should be added

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

// 

CXnPluginData* DeterminePlugin( CXnViewManager& aViewManager, 

    CXnNode* aPredicate )

    {

    CXnViewData& viewData( aViewManager.ActiveViewData() );

    if ( aPredicate )

        {

        CXnPluginData* plugin( viewData.Plugin( aPredicate ) );

        if ( plugin && !plugin->Occupied() )

            {

            return plugin;

            }

        }

    RPointerArray< CXnNode >& nodes( aViewManager.PluginNodes() );

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

        {

        CXnNode* node( nodes[i] );

        CXnPluginData* plugin( viewData.Plugin( node ) );

        if ( plugin && !plugin->Occupied() )

            {

            return plugin;

            }

        }

    return NULL;

    }

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

// DeterminePlugin

// Determines target plugin based widget info

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

//

CXnPluginData* DeterminePlugin( RPointerArray< CXnPluginData >& aPlugins, 

    const CHsContentInfo& aContentInfo ) 

    {    

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

        {

        CXnPluginData* plugin( aPlugins[i] );

        if ( plugin->Occupied() && plugin->PluginId() == aContentInfo.PluginId() )

            {

            return plugin;

            }

        }

    return NULL;

    }

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

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

// CXnEditor::NewL

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

// 

CXnEditor* CXnEditor::NewL( CXnViewManager& aViewManager, 

    const TDesC8& aUid )

    {

    CXnEditor* self = CXnEditor::NewLC( aViewManager, aUid );

    CleanupStack::Pop( self );

    return self;

    }

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

// CXnEditor::NewLC

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

// 

CXnEditor* CXnEditor::NewLC( CXnViewManager& aViewManager,

    const TDesC8& aUid )

    {

    CXnEditor* self = new ( ELeave ) CXnEditor( aViewManager );

    CleanupStack::PushL( self );

    self->ConstructL( aUid );

    return self;

    }

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

// CXnEditor::CXnEditor

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

// 

CXnEditor::CXnEditor( CXnViewManager& aViewManager )

    : iViewManager( aViewManager ),

      iWidgetsVisibilityState( ETrue )

    {

    iViewManager.AddObserver( *this );

    }

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

// CXnEditor::ConstructL

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

// 

void CXnEditor::ConstructL( const TDesC8& aUid )

    {

    iCpsWrapper = CCpsWrapper::NewL( *this );

    iHspsWrapper = CHspsWrapper::NewL( aUid, this );

    iRepository= CRepository::NewL( TUid::Uid( KCRUidActiveIdleLV ) );

    }

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

// CXnEditor::~CXnEditor

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

// 

CXnEditor::~CXnEditor()

    {

    iViewManager.RemoveObserver( *this );

    delete iCpsWrapper;

    delete iHspsWrapper;

    delete iPublisherMap;

    delete iRepository;

    }

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

// CXnEditor::IsCurrentViewFull

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

//

TBool CXnEditor::IsCurrentViewFull()

    {

    TBool viewFull = ETrue;

    RPointerArray< CXnPluginData >& plugins( 

        iViewManager.ActiveViewData().PluginData() );

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

        {

        if ( !plugins[i]->Occupied() )

            {

            viewFull = EFalse;

            break;

            }

        }

    return viewFull;

    }

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

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

//

    TBool aIgnoreViewFull )

    {

    RPointerArray< CHsContentInfo >& list( aContentInfoArray.Array() );

    TBool viewFull = ( aIgnoreViewFull ? EFalse : IsCurrentViewFull() );

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

        {

        CHsContentInfo* info( list[i] );

        info->SetCanBeAdded( EFalse );

        info->SetCanBeRemoved( EFalse );

        TInt result( 0 );

        if ( info->Type() != KKeyTemplate() )

            {   

            result = NonTemplateWidgetCanBeAddedRemovedL( *info );            

            }

        else

            {

            result = TemplateWidgetCanBeAddedRemovedL( *info );

            }

        if ( ( result & ECanBeAdded ) && !viewFull )

            {                        

            info->SetCanBeAdded( ETrue );            

            }

        if ( result & ECanBeRemoved )

            {

            info->SetCanBeRemoved( ETrue );

            }

        }            

    }

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

// CXnEditor::TemplateWidgetCanBeAddedRemovedL

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

// 

TInt CXnEditor::TemplateWidgetCanBeAddedRemovedL( 

    CHsContentInfo& aInfo )

	{

	TInt retval( 0 );

	TInt widgetCount( 0 );

	RPointerArray< CXnPluginData > plugins;

	CleanupClosePushL( plugins );

	if ( aInfo.IsWrt() )

	    {

	    // Get plugins globally from all pages

	    iViewManager.PluginDataL( plugins, ETrue );

	    }

	else

	    {

	    // Get plugins from current page

	    iViewManager.PluginDataL( plugins, EFalse );

	    }

	// Get widgets in current configuration

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

		{

		CXnPluginData* plugin( plugins[i] );

		if ( !plugin->Occupied() )

		    {

		    continue;

		    }

		if ( plugin->PublisherName() == aInfo.PublisherId() )

			{

			if ( plugin->Removable() )

			    {

			    // To enable widget remove

			    aInfo.SetPluginIdL( plugin->PluginId() );

			    retval |= ECanBeRemoved;

			    }

			widgetCount++;

			}

		}

	if ( widgetCount < aInfo.MaxWidgets() )

	    {

	    retval |= ECanBeAdded;

	    }

	CleanupStack::PopAndDestroy( &plugins );

	return retval;

	}

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

// CXnEditor::NonTemplateWidgetCanBeAddedRemovedL

//

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

// 

TInt CXnEditor::NonTemplateWidgetCanBeAddedRemovedL( 

    CHsContentInfo& aInfo )

    {    

    TInt retval( 0 );

    TInt widgetCount( 0 );

    CXnViewData& activeView( iViewManager.ActiveViewData() );

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

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

        {

        CXnPluginData* plugin( plugins[i] );

        if ( !plugin->Occupied() )

            {

            continue;

            }        

        if ( plugin->PluginUid().CompareF( aInfo.Uid() ) == 0 )

            {

            if ( plugin->Removable() )

                {

                // To enable widget remove

                aInfo.SetPluginIdL( plugin->PluginId() );

                retval |= ECanBeRemoved;

                }

            widgetCount++;

            }

        }

    if ( widgetCount < aInfo.MaxWidgets() ||

        aInfo.MaxWidgets() == KMultiInstanceUnlimitedValue )

        {

        retval |= ECanBeAdded;        

        }

    return retval;

    }

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

// CXnEditor::FilterViewListL

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

//

void CXnEditor::FilterViewListL( CHsContentInfoArray& aContentInfoArray )

    {

    RPointerArray< CHsContentInfo >& list( aContentInfoArray.Array() );

    RPointerArray< CXnPluginData >& views( 

        iViewManager.ActiveAppData().PluginData() );

    TInt viewAmount( iViewManager.ViewAmount() );

    const TInt KMaxViewAmount( 6 );

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

        {

        CHsContentInfo* info( list[i] );

        info->SetCanBeAdded( EFalse );

        info->SetCanBeRemoved( EFalse );