#include <e32hashtab.h>

#include <utf.h>

#include <gulicon.h>

#include <hscontentpublisher.h>

#include <hspublisherinfo.h>

#include "contentrenderer.h"

#include "appui.h"

#include "activetransactionstack.h"

#include "transactionfactoryimpl.h"

#include "mtransaction.h"

#include "mtransactionelement.h"

#include "aixmluiutils.h"

#include "xmluicontroller.h"

#include "xmlnodeidgenerator.h"

#include "aixmluiconstants.h"

#include "aifweventhandler.h"

#include "databuffertransactionelement.h"

#include "newstickercallbackhandler.h"

#include "newstickertransactionelement.h"

#include "csspropertymap.h"

#include "policyevaluator.h"

#include "debug.h"

#include "xnuiengineappif.h"

#include "xnnodeappif.h"

#include "xncomponentnodeimpl.h"

#include "xnproperty.h"

#include "mxncomponentinterface.h"

#include "xntext.h"

#include "xnbitmap.h"

#include "xntype.h"

#include "xnmenuadapter.h"

#include "xnlistquerydialogadapter.h"

#include "mxncomponentinterface.h"

#include "aistrcnv.h"

#include "contentprioritymap.h"

#include "ainativeuiplugins.h"

/**

 * Cleanup item for cleanup of TPtrHashMapIter

 */            

class TMapCleanupItem

public:

     * C++ consturctor

    TMapCleanupItem( TPtrHashMapIter< TDesC, TInt >& aIterator );

     * Removes the pointers in the map and deletes the objects

     * referenced by the pointers.

     */ 

    void Release();

private:        

    TPtrHashMapIter< TDesC, TInt > iIterator;    

    };

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

// TMapCleanupItem::TMapCleanupItem

//  

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

//

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

// TMapCleanupItem::Release

//  

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

//

    const TDesC* key( iIterator.CurrentKey() );

    const TInt* value( iIterator.CurrentValue() );

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

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

// ContentItemIterator

// Gets content item iterator

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

//

static MAiContentItemIterator* ContentItemIterator( CHsContentPublisher& aPlugin,

    CHsContentPublisher::TProperty aType )

    {       

    return static_cast< 

        MAiContentItemIterator* >( aPlugin.GetProperty( aType ) );                                     

    }

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

// ContentPriority

// Gets the content priority associated in the property element

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

//

static TInt ContentPriority( CXnNodeAppIf& aPropertyElement )

    {

    TInt32 priority( KErrNotFound );

    const TDesC8* name( 

        PropertyValue( aPropertyElement, property::KName ) );

    if ( name && *name == name::KPriority )

        {

        const TDesC8* value( 

            PropertyValue( aPropertyElement, property::KValue ) );

        if ( value )

            {

            AiUtility::ParseInt( priority, *value );

            }

        }

    return priority;

    }

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

// RemoveNonPriorityElements

// Remove elements from array which do not contain priority or priority is 

// not lower than the given value.

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

//

static void RemoveNonPriorityElements( RPointerArray< CXnNodeAppIf>& aElements,

    TInt aLastPriority )

    {

    //  Remove non priority elements and higher priority elements

    TInt elementCount( aElements.Count() );    

    for ( TInt i = 0; i < elementCount; )

        {

        CXnNodeAppIf* current( aElements[i] );

        // Check name attribute

        const TDesC8* name( PropertyValue( *current, property::KName ) );

        if ( !name || *name != name::KPriority )

            {

            // Remove current

            aElements.Remove( i );

            --elementCount;

            }

        else

            {

            // Check current priority

            const TDesC8* value( 

                PropertyValue( *current, property::KValue ) );

            if ( !value ) // value not present

                {

                aElements.Remove( i );

                --elementCount;

                continue;

                }

            TInt32 currentPriority( KErrNotFound );

            if ( AiUtility::ParseInt( currentPriority, *value ) != KErrNone )

                {

                // value is not integer

                aElements.Remove( i );

                --elementCount;

                continue;

                }

            if ( currentPriority < aLastPriority )

                {

                // Keep element and iterate further

                ++i;

                }

            else

                {

                // priority is too high

                aElements.Remove( i );

                --elementCount;

                }

            }

        }

    }

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

// DescendingPriorityOrder

// Descending priority order for prioritized content selectors. 

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

//

static TInt DescendingPriorityOrder( const CXnNodeAppIf& aNode1,

    const CXnNodeAppIf& aNode2 )

    {

    /*

    * @param aNode1 First node to compare

    * @param aNode2 Second node to compare

    * @return 0 nodes have equal priority

    * @return >0 aNode1 has lower priority

    * @return <0 aNode2 has lower priority

    */

    // Array content has been validated, so no checks are needed

    const TDesC8* value1( 

        PropertyValue( aNode1, property::KValue ) );

    const TDesC8* value2( 

        PropertyValue( aNode2, property::KValue ) );

    TInt32 priority1( KErrNotFound );

    AiUtility::ParseInt( priority1, *value1 );

    TInt32 priority2( KErrNotFound );

    AiUtility::ParseInt( priority2, *value2 );

    if ( priority1 == priority2 )

        {

        return 0;

        }

    return ( priority1 < priority2 ) ? 1 : -1;

    }

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

// RemoveDuplicateContentChangesL

// Removes duplicate entries in content change array 

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

//

static void RemoveDuplicateContentChangesL( RAiPolicyElementArray& aArray )

    {

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

        {

        HBufC* id( PropertyValueL( aArray[i].Target(),  

            AiUiDef::xml::property::KId ) ); 

        if ( id )

            {

            CleanupStack::PushL( id );

            for ( TInt j = i; j < aArray.Count(); ++j )

                {

                HBufC* id2( PropertyValueL( aArray[j].Target(), 

                   AiUiDef::xml::property::KId ) );

                if ( id2 )

                    {

                    CleanupStack::PushL( id2 );

                    // Same id and same policy

                    if ( i != j && id->Compare( *id2 ) == 0 &&                          

                     ( aArray[i].Policy().Compare( aArray[j].Policy()) == 0 ) ) 

                        {

                        aArray.Remove( j );

                        --j;

                        }

                    }

                CleanupStack::PopAndDestroy( id2 );                

                }

            CleanupStack::PopAndDestroy( id );

            }

        }

    }

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

// CleanupReleaseMapItem

// Helper to handle cleanup of map iterator 

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

//

static void CleanupReleaseMapItem( TAny* aMapCleanupItem )

    {

    if ( aMapCleanupItem )

        {

        static_cast< TMapCleanupItem* >( aMapCleanupItem )->Release();

        }

    }

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

// CleanupReleasePushL

// Helper to push map iterator into cleanup stack. 

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

//

static void CleanupReleasePushL( TMapCleanupItem& aCleanupItem )

    {

    CleanupStack::PushL( TCleanupItem( CleanupReleaseMapItem, &aCleanupItem ) );

    }

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

// CContentRenderer::CContentRenderer

// 

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

//

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

// CContentRenderer::ConstructL

// 

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

//

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

// CContentRenderer::NewL

// 

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

//

    CleanupStack::Pop( self );

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

// CContentRenderer::~CContentRenderer

// 

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

//

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

// CContentRenderer::SetEventHandler

// 

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

//

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

// CContentRenderer::StartTransaction

// 

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

//

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

// CContentRenderer::Commit

// 

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

//

    MTransaction* tr( iStack->Remove( aTxId ) );

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

// CContentRenderer::ProcessContentChangesL

// 

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

//

    TDblQueIter<CTransactionElement> iter( aTr.ElementIter() );

          iPolicyEvaluator->EvaluateContentChangedPolicyL( *(target.ParentL() ),