/*

* 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:    Window to a list of objects

*

*/

#include "glxlistwindow.h"

#include "glxpanic.h"

#include "glxlistutils.h" //for GlxListUtils

#include <glxtracer.h>                 //For logging

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

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

// CGlxDataWindow 

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

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

//

class CGlxDataWindow : public CBase 

    {

    friend class TGlxWindowIterator;

public:

    /** Destructor*/

    ~CGlxDataWindow()

        {

        iObjects.Close();

        }

    /** Destroy contents of the window */

    void Destroy()

        {

        iObjects.ResetAndDestroy();

        }

    /** Reserve max window size */

    inline void ReserveL( TInt aMaxCount )

        {

        iObjects.ReserveL( aMaxCount );

        }

    /** Preparet the window to accept items */

        {

        __TEST_INVARIANT;

        iTotalSize = aTotalSize;    

        // use GlxListUtils::NormalizedIndex instead of Normalize to avoid 

        // execution-order dependency to the setting of iTotalSize

        iWindowStartIndex = GlxListUtils::NormalizedIndex( aRange.iStartIndex, iTotalSize );

        // all existing pointers in the array are NULL, as they have been 

        // set so by PopulateExistingAndUnuseOld

        // add sufficient number of new null pointers

        for ( TInt i = iObjects.Count(); i < aRange.iLength; i++ ) 

            {

            // Append cannot fail since reservation has been made

            }

        // remove unnecessary pointers

        for ( TInt i = iObjects.Count() - 1; i >= aRange.iLength; i-- )

            {

            iObjects.Remove( i );

            }

        __TEST_INVARIANT;

        }

    /** @return an iterator that can iterate throught the items in window */

    inline TGlxWindowIterator Iterator() const

        {

        return TGlxWindowIterator( *this );

        }

    /** @return whether the list index is within range */

    inline TBool InRange( TInt aListIndex ) const

        {

        return KErrNotFound != WindowIndex( aListIndex );

        }

    inline CBase*& operator[] ( TInt aListIndex )

        {

        return iObjects[ WindowIndex( aListIndex ) ];

        }

    /** @return the length of the window */

    inline TInt Size() const

        {

        return iObjects.Count();

        }

    /** @return the total length of the list */

    inline TInt TotalSize() const

        {

        return iTotalSize;

        }

private:        

    /** convert a window index to list index */

    TInt ListIndex( TInt aWindowIndex ) const

        {

    	__ASSERT_DEBUG( aWindowIndex >= 0 && aWindowIndex < Size(), Panic( EGlxPanicIllegalArgument ) ); 

        return Normalize( aWindowIndex + iWindowStartIndex );

    	}

    /** convert a list index to window index */

    /// @todo Make this private

    TInt WindowIndex( TInt aListIndex ) const

        {

        if ( KErrNotFound == aListIndex )

            {

            return KErrNotFound;

            }

    	__ASSERT_DEBUG( aListIndex >= 0 && aListIndex < iTotalSize, Panic( EGlxPanicIllegalArgument ) );

    	// Convert the list index to a window index

    	TInt windowIndex = Normalize( aListIndex - iWindowStartIndex );

    	if ( windowIndex >= Size() ) 

    		{

    		return KErrNotFound; // Does not fit to the window

    		}

    	return windowIndex; 

    	}

    /** Normalise index to list length */

    inline TInt Normalize( TInt aIndex ) const

        {

        return GlxListUtils::NormalizedIndex( aIndex, iTotalSize );

        }

    /** Test state */

    void __DbgTestInvariant() const

        {

        __ASSERT_DEBUG(iTotalSize >= 0 && iTotalSize < 50000, Panic(EGlxPanicIllegalState)); // Sanity check

        __ASSERT_DEBUG(iObjects.Count() <= iTotalSize, Panic(EGlxPanicIllegalState));

        }

private:   

    /// Full size of the list

	TInt iTotalSize;

	/// Index of the first object in iWindow in the list,

	/// i.e., the list index from which the window starts from

	TInt iWindowStartIndex;

    /// List of objects in the window, starting from iWindowStartIndex

    RPointerArray< CBase > iObjects;

    };

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

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

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

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

// Constructor

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

TGlxWindowIterator::TGlxWindowIterator( const CGlxDataWindow& aWindow )    

    {

    TRACER("TGlxWindowIterator::TGlxWindowIterator");

    iWindow = &aWindow;

    iWindowIndex = 0;

    }

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

// Constructor

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

EXPORT_C TGlxWindowIterator::TGlxWindowIterator( const TGlxWindowIterator& aIterator ) 

    {

    TRACER("TGlxWindowIterator::TGlxWindowIterator");

    iWindow = aIterator.iWindow;

    iWindowIndex = aIterator.iWindowIndex;

    }

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

