/*
* Copyright (c) 2008-2009 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:    ALF visual utilities
*
*/




// CLASS HEADER
#include "glxvisualutilities.h"

// EXTERNAL HEADERS
#include <uiacceltk/huicontrol.h>
#include <uiacceltk/huivisual.h>

namespace NGlxVisualUtilities
    {
    /**
     * TGlxVisualTransferCleanup
     * This class handles the awkward situation in visual ownership transfer
     * that some of the visuals are transferred to new parent and a leave occurs.
     * In leave case we need to undo the ownership transfer completely.
     * This class also removes the ownership from the old control in case
     * there was no leave.
     * @usage:
     * \code
     *      RArray<CHuiVisual*> allvisuals;
     *      TGlxVisualTransferCleanup cleanup( allvisuals );
     *       // set the parent to remove from to be the new one
     *      cleanup.iParentToRemoveFrom = aNewParent;
     *      CleanupClosePushL( cleanup );
     *      // start to append the visuals to the new parent
     *      // in case of leave they are removed from new parent
     *      RecurseAndTransferVisualsL( visualcleanup, aVisual, aNewParent );
     *      // set the parent to remove to be the old one
     *      cleanup.iParentToRemoveFrom = oldParent;
     *      // remove the item from cleanupstack,
     *      // this removes the visuals from their old parent 
     *      CleanupStack::PopAndDestroy( &cleanup );
     * \endcode
     */
    NONSHARABLE_CLASS( TGlxVisualTransferCleanup )
    	{
    	public:

            /**
    		 * Constructor.
    		 * @param aArray, the array of Visuals 
    		 * @param aOldParent, the old parent of visuals
    		 * @param aNewParent, the new parent for visuals
    		 */
    		inline TGlxVisualTransferCleanup( 
                RArray<CHuiVisual*>& aArray )
                : iArray( aArray )
    			{
                }

            /**
             * Close. Put this class to Cleanupstack with 
             * CleanupClosePushL so that this gets called in case of a leave
             */
            inline void Close()
                {
                // need to remove all visuals from the given parent
                // loop through all the CHuiVisuals
                for( TInt i = 0; i < iArray.Count(); ++i )
                    {
                    // remove from the given parent
                    iParentToRemoveFrom->Remove( iArray[ i ] );
                    }
                // reset the array
                iArray.Reset();
                }

            /// Ref: the parent where to remove
            MHuiVisualOwner* iParentToRemoveFrom;

        private: // Implementation

            /// Ref: the array containing all the visuals
            RArray<CHuiVisual*>& iArray; 

    	};

    /**
     * Recursive helper method to transfer the ownership of visuals
     * @param aVisualCleanup an array containing all visuals in the hierarchy
     * @param aVisual the visual to move to new control
     * @param aNewParent the new parent for the visual
     */
    void RecurseAndTransferVisualsL(
        RArray<CHuiVisual*>& aVisualCleanup,
        CHuiVisual& aVisual, CHuiControl& aNewParent )
        {
        // make room to the pointer so that we always succeed in appending
        // Note that we need to make room for one new item, thus count + 1
        aVisualCleanup.ReserveL( aVisualCleanup.Count() + 1 );
        // append us to the new parent, Note that for a while we are
        // owner by two controls but thats not a problem as the other parent 
        // is removed by either TGlxVisualTransferCleanup.Close() by CleanupStack
        // or destructor of TGlxVisualTransferCleanup and there is no other way
        // of getting out from this method (of course panic is ;)
        aNewParent.AppendL( &aVisual );
        // add us in the cleanuparray so that we can be removed from the 
        // new parent in case some of the following AppendLs leave
        // this does not fail as reserve was called so no AppendL needed
        aVisualCleanup.Append( &aVisual );
        // check if the visual has childs
        TInt childCount = aVisual.Count();
        // transfer all the childs
        while( childCount-- > 0 )
            {
            // get the child
            CHuiVisual& childVisual = aVisual.Visual( childCount );
            // call transfer recursively on the child
            RecurseAndTransferVisualsL( 
                aVisualCleanup, childVisual, aNewParent );
            }
        }

    // -------------------------------------------------------------------------
	// TransferVisualsL
	// -------------------------------------------------------------------------
    EXPORT_C void TransferVisualsL( 
        CHuiVisual& aVisual, CHuiControl& aNewParent )
        {
        // check if parent is already correct
        if( &( aVisual.Owner() ) == 
            static_cast< MHuiVisualOwner* >( &aNewParent ) )
            {
            // nothing else to be done
            return;
            }
        // create an array for visual pointers on the stack
        RArray< CHuiVisual* > visualcleanup;
        // create the cleanup item from stack as well
        TGlxVisualTransferCleanup removeParent( visualcleanup );
        // set the parent to remove from to be the new one
        removeParent.iParentToRemoveFrom = &aNewParent;
        // need to remember the old parent
        MHuiVisualOwner* oldParent = &( aVisual.Owner() );
        // put it to cleanupstack so that close gets called in case of leave
        CleanupClosePushL( removeParent );
        // run the recursive loop, if it leaves the visuals are removed from
        // new parent by the Close method of cleanParents
        RecurseAndTransferVisualsL( visualcleanup, aVisual, aNewParent );
        // set the parent to remove to be the old one
        removeParent.iParentToRemoveFrom = oldParent;
        // remove the item from cleanupstack,
        // this removes the visuals from the old parent 
        CleanupStack::PopAndDestroy( &removeParent );
        // close the array
        visualcleanup.Close();
        }
    }