/*

* Copyright (c) 2002-2005 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:  Implementation of XCFW Content tree

*

*/

// INCLUDE FILES

#include    "xcfwtree.h"

#include    "xcfwnode.h"

#include    "xcfwpanic.h"

// MACROS

//Helper macro to cast MXCFWNode pointers to CXCFWNode

#define WRAPNODE( aNode ) static_cast<CXCFWNode*>( aNode )

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

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

// CXCFWTree::CXCFWTree

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CXCFWTree::CXCFWTree()

    {

    }

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

// CXCFWTree::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CXCFWTree::ConstructL()

    {

    }

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

// CXCFWTree::NewL

// Two-phased constructor.

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

//

EXPORT_C CXCFWTree* CXCFWTree::NewL()

    {

    CXCFWTree* self = new( ELeave ) CXCFWTree;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

EXPORT_C CXCFWTree::~CXCFWTree()

    {

    //delete dtd name buffer

    delete iDTDName;

    //delete node array    

    iNodeList.ResetAndDestroy();

    iNodeList.Close();

    //reset node array for client

    iNodeListForClient.Reset();

    iNodeListForClient.Close();

    //Null root pointer (owned in the iNodeList array)

    iRoot = NULL;

    }

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

// CXCFWTree::AddNodeL

// this overload is for adding node under certain parent before certain child

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

//

EXPORT_C MXCFWNode* CXCFWTree::AddNodeL(

    CGECOObjectBase* aData, 

    MXCFWNode* aParent, 

    MXCFWNode* aInsertBefore )

    {

    CleanupStack::PushL( aData );

    __ASSERT_LEAVE( aParent && aData && aInsertBefore &&

        aData->TypeIdentifier() != iRoot->Data()->TypeIdentifier() &&

        aInsertBefore->Parent() == aParent, KErrArgument );

    __ASSERT_LEAVE( !iLocked, KErrAccessDenied );

    //Create new node and add to arrays.

    CXCFWNode* nodeToAdd = CXCFWNode::NewL( aData );

    CleanupStack::Pop( aData );

    CleanupStack::PushL( nodeToAdd );

    User::LeaveIfError( iNodeList.Append( nodeToAdd ) );

    CleanupStack::Pop( nodeToAdd );

    //update node references

    nodeToAdd->SetParent( aParent );

    nodeToAdd->SetNextSibling( aInsertBefore );

    nodeToAdd->SetPrevSibling( aInsertBefore->PrevSibling() );

    //if "insert before" -node has previous sibling, update that

    if ( aInsertBefore->PrevSibling() )

        {

        WRAPNODE( aInsertBefore->PrevSibling() )->SetNextSibling( nodeToAdd );

        }

    //set previous sibling

    WRAPNODE( aInsertBefore )->SetPrevSibling( nodeToAdd );            

    if( aParent->FirstChild() == aInsertBefore )

        {

        WRAPNODE( aParent )->SetFirstChild( nodeToAdd );            

        }

    //Set client list dirty => will be updated on next Nodes() request.

    iClientListDirty = ETrue;

    return nodeToAdd;

    }

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

// CXCFWTree::AddNodeL

// this overload is for adding node under certain parent as last child

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

//

EXPORT_C MXCFWNode* CXCFWTree::AddNodeL(

    CGECOObjectBase* aData, 

    MXCFWNode* aParent )

    {

    CleanupStack::PushL( aData );

    //Legality checks

    __ASSERT_LEAVE( aParent && aData && 

         aData->TypeIdentifier() != iRoot->Data()->TypeIdentifier(),

         KErrArgument );

    __ASSERT_LEAVE( !iLocked, KErrAccessDenied );

    //Create new node and add to arrays

    CXCFWNode* nodeToAdd = CXCFWNode::NewL( aData );

    CleanupStack::Pop( aData );

    CleanupStack::PushL( nodeToAdd );

    User::LeaveIfError( iNodeList.Append( nodeToAdd ) );

    CleanupStack::Pop( nodeToAdd );

    //set parent for new node

    nodeToAdd->SetParent( aParent );

    //if parent has a last child

    if( aParent->LastChild() )

        {

        nodeToAdd->SetPrevSibling( aParent->LastChild() );

        WRAPNODE( aParent->LastChild() )->SetNextSibling( nodeToAdd );

        }

    else

        {

        WRAPNODE( aParent )->SetFirstChild( nodeToAdd );

        }

    //update last child of the parent        

    WRAPNODE( aParent )->SetLastChild( nodeToAdd );        

    //Set client list dirty => will be updated on next Nodes() request.

    iClientListDirty = ETrue;

    return nodeToAdd;        

    }

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

// CXCFWTree::AddNodeL

// this overload is for adding root node only

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

//

EXPORT_C MXCFWNode* CXCFWTree::AddNodeL(

    CGECOObjectBase* aData )

    {

    CleanupStack::PushL( aData );

    //if we already have a root, this is illegal

    __ASSERT_LEAVE( iRoot==NULL, KErrAlreadyExists );

    __ASSERT_LEAVE( !iLocked, KErrAccessDenied );

    //Create root node and add to arrays

    CXCFWNode* nodeToAdd = CXCFWNode::NewL( aData );

    CleanupStack::Pop( aData );

    CleanupStack::PushL( nodeToAdd );

    User::LeaveIfError( iNodeList.Append( nodeToAdd ) );

    CleanupStack::Pop( nodeToAdd );

    //Set internal root member.

    iRoot = nodeToAdd;

    nodeToAdd = NULL;

    //Set client list dirty => will be updated on next Nodes() request.

    iClientListDirty = ETrue;

    return iRoot;

    }

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

// CXCFWTree::GetChildNodesL

// Put child nodes of the given parent to the given array

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

//

EXPORT_C void CXCFWTree::GetChildNodesL(

    MXCFWNode* aParent, 

    RNodeArray& aNodeList)

    {

    __ASSERT_LEAVE( aParent != NULL, KErrArgument );

    MXCFWNode* pointer = aParent->FirstChild();

    while ( pointer )

        {

        User::LeaveIfError( aNodeList.Append( pointer ) );

        pointer = pointer->NextSibling();

        }

    }

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

// CXCFWTree::GetNodesOfTypeL

// Put nodes that have dataobject of given type to given array.

// In case of recursion, pre-order recursion is used

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

//

EXPORT_C void CXCFWTree::GetNodesOfTypeL( 

    const TDesC& aType, 

    RNodeArray& aNodeList, 

    MXCFWNode* aParent, 

    TBool aRecursive )

    {

    __ASSERT_LEAVE( aParent != NULL, KErrArgument );

    MXCFWNode* pointer = aParent->FirstChild();

    while ( pointer )

        {

        if ( pointer->Data()->TypeIdentifier().Compare( aType ) == 0 )

            {

            User::LeaveIfError( aNodeList.Append( pointer ) );                

            }

        if ( aRecursive )

            {

            GetNodesOfTypeL( aType, aNodeList, pointer, aRecursive );                

            }

        pointer = pointer->NextSibling();

        }

    }

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

// CXCFWTree::MoveNodeL

// Moves a node in tree and updates the relative nodes in both original and

// new location.

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

//

EXPORT_C void CXCFWTree::MoveNodeL(

    MXCFWNode* aNodeToMove, 

    MXCFWNode* aNewParent, 

    MXCFWNode* aInsertBefore )

    {

    // assure parameter legality

    __ASSERT_LEAVE( aNodeToMove && aNewParent && 

        aNodeToMove != iRoot && aInsertBefore != iRoot &&

        aNodeToMove != aNewParent,

        KErrArgument );            

    __ASSERT_LEAVE( !iLocked, KErrAccessDenied );

    //if "insert before" node is child node of the given parent, move is illegal

    if ( aInsertBefore && aInsertBefore->Parent() != aNewParent )

        {

        User::Leave( KErrArgument );            

        }

    MXCFWNode* check = aNewParent->Parent();

    while ( check )

        {

        //if user tries to move a node under itself (it is among the parents 

        // of the given new parent) we'll leave

        if ( check == aNodeToMove )

            {

            User::Leave( KErrArgument );

            }

        check = check->Parent();

        }

    check = NULL;

    //first update old parent if necessary

    if ( aNodeToMove->Parent()->FirstChild() == aNodeToMove )

        {

        WRAPNODE( aNodeToMove->Parent() )->SetFirstChild( 

                                aNodeToMove->NextSibling() );            

        }

    if ( aNodeToMove->Parent()->LastChild() == aNodeToMove )

        {

        WRAPNODE( aNodeToMove->Parent() )->SetLastChild(

                                   aNodeToMove->PrevSibling() );            

        }

    //update old siblings

    if ( aNodeToMove->PrevSibling() )

        {

        WRAPNODE( aNodeToMove->PrevSibling())->SetNextSibling(

                                aNodeToMove->NextSibling() );            

        }

    if ( aNodeToMove->NextSibling() )

        {

        WRAPNODE( aNodeToMove->NextSibling() )->SetPrevSibling( 

                                aNodeToMove->PrevSibling() );            

        }

    //set new parent:

    WRAPNODE( aNodeToMove )->SetParent( aNewParent );

    //update new siblings

    if ( aInsertBefore )

        {

        //if "insert before" -node has a sibling before it, we update that

        if ( aInsertBefore->PrevSibling() )

            {

            WRAPNODE( aInsertBefore->PrevSibling() )->SetNextSibling(

                                aNodeToMove );                

            }

        else 

        //no previous sibling => insertbefore is the first child of new parent

            {

            WRAPNODE( aNewParent )->SetFirstChild( aNodeToMove );                

            }

        WRAPNODE( aNodeToMove )->SetPrevSibling( aInsertBefore->PrevSibling() );

        WRAPNODE( aNodeToMove )->SetNextSibling( aInsertBefore );

        WRAPNODE( aInsertBefore )->SetPrevSibling( aNodeToMove );

        }

    else

        {

        //if new parent had children

        if ( aNewParent->LastChild() )

            {

            WRAPNODE( aNewParent->LastChild() )->SetNextSibling( aNodeToMove );

            WRAPNODE( aNodeToMove )->SetPrevSibling( aNewParent->LastChild() );

            WRAPNODE( aNewParent )->SetLastChild( aNodeToMove );

            WRAPNODE( aNodeToMove )->SetNextSibling(NULL);

            }

        else //no children before

            {

            WRAPNODE( aNewParent )->SetFirstChild( aNodeToMove );

            WRAPNODE( aNewParent )->SetLastChild( aNodeToMove );

            WRAPNODE( aNodeToMove )->SetPrevSibling( NULL );

            WRAPNODE( aNodeToMove )->SetNextSibling( NULL );            

            }

        }

    //Set client list dirty => will be updated on next Nodes() request.

    iClientListDirty = ETrue;

    }

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

// CXCFWTree::Nodes

// return tree nodes as array of MXCFWNode pointers

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

//

EXPORT_C RNodeArray& CXCFWTree::Nodes()

    {

    //see if we should update the MXCFWNode array to reflect the new

    if ( iClientListDirty )

        {

        if ( iNodeListForClient.Count() > 0 )

            {

            iNodeListForClient.Reset();

            }

        TInt count = iNodeList.Count();

        for ( TInt i = 0; i < count; i++ )

            {

            iNodeListForClient.Append( (MXCFWNode*)iNodeList[i] );           

            }

        iClientListDirty = EFalse;

        }

    return iNodeListForClient;

    }

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

// CXCFWTree::RemoveNodeL

// Removes a node from tree by updating all relative nodes and removing from

// arrays.

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

//

EXPORT_C void CXCFWTree::RemoveNodeL(

    MXCFWNode* aNodeToRemove )

    {

    __ASSERT_LEAVE( aNodeToRemove != NULL, KErrArgument );

    __ASSERT_LEAVE( !iLocked, KErrAccessDenied );

    if ( iRoot != aNodeToRemove )

        {

        //update related nodes before removal, unless removing root node.

        if ( aNodeToRemove->PrevSibling() )

            {

            WRAPNODE( aNodeToRemove->PrevSibling() )->SetNextSibling(

                                    aNodeToRemove->NextSibling() );            

            }

        if ( aNodeToRemove->NextSibling() )

            {

            WRAPNODE( aNodeToRemove->NextSibling() )->SetPrevSibling( 

                                    aNodeToRemove->PrevSibling() );    

            }

        if ( aNodeToRemove->Parent()->FirstChild() == aNodeToRemove )

            {

            WRAPNODE( aNodeToRemove->Parent() )->SetFirstChild( 

                                    aNodeToRemove->NextSibling() );            

            }

        if ( aNodeToRemove->Parent()->LastChild() == aNodeToRemove )

            {

            WRAPNODE( aNodeToRemove->Parent() )->SetLastChild( 

                                    aNodeToRemove->PrevSibling() );            

            }

        }

    else

        {

        //root was removed.

        iRoot = NULL;            

        }

    //Set client list dirty => will be updated on next Nodes() request.

    iClientListDirty = ETrue;

    RemoveNodeRecursiveL( aNodeToRemove );

    }

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

// CXCFWTree::RemoveFromArray

// Removes node pointer from CXCFWNode and MXCFWNode pointer arrays. 

// Deletes from CXCFWNode array as well.

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

//

void CXCFWTree::RemoveFromNodeList(

    MXCFWNode* aNode )

    {

    //remove node from the pointer array.

    TInt i = iNodeList.Count() - 1 ;

    for ( ;i>=0 && aNode != iNodeList[i] ; i-- ){}

    if ( i>=0 )

        {

        //delete object

        delete iNodeList[i];

        //remove from pointer arrays.

        iNodeList.Remove(i);

        }

    }

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

// CXCFWTree::RemoveNodeRecursiveL

// Post-order recursion is used to make sure that no orhpan nodes are left

// floating.

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

//

void CXCFWTree::RemoveNodeRecursiveL(

    MXCFWNode* aNode )

    {

    __ASSERT_LEAVE ( aNode != NULL, KErrArgument );

    MXCFWNode* pointer = aNode->FirstChild();

    while ( pointer )

        {

        MXCFWNode* temp = pointer->NextSibling();

        RemoveNodeRecursiveL( pointer );

        pointer = temp;            

        }

    RemoveFromNodeList( aNode );

    }

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

// CXCFWTree::Root

// Returns MXCFWNode pointer to root node.

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

//

EXPORT_C MXCFWNode* CXCFWTree::Root()

    {

    return iRoot;

    }

EXPORT_C void CXCFWTree::SetLocked( TBool aLockStatus )

    {

    iLocked = aLockStatus;

    }

EXPORT_C TBool CXCFWTree::IsLocked()

    {