// ++

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

EXPORT_C TInt TGlxWindowIterator::operator++( TInt ) 

    {

    TRACER("TGlxWindowIterator::operator++");

    if ( iWindowIndex == iWindow->iObjects.Count() ) 

        {

        return KErrNotFound;

        }

    return iWindow->ListIndex( iWindowIndex++ );

    }

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

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

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

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

// TChange

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

//    

CGlxListWindow::TChange::TChange( TInt aNewFocusIndex, TInt aNewTotalSize, TChangeType aChangeType, 

        TInt aFirstChangedIndex, TInt aLastChangedIndex )   

    {

    TRACER("TChange::Default Constructor");

    iNewFocusIndex = aNewFocusIndex;

    iNewTotalSize = aNewTotalSize;

    iChangeType = aChangeType;

    iFirstChangedIndex = aFirstChangedIndex;

    iLastChangedIndex = aLastChangedIndex;

    }

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

// Constructor

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

//

EXPORT_C CGlxListWindow::CGlxListWindow( MGlxWindowObjectFactory& aObjectFactory ) 

        : iObjectFactory( aObjectFactory )

	{

	TRACER("CGlxListWindow::Default Constructor");

    iFocusIndex = KErrNotFound; // No items, hence no focus

	}

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

// ConstructL

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

//

EXPORT_C void CGlxListWindow::ConstructL() 

	{

	TRACER("CGlxListWindow::ConstructL");

    iWorkingWindow = new (ELeave) CGlxDataWindow;

    iWindow = new (ELeave) CGlxDataWindow;

    // default range offsets are 0, 0, which means that only the focused item

    // in in the window by default. Create an object for the focus. This

    // makes it optional to call SetRangeOffsetsL if range remains 0,0

    iUnusedObjects.AppendL( iObjectFactory.CreateObjectL() );

	}

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

// Destructor

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

//

EXPORT_C CGlxListWindow::~CGlxListWindow() 

	{

	TRACER("CGlxListWindow::Destructor");

    // objects may exist in either iWindow or object pool (iUnusedObjects)

    if ( iWindow )

        {

        // this call could be removed, if could call Cleanup here

        // currently deriving classes implement CleanupObject, so calling it

        // here is not possible => requires a different object as factory

        iWindow->Destroy(); 

        delete iWindow;

        }

    iUnusedObjects.ResetAndDestroy();

    // the working window does not own anything

    delete iWorkingWindow;

	}

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

// Cleans up remaining objects in the window

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

//

	{

    // make the window empty. this will clean up all remaining objects.

	}

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

// SetRangeOffsetsL

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

// DEPRECATED

EXPORT_C void CGlxListWindow::SetRangeOffsetsL( TInt aFrontOffset, TInt aRearOffset ) 

	{

	TRACER("CGlxListWindow::SetRangeOffsetsL");

    SetRangeOffsetsL( iFocusIndex, iWindow->TotalSize(), aFrontOffset, aRearOffset );

	}

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

// SetRangeOffsetsL

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

//

EXPORT_C void CGlxListWindow::SetRangeOffsetsL( TInt aFocusIndex, 

        TInt aTotalSize, TInt aFrontOffset, TInt aRearOffset ) 

	{

	TRACER("CGlxListWindow::SetRangeOffsetsL");

	__ASSERT_DEBUG( aFrontOffset <= 0 && aRearOffset >= 0, Panic( EGlxPanicIllegalArgument ) );

	__ASSERT_DEBUG( ( 0 <= aFocusIndex && aFocusIndex < aTotalSize ) ||

                    ( KErrNotFound == aFocusIndex && 0 == aTotalSize ), 

                    Panic( EGlxPanicIllegalArgument ) );

	iFrontOffset = aFrontOffset;

	iRearOffset = aRearOffset;

    // only ever expand the range. there is no use case to do the otherwise, 

    // so don't bother optimising that case by freeing unnecessary objects.

    // all or no objects may be in use at any time - reserve max count in all arrays

    TInt maxObjectCount = aRearOffset - aFrontOffset + 1;

    iWorkingWindow->ReserveL( maxObjectCount );

    iWindow->ReserveL( maxObjectCount );

    iUnusedObjects.ReserveL( maxObjectCount );

    // create enough new objects into the unused objects pool

    // objects are either in the main window or in the pool

    for ( TInt i = iWindow->Size() + iUnusedObjects.Count(); i < maxObjectCount; i++ )

        {

        // cannot fail since reservation made above

        }

	}

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

// Iterator

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

//

EXPORT_C TGlxWindowIterator CGlxListWindow::Iterator() const

    {

    TRACER("CGlxListWindow::Iterator");

    return iWindow->Iterator();

    }

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

// SetFocusIndexL

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

// DEPRICATED

	{

	}

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

// SetFocusIndexL

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

//

	{

	__ASSERT_DEBUG( ( 0 <= aFocusIndex && aFocusIndex < aTotalSize ) ||

                    ( KErrNotFound == aFocusIndex && 0 == aTotalSize ), 

                    Panic( EGlxPanicIllegalArgument ) );

    __TEST_INVARIANT;

    __TEST_INVARIANT;

	}

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

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

// DEPRICATED

	{

	TInt newItemCount = aLastNewIndex - aFirstNewIndex + 1;

	TInt newTotalSize = iWindow->TotalSize() + newItemCount;

	// Check if it is necessary to move focus

	TInt newFocusIndex = iFocusIndex;

	if ( KErrNotFound == newFocusIndex )

		{

		// List is empty, so set focus to the first item

		__ASSERT_DEBUG(iWindow->TotalSize() == 0, Panic(EGlxPanicIllegalState)); // Must have had an empty list to have no focus

		newFocusIndex = 0; 

		}

	else if (newFocusIndex >= aFirstNewIndex)

		{

		// Move focus, so that the focus stays on the same item that was 

		// focused before items were added

		newFocusIndex += newItemCount;

		}

	}

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

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

//

        TInt aTotalSize, TInt aFirstNewIndex, TInt aLastNewIndex ) 

	{

    __ASSERT_DEBUG( 0 <= aFirstNewIndex && aFirstNewIndex <= aLastNewIndex && 

                    aLastNewIndex < aTotalSize &&

                    0 <= aFocusIndex && aFocusIndex < aTotalSize,

                    Panic( EGlxPanicIllegalArgument ) ); 

    __TEST_INVARIANT;

        aFirstNewIndex, aLastNewIndex ) );

    __TEST_INVARIANT;

	}

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

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

// DEPRICATED

	{

	TInt itemsRemovedCount = aLastRemovedIndex - aFirstRemovedIndex + 1;

	TInt newTotalSize = iWindow->TotalSize() - itemsRemovedCount;

	TInt newFocusIndex = iFocusIndex;

	// check number of items left

	if (newTotalSize == 0)

	    {

	    // all items have been removed

	    newFocusIndex = KErrNotFound;

	    }

	else  // still some items in the list

	    {

	    // Focus should stay on the same item if possible. If not, it should

	    // go to the first previous item still existing. If none, it should go to 

	    // first (=first next) item.

        // @todo: Do not maintain focus index in this class, This is broken

	    // Update focus if the removal point was before	the focus

	    if (aFirstRemovedIndex <= newFocusIndex) 

	    	{

	    	TInt firstToFocusCount = newFocusIndex - aFirstRemovedIndex + 1;

	    	newFocusIndex -= Min(itemsRemovedCount, firstToFocusCount);

	    	if (newFocusIndex < 0)

	    		{

	    		newFocusIndex = 0;

	    		}

	    	}

	    }

	}	

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

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

//	

        TInt aTotalSize, TInt aFirstRemovedIndex, TInt aLastRemovedIndex ) 

	{

    __ASSERT_DEBUG( 0 <= aFirstRemovedIndex && aFirstRemovedIndex <= aLastRemovedIndex &&

                    ( ( 0 <= aFocusIndex && aFocusIndex < aTotalSize ) || 

                      ( KErrNotFound == aFocusIndex && aTotalSize == 0 ) ),

                    Panic( EGlxPanicIllegalArgument ) ); 

    __TEST_INVARIANT;

        aFirstRemovedIndex, aLastRemovedIndex ) );

    __TEST_INVARIANT;

	}	

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

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

//

	{

    // (in a list of:  |abcdefghijklm|

    // iWindow:        |----efghi----|

    // iWorkingWindow: undefined state

    // iUnusedObjects: XXX (3 objects, in reality only contains objects if list 

    //                      is shorter than max window length)

    // Prepare the working window to accept objects

    // iWindow:        |----efghi----|

    // iWorkingWindow: |------00000--|

    // iUnusedObjects: XXX 

    // move unused objects to pool, and reusable objects to working window

    // iWindow:        |----efghi----|

    // iWorkingWindow: |------ghi00--|

    // iUnusedObjects: XXXXX (2 objects added, used to be e and f)

    // set the current window to working window and vice versa.

    // do this before populating new items, since when the deriving class

    // is asked to set up the items, it is better to allow it to access the

    // objects from the window (only objects from main window can be accessed

    // externally)

    SwapWindows();

    iFocusIndex = aChange.iNewFocusIndex;