/*

* Copyright (c) 2008 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:   ?Description

*

*/

#include <uiacceltk/HuiCanvasVisual.h>

#include <alfwindowstructs.h>

#include "huiwscanvascommands.h"

#include "alfnodes.h"

#include "alfhierarchymodel.h"

#include "alfstreamerserver.h"

#include "alfwindowmanager.h"

#include "alfwindow.h"

#include "alfwindowdata.h"

#ifdef ALF_DEBUG_PRINT_NODE_INFO

    #define _ALF_LOGGING

    #include "alflogger.h"

    #undef _ALF_LOGGING

#else

    #include "alflogger.h"

#endif

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

// Constructor

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

//

CAlfNode::CAlfNode( ) :  

    iVisible( ETrue )

    {

    }

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

// ConstructL

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

//

void CAlfNode::ConstructL( CAlfHierarchyModel* aModel, RMemReadStream* aStream  )

    {

    iModel = aModel;

    iId = aStream->ReadInt32L();

    }

void CAlfNode::SetTracking( TBool aValue )

    {

    iTrackNode = aValue;

    if ( iWindow )

        {

        iWindow->SetNodeTracking( aValue );

        }

    }

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

// OrphanMe

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

//

CAlfNode* CAlfNode::OrphanMe()

    {

    __ALFLOGSTRING1("CAlfNode::OrphanMe %d", iId);

    // Parent node has been deleted. Orphan the node: remove the parent/sibling relationship.

    CAlfNode* sibling = iSibling;

    iSibling = NULL;

    iParent = NULL;

    return sibling;

    }

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

// ResolveParentL

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

//

void CAlfNode::ResolveParent( TUint32 aParentId, TInt aMyId )

    {

    CAlfNode* tmp = iModel->FindNode( aParentId );

    if ( tmp )

        {

        // 1. set parent, if there is one (root node is the only exception )

        iParent = tmp;

        // Possible sprite, textcursor, anim and child windows have different lists on the node

        switch( iType )

            {

            default:

                {

                SetFirstChild();

                break;

                }

            case MWsWindowTreeNode::EWinTreeNodeAnim:

                {

                SetFirstAnim();

                break;

                }

            case MWsWindowTreeNode::EWinTreeNodeSprite:

                {

                SetFirstSprite();

                break;

                }

            case MWsWindowTreeNode::EWinTreeNodeStandardTextCursor:

                {

                ASSERT( !iParent->iTextCursor );

                __ALFLOGSTRING1("parent->iTextCursor %d", iParent->iTextCursor );

                iParent->iTextCursor = (CAlfNodeTextCursor*)this;

                __ALFLOGSTRING1("parent->iTextCursor %d", iParent->iTextCursor );

                break;

                }

            }

        } 

    iId = aMyId;

    iModel->InsertNode( iId, this );

    ASSERT( iParent != NULL || iType == MWsWindowTreeNode::EWinTreeNodeRoot);

    if ( iType == MWsWindowTreeNode::EWinTreeNodeGroup )

        {

        iGroupId = iId;

        }

    else

        {

        iGroupId = FindParentGroup();

        }

    }

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

// SetFirstChild

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

//

void CAlfNode::SetFirstChild()

    {

    if ( iParent->iChild )

        {

        // pass over the previous first child and make it my sibling

        iSibling = iParent->iChild;

        }

    // jealously make me the first child

    iParent->iChild = this;

    }

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

// SetFirstChild

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

//

void CAlfNode::SetFirstAnim()

    {

    if ( iParent->iAnimChild )

        {

        // pass over the previous first child and make it my sibling

        iSibling = iParent->iAnimChild;

        }

    // jealously make me the first child

    iParent->iAnimChild = (CAlfNodeAnim*)this;

    }

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

// SetFirstChild

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

//

void CAlfNode::SetFirstSprite()

    {

    if ( iParent->iSpriteChild )

        {

        // pass over the previous first child and make it my sibling

        iSibling = iParent->iSpriteChild;

        }

    // jealously make me the first child

    iParent->iSpriteChild = (CAlfNodeSprite*)this;

    }

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

// FindParentGroup

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

//

TUint32 CAlfNode::FindParentGroup()

    {

    // go back in parents, until a group node is found. return its id.

    if ( iType == MWsWindowTreeNode::EWinTreeNodeSprite )

        {

        if ( iParent->iType == MWsWindowTreeNode::EWinTreeNodeRoot )

            {

            return 0;

            }

        else

            {

            return iParent->iId; // TODO: THIS IS ROOT, MIGHT NOT BE ALWAYS

            }

        }

    if ( iType == MWsWindowTreeNode::EWinTreeNodeRoot )

        {

        return 0;

        }

    ASSERT( iParent );

    CAlfNode* parent = iParent;

    while( parent->iType != MWsWindowTreeNode::EWinTreeNodeGroup )

        {

        parent = parent->iParent;

        }

    return parent->iId;

    }

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

// GetAllChildrenInGroup

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

//

void CAlfNode::GetAllChildrenInGroup( RPointerArray<CAlfNode>& aNodes, TUint32 aParentId )

	{

	if ( iParent->iType != MWsWindowTreeNode::EWinTreeNodeRoot)

		{

		CAlfNode* parentGroupNode = iModel->FindNode( aParentId );

		aNodes.Append(parentGroupNode); 

		for (CAlfNode::TIter iter( parentGroupNode ); iter.Current() != NULL;  iter.Next()) 

			{ 

			if (iter.Current() != parentGroupNode )

			    {

			    aNodes.Append(iter.Current());

			    }

			}

		}

	else

		{

		CAlfNode* child = iParent->iChild;

		do

			{

			aNodes.Append( child );

			child = child->iSibling; 

			}

		while( child );

		}

	}

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

// OrdinalPosition

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

//

TInt CAlfNode::OrdinalPosition()

    {

    //_LIT( KText, "OrdinalPosition");

    __ALFLOGSTRING("CAlfNode::OrdinalPosition");

    // __ALFLOGSTRING1("CAlfNode::OrdinalPosition - Looking for me %d", iId );

    RPointerArray<CAlfNode> nodes;

    TBool hasOrdinalPosition = ETrue;

    switch(iParent->iType)

        {

        case MWsWindowTreeNode::EWinTreeNodeClient:

            {

            CAlfNode* parentNode = iModel->FindNode( iParent->iId );

            __ASSERT_DEBUG(parentNode, USER_INVARIANT());

            if (parentNode  && parentNode->HasChildren())

                {

                // parent node is not added to the list

                // the anims, cursor and sprites directly in this parent are added to the list

                // siblings are added to the list, but their anims, cursors and sprites are not added

                TraverseNodeTree( parentNode, nodes, EFalse /* list all for this node */, EFalse /* dont add me */);

                }      

            break;

            }

        case MWsWindowTreeNode::EWinTreeNodeGroup:

            {

            TUint32 parentId = FindParentGroup();

            CAlfNode* parentGroupNode = iModel->FindNode( parentId );

            //__ALFLOGSTRING1("CAlfNode::OrdinalPosition - My parent %d", parentId );        

            CAlfNode* current;

            if ( parentGroupNode )

                {

                current = parentGroupNode->iChild;

                TraverseNodeTree( current, nodes, ETrue /* list siblings only */, ETrue /* add me */ );

                }      

            break;

            }

        case MWsWindowTreeNode::EWinTreeNodeRoot:

            {

            // Window group ordinal position calculation (their parent is EWinTreeNodeRoot)

            // Root node can have window groups, sprites and perhaps anims as children.

            // However, sprites & anims do not have ordinal position concept, but window groups do.

            // These sprites & anims are placed to floating sprite control group in alfbridge side 

            // and so they are excluded from ordinal position calculation.

            CAlfNode* child = iParent->iChild;

            if ( this == iParent->iTextCursor )

                {

                hasOrdinalPosition = EFalse;

                }

            if ( hasOrdinalPosition && iParent->iSpriteChild )

                {

                CAlfNode* animnode = iParent->iSpriteChild ;

                while ( animnode )

                    {

                    if ( this == animnode )

                        {

                        hasOrdinalPosition = EFalse;

                        break;

                        }

                    animnode = animnode->iSibling;

                    }

                }

            if( hasOrdinalPosition && iParent->iAnimChild )

                {

                CAlfNode* animnode = iParent->iAnimChild ;

                while ( animnode )

                    {

                    if ( this == animnode )

                        {

                        hasOrdinalPosition = EFalse;

                        break;

                        }                    

                    animnode = animnode->iSibling;

                    }

                }

            if ( child )

                {

                do

                    {

                    nodes.Append( child );

                    child = child->iSibling;

                    }

                while( child );

                }

            break;

            }

        }

    TInt ordinalPosition = -1;

    if ( hasOrdinalPosition )

        {        

        TInt i = nodes.Count();

        //   __ALFLOGSTRING1("Node count: %d", i );

        // return my position in the node array

        while( --i >=0 && nodes[i] != this ) 

            {

            }

        if ( i < 0)

            {

            __ALFLOGSTRING1("Node %d not found!", iId);

            __ASSERT_DEBUG( 0, USER_INVARIANT() );

            //USER_INVARIANT();

            }

        else

            {

            __ALFLOGSTRING2("Found %d at ordinal position %d!", nodes[i]->iId, i );

            }

        ordinalPosition = i;

        }

    nodes.Close();    

    return ordinalPosition;

    }

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

// CAlfNode::TraverseNodeTree

// Traverse through node tree and fill node array 

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

//

void CAlfNode::TraverseNodeTree( CAlfNode* node,  RPointerArray<CAlfNode>& nodes, TBool aTraverseOnlySiblings, TBool aAddMe)

    {

    // Exit if we've already finished walking the tree.

    if ( node == NULL) 

        { 

        return;

        }

        {

                {

                }

            {

            }

        }

    }

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

// OrdinalPosition

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

//

#ifdef ALF_DEBUG_PRINT_NODE_INFO

TInt CAlfNode::PrintOrdinalPositions()

    {

    TInt i = 0;

    __ALFLOGSTRING("CAlfNode::PrintOrdinalPositions - ");

    RPointerArray<CAlfNode> nodes;

    if ( iParent->iType != MWsWindowTreeNode::EWinTreeNodeRoot)

        {

        TUint32 parentId = FindParentGroup();

        CAlfNode* parentGroupNode = iModel->FindNode( parentId );

        for (CAlfNode::TIter iter( parentGroupNode ); iter.Current() != NULL;  iter.Next()) 

            { 

            nodes.Append(iter.Current()); 

            }

        }

    else

        {

        CAlfNode* child = iParent->iChild;

        do

            {

            nodes.Append( child );

            }

        while( ( child = child->iSibling) != NULL );

        }

    i = nodes.Count();

    // return my position in the node arr

    TInt groupLevel = 0;

    while( --i >=0  ) 

    	{

    	CAlfNodeVisual* node = (CAlfNodeVisual*)nodes[i];

    	_LIT(KText, "PrintOrdinalPositions");

    	// PrintInfo( i, node, TPtrC(KText), 0);

    	}

    nodes.Close();    

    return i;

    }

void CAlfNode::PrintInfo( CAlfNode* aNode, TInt aHighLightNode, TInt aDepth)

    {

    HBufC16* buffer = HBufC16::NewL(256);

    TPtr iDebugText = buffer->Des();

    iDebugText.Format( _L(""));

    MWsWindowTreeNode::TType type = aNode->Type();

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

        {

        iDebugText.AppendFormat(_L(" "));

        }

    // Print the parent id in front of every children. For debugging the debugging code...

    //CAlfNode* parent = aNode->iParent;

    //if (parent)

    //	{

	//	iDebugText.AppendFormat(_L("[0x%x] "), parent->iId);

    //	}

    if ( aHighLightNode == aNode->iId )

        {

        iDebugText.AppendFormat( _L("\n-- MODIFIED NODE -- \n"));

        }

    switch ( type )

        {