/*

* 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    "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    "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"

using namespace AiXmlUiController;

using namespace AiUiDef::xml;

using namespace XnTextInterface;

using namespace XnImageInterface;

namespace

    {

    typedef RPointerArray<CXnNodeAppIf> RXnNodeArray;

    /**

     * Gets content item iterator.

     *

     * @param aPlugin plugin to fetch the iterator

     * @param aContentType type of iterator (content/resource/event)

     * @return the iterator

     * @leave KErrNotSupported if plugin does not provide iterator

     */ 

    static MAiContentItemIterator& ContentItemIteratorL( MAiPropertyExtension& aPlugin,

                                                         TInt aContentType )

        {

        MAiContentItemIterator* iter =

            static_cast< MAiContentItemIterator* >( aPlugin.GetPropertyL( aContentType ) );

        if ( !iter )

            {

            User::Leave( KErrNotSupported );

            }

        return *iter;

        }

    /**

     * Gets the content priority associated in the property element.

     *

     * @param aPropertyElement the property element

     * @return priority value or KErrNotFound for non-prioritized element

     */

    TInt GetContentPriority( 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;

        }

    /**

     * Remove elements from array which do not contain priority or priority is not lower than

     * the given value.

     * 

     * @param aElements array of elements

     * @param aLastPriority upper bound of priority value (excluded from the array)

     */

    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;

                    }

                }

            }

        }

    /**

     * Descending priority order for prioritized content selectors.

     *

     * @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

     */

    TInt DescendingPriorityOrder( const CXnNodeAppIf& aNode1,

                                  const CXnNodeAppIf& aNode2 )

        {

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

        }

    /**

     * Removes duplicate entries in content change array

     */

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

                }

            }

        }

    /**

     * Cleanup item for cleanup of TPtrHashMapIter

     */            

    class TMapCleanupItem

        {

    public:

        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;

        };

    /**

     * Helper to handle cleanup of map iterator

     * @param aMapCleanupItem 

     */

    void CleanupRelease( TAny* aMapCleanupItem )

        {

        if ( aMapCleanupItem )

            {

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

            }

        }

    /**

     * Helper to push map iterator into cleanup stack.

     *

     * @param aCleanupItem item to push into cleanup stack

     **/

    void CleanupReleasePushL( TMapCleanupItem& aCleanupItem )

        {

        CleanupStack::PushL( TCleanupItem( CleanupRelease,

                                           &aCleanupItem ) );

        }

    }

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

    : iIterator( aIterator )

    {

    }

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

    }

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

CContentRenderer::CContentRenderer( CAppUi& aAppUi )

    : iAppUi( aAppUi )

    {

    }

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* CContentRenderer::NewL( CAppUi& aAppUi )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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 iNTClass;

    delete iPropertyMap;

    delete iContentPriorityMap;

    delete iCallbackHandler;

    }

void CContentRenderer::SetEventHandler( MAiFwEventHandler& aFwEventHandler )

    {

    iFwEventHandler = &aFwEventHandler;

    }

void CContentRenderer::Reset()

    {

    iContentPriorityMap->Reset();

    iPropertyMap->Reset();

    }

void CContentRenderer::CleanPluginFromUi( MAiPropertyExtension& aPlugin )

    {

    // Create transaction to clean UI

    TInt txId = reinterpret_cast< TInt >( &aPlugin );

    TBool txCreated = ( StartTransaction( txId ) == KErrNone );

    // Clean plugin

    TRAPD( cleanError, CleanPluginFromUiL( aPlugin ) );

    // Commit transaction

    if ( txCreated )

        {

        if (cleanError )

            {

            CancelTransaction( txId );

            }

        else

            {

            Commit( txId );

            }

        }

    }

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;

    }

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

        TRAPD( error, tr->CommitL( layoutChanged, propertyHashMap ) );

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

            );

        iFactory->ReleaseTransaction( tr );  

        return error;

        }

    return KErrNotSupported;

    }

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

    }

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 )

                {

                targetNode->ShowTooltipsL();

                }                   

            }        

        }

    }

TInt CContentRenderer::CancelTransaction( TInt aTxId )

    {

    // Remove transaction with aTxId from stack

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

    if ( tr )

        {

        // Release transaction to factory

        __TICK("XML UI: Cancel transaction");

        __HEAP("XML UI: Cancel transaction");

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

        iFactory->ReleaseTransaction( tr );

        return KErrNone;

        }