/*
* Copyright (c) 2002 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 node class
*
*/


// INCLUDE FILES
#include <DigViewGraph.h>
#include <barsc.h>      // RResourceFile
#include <barsread.h>   // TResourceReader
#include <e32std.h>     


/// Unnamed namespace for local definitions
namespace {
void CleanupResetAndDestroy(TAny* aObj)
    {
    if (aObj)
        {
        static_cast<CArrayPtrFlat<CDigViewNode>*>(aObj)->ResetAndDestroy();
        delete aObj;
        }
    }

// LOCAL DEBUG CODE
#ifdef _DEBUG
// MODULE DATA STRUCTURES
enum TPanicCode
    {    
    EPanicPre_MergeNodesL = 1
    };

void Panic(TPanicCode aReason)
    {
    _LIT(KPanicText, "CDigViewGraph");
    User::Panic(KPanicText,aReason);
    }
#endif
}

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


//
// CDigViewNode
// 
EXPORT_C CDigViewNode::~CDigViewNode()
    {
    }

EXPORT_C TBool CDigViewNode::FindTransition
        (const TDigViewTransition& aTransition) const
    {
    for (TInt i=0; i < iTransitions.Count(); ++i)
        {
        if (iTransitions[i] == aTransition)
            return ETrue;
        }
    return EFalse;
    }

/**
 * Finds transition based on aEvent, in case not found returns NULL.
 *
 * @param aEvent event to be searched
 */
TDigViewTransition* CDigViewNode::FindTransition(const TInt aEvent)
    {
    for (TInt i=0; i < iTransitions.Count(); ++i)
        {
        if (iTransitions[i].iEvent == aEvent)
            return &iTransitions[i];
        }
    return NULL;
    }

/**
 * Appends or modify existing transition(s). 
 *
 * @param aNewNode holds transitions to be processed
 */
void CDigViewNode::MergeL(CDigViewNode& aNewNode)
    {
    TInt transCount = aNewNode.iTransitions.Count();
    while (transCount-- > 0)
        {
        TDigViewTransition newTrans = aNewNode.iTransitions.At(transCount);
        TDigViewTransition* trans = FindTransition(newTrans.iEvent);
        if (trans)
            {
            trans->iTargetViewId = newTrans.iTargetViewId;
            }
        else 
            {
            // Add new transition
            iTransitions.AppendL(newTrans);
            }
        }
    iAdditionalResId = aNewNode.iAdditionalResId;
    }


//
// CDigViewGraph
//
EXPORT_C CDigViewGraph* CDigViewGraph::NewL(TResourceReader& aResReader)
    {
    CDigViewGraph* self = new(ELeave) CDigViewGraph;
    CleanupStack::PushL(self);
    self->ConstructL(aResReader);
    CleanupStack::Pop();  //self
    return self;
    }

void CDigViewGraph::ConstructL(TResourceReader& aResReader)
    {
    iNodes = CreateUnlinkedNodesFromResourceL(aResReader);
    LinkNodesWithTransitions();    
    }

EXPORT_C CDigViewGraph::~CDigViewGraph()
    {    
    if (iNodes)
        {
        iNodes->ResetAndDestroy();
        }
    delete iNodes;
    }

EXPORT_C CDigViewNode* CDigViewGraph::FindNodeWithViewId(TUid aViewId) const
    {
    if (aViewId != KNullUid)
        {
        TInt count = iNodes->Count();
        while (count-- > 0)
            {
            CDigViewNode* node = iNodes->At(count);
            if (node->iViewId == aViewId)
                return node;
            }
        }
    return NULL;
    }

EXPORT_C void CDigViewGraph::ModifyViewGraphL(TResourceReader& aResReader)
    {
    CDigViewNodeArray* nodes = CreateUnlinkedNodesFromResourceL(aResReader);
    // The nodes of the array are not cleaned up by design, only the array
    // holding them. The node cleanup is handled in MergeNodesL.
    CleanupStack::PushL(nodes); 
    MergeNodesL(*nodes); // The ownership of the array's nodes is taken here
    CleanupStack::PopAndDestroy(nodes);

    LinkNodesWithTransitions();
    }

/**
 * Creates a new view node array from resource file.
 *
 * @param aResReader containing DIG_VIEW_GRAPH resource
 */
CDigViewGraph::CDigViewNodeArray* CDigViewGraph::
        CreateUnlinkedNodesFromResourceL(TResourceReader& aResReader)
    {
    TInt count = aResReader.ReadInt16();
    CDigViewNodeArray* nodes = new (ELeave) CDigViewNodeArray(1);
    CleanupStack::PushL(TCleanupItem(CleanupResetAndDestroy,nodes));
    if (count > 1)
        {
        nodes->SetReserveL(count);
        }
    
    while (count-- > 0)
        {            
        CDigViewNode* node = new(ELeave) CDigViewNode;
        CleanupStack::PushL(node);
        
        // DIG_VIEW_NODE
        node->iViewId.iUid = aResReader.ReadInt32();
        node->iDefaultPrevViewId.iUid = aResReader.ReadInt32(); 
        node->iDefaultPreviousNode = NULL;
        node->iPreviousNode = NULL;        
        node->iExitNode = aResReader.ReadInt8();
        
        TInt transCount = aResReader.ReadInt16(); // transitions[]
        node->iTransitions.SetReserveL(transCount);
        while (transCount-- > 0)
            {
            // DIG_VIEW_TRANSITION
            TDigViewTransition trans;
            trans.iEvent = aResReader.ReadInt32();            
            trans.iTargetViewId.iUid = aResReader.ReadInt32();
            trans.iNode = NULL;
            node->iTransitions.AppendL(trans);
            }        
        node->iAdditionalResId = aResReader.ReadInt32();

        nodes->AppendL(node);
        CleanupStack::Pop();
        }
    CleanupStack::Pop(nodes);
    return nodes;
    }   

/**
 * Links nodes with transitions.
 */
void CDigViewGraph::LinkNodesWithTransitions()
    {
    for (TInt i(0); i < iNodes->Count(); i++)
        {
        CDigViewNode* node = iNodes->At(i);
        node->iDefaultPreviousNode = FindNodeWithViewId
                (node->iDefaultPrevViewId);
        TInt transCount = node->iTransitions.Count();
        while (transCount-- > 0)
            {
            TDigViewTransition& trans = node->iTransitions.At(transCount);
            trans.iNode = FindNodeWithViewId(trans.iTargetViewId);
            }
        }
    }

/**
 * Merges two node arrays, iNode and aChangedNodes. 
 * Handles also destruction of nodes existing in aChangedNodes.
 *
 * @param aChangedNodes array to be merged with iNode
 */
void CDigViewGraph::MergeNodesL(CDigViewNodeArray& aChangedNodes)
    {
    __ASSERT_DEBUG(iNodes != &aChangedNodes, Panic(EPanicPre_MergeNodesL));

    for ( TInt j = aChangedNodes.Count()-1; j >= 0; --j )
        {
        // Changed node has to be destroyed if not appended
        CDigViewNode* changedNode = aChangedNodes.At(j);
        CDigViewNode* node = FindNodeWithViewId(changedNode->ViewId());
        if (node)
            {
            // The changedNode is not in cleanupstack yet,
            // @see CDigViewGraph::ModifyViewGraphL
            CleanupStack::PushL(changedNode);
            node->MergeL(*changedNode);
            aChangedNodes.Delete(j);
            CleanupStack::PopAndDestroy(changedNode);
            }
        else
            {
            // The changedNode is not in cleanupstack yet,
            // @see CDigViewGraph::ModifyViewGraphL
            CleanupStack::PushL(changedNode);
            iNodes->AppendL(changedNode);
            CleanupStack::Pop(changedNode);
            }
        }
    }


//  End of File