/*

* Copyright (c) 2005-2007 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:  Content renderer implementation

*

*/

// System includes

#include <e32hashtab.h>

#include <utf.h>

#include <gulicon.h>

// User includes

#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 "newstickertransactionelement.h"

#include "csspropertymap.h"

#include "policyevaluator.h"

#include "debug.h"

#include "xnuiengineappif.h"

#include "xnnodeappif.h"

#include "xnproperty.h"

#include "mxncomponentinterface.h"

#include "xntext.h"

#include "xnbitmap.h"

#include "xntype.h"

#include "xnmenuadapter.h"

#include "xnlistquerydialogadapter.h"

#include "xnnewsticker.h"

#include "mxncomponentinterface.h"

#include "aistrcnv.h"

#include "contentprioritymap.h"

#include "ainativeuiplugins.h"

using namespace AiXmlUiController;

using namespace AiUiDef::xml;

using namespace XnTextInterface;

using namespace XnImageInterface;

/**

 * 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::TMapCleanupItem( TPtrHashMapIter< TDesC, TInt >& aIterator )

    : iIterator( aIterator )

    {

    }

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

// TMapCleanupItem::Release

//  

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

//

void TMapCleanupItem::Release()

    {

    // Delete current key and value

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

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

    delete key;

    delete value;

    // Remove mapping from the map.

    iIterator.RemoveCurrent();

    }

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

                CleanupStack::PushL( id2 );

                if ( 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 ) );

    }

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

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

// CContentRenderer::CContentRenderer

// 

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

//

CContentRenderer::CContentRenderer( CAppUi& aAppUi )

    : iAppUi( aAppUi )

    {

    }

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

// CContentRenderer::ConstructL

// 

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

//

void CContentRenderer::ConstructL()

    {

    iContentPriorityMap = AiUtility::CContentPriorityMap::NewL();

    iPropertyMap = CCssPropertyMap::NewL();

    iFactory = CTransactionFactoryImpl::NewL(*iContentPriorityMap,

                                             *iPropertyMap);

    iStack = CActiveTransactionStack::NewL();

    iNodeIdGenerator = CXmlNodeIdGenerator::NewL();

    iTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iPolicyEvaluator = CPolicyEvaluator::NewL();

    }

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

// CContentRenderer::NewL

// 

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

//

CContentRenderer* CContentRenderer::NewL( CAppUi& aAppUi )

    {

    CContentRenderer* self = new( ELeave ) CContentRenderer( aAppUi );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CContentRenderer::~CContentRenderer

// 

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

//

CContentRenderer::~CContentRenderer()

    {

    delete iPolicyEvaluator;

    if ( iTimer )

        {

        iTimer->Cancel();

        delete iTimer;

        }

    delete iNodeIdGenerator;

    if ( iStack )

        {

        while ( !iStack->IsEmpty() )

            {

            MTransaction* tr = iStack->Pop();

            iFactory->ReleaseTransaction( tr );

            }

        delete iStack;

        }

    delete iFactory;

    iRefreshableUiElements.ResetAndDestroy();

    delete iPropertyMap;

    delete iContentPriorityMap;    

    }

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

// CContentRenderer::SetEventHandler

// 

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

//

void CContentRenderer::SetEventHandler( MAiFwEventHandler& aFwEventHandler )

    {

    iFwEventHandler = &aFwEventHandler;

    }

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

// CContentRenderer::StartTransaction

// 

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

//

TInt CContentRenderer::StartTransaction( TInt aTxId )

    {

    __PRINT(__DBG_FORMAT("\t[I]\tXML UI: Start transaction id=%d"), aTxId);

    __HEAP("XML UI: Start transaction");

    __TICK("XML UI: Start transaction");

    TRAPD( error, DoStartTransactionL( aTxId ) );

    if ( error )

        {

        SetImmediateMode( ETrue );

        }

    return error;

    }

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

// CContentRenderer::Commit

// 

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

//

TInt CContentRenderer::Commit( TInt aTxId )

    {

    // Remove transaction with aTxId from stack

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

    if ( tr )

        {

        // Commit transaction        

        RPropertyHashMap propertyHashMap;

        TBool layoutChanged( EFalse );

        if( error == KErrNone )

            {

            TRAP_IGNORE( SetPropertyArraysL( propertyHashMap ) );

            }

        propertyHashMap.Close();

        __TICK("XML UI: Commit transaction");

        __HEAP("XML UI: Commit transaction");

        __PRINT(__DBG_FORMAT("\t[I]\tXML UI: Commit transaction id=%d"), aTxId);

        StartContentRefresh();

        TRAP_IGNORE

            (

            iAppUi.UiEngineL()->RenderUIL();                                  //jtm+++

            ProcessContentChangesL( *tr );

            );

        return error;

        }

    return KErrNotSupported;

    }

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

// CContentRenderer::ProcessContentChangesL

// 

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

//

void CContentRenderer::ProcessContentChangesL( MTransaction& aTr )

    {

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

    RAiPolicyElementArray contentChangedArray;

    CleanupClosePushL( contentChangedArray );

    while ( iter )

          {

          CTransactionElement* element = iter++;

          CXnNodeAppIf& target = element->Target();

          // Find own and parents policy/ContentChanged nodes 

          iPolicyEvaluator->EvaluateContentChangedPolicyL( target, 

                  contentChangedArray);

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

                  contentChangedArray);

          }

    ::RemoveDuplicateContentChangesL( contentChangedArray );

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

        {

        ProcessContentChangeL( contentChangedArray[i] );

        }

    CleanupStack::PopAndDestroy();

    }

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

// CContentRenderer::ProcessContentChangeL

// 

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

//

void CContentRenderer::ProcessContentChangeL( TAiPolicyElement& aElement )

    {

    const TDesC8* id( PropertyValue( 

        aElement.Target(), AiUiDef::xml::property::KId ) ); 

    if ( id )

        {

        CXnNodeAppIf* targetNode( 

            FindNodeByIdL( *id, aElement.Target().Namespace() ) );

        if ( targetNode )

            {                     

            if ( aElement.Policy() == AiUiDef::xml::value::KShowTooltips )

                {