diff -r 4ea6f81c838a -r 0e9bb658ef58 widgetmodel/alfwidgetmodel/src/alfrecyclinggridelementimpl.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/widgetmodel/alfwidgetmodel/src/alfrecyclinggridelementimpl.cpp	Wed Sep 01 12:23:18 2010 +0100
@@ -0,0 +1,755 @@
+/*
+* Copyright (c) 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:   Private Implementation file for AlfRecyclingGridElement.
+*
+*/
+
+
+#include "alfrecyclinggridelementimpl.h"
+#include "autoarrayptr.h"
+#include <uiacceltk/HuiLayout.h> // Just for CHuiLayout::EExpandVertically
+#include <alf/alfenv.h>
+#include <alf/alfconstants.h>
+#include <alf/alfcommand.h>
+
+#include <alf/alfgridlayout.h>
+#include <alf/alflayout.h>
+#include <alf/alfcontrol.h>
+#include <alf/alfevent.h>
+
+#include "alf/ialfvisualtemplate.h"
+#include <alf/alfvarianttype.h>
+#include <alf/alfwidgetcontrol.h>
+#include <alf/alfvisualexception.h>
+#include <alf/alfwidgetevents.h>
+#include <osn/ustring.h>
+#include <memory>
+#include <osn/osnnew.h>
+
+using namespace osncore;
+
+_LIT8(KMainLayoutName, "MainLayout");
+_LIT8(KScrollLayoutName, "ScrollLayout");
+
+const int KDefaultScrollingTime = 400;
+
+using namespace Alf;
+
+AlfRecyclingGridElementImpl::AlfRecyclingGridElementImpl(
+    AlfRecyclingGridElement& aOwner,
+    int aNumColumns,
+    int aNumRows) : mOwner( aOwner )
+    {
+    mNumVisibleColumns     = aNumColumns;
+    mNumVisibleRows     = aNumRows;
+    mNumColumns      = 0;
+    mNumRows      = 0;
+    mFillStyle      = AlfRecyclingGridElement::AlfRecyclingGridElement::EColumnsFirst;
+    mFillStyleParam     = 0;
+    mScrollingTime     = KDefaultScrollingTime;
+    mFadeInTime      = KDefaultScrollingTime / 2.f;
+    mFadeInDelay     = KDefaultScrollingTime / 2.f;
+    mFadeOutTime     = KDefaultScrollingTime / 2.f;
+    mFadeOutDelay     = 0;
+    mScrollOffset.iX    = 0;
+    mScrollOffset.iY    = 0;
+    mHorizontalOffset    = false;
+    mVerticalOffset     = false;
+
+    setFillStyle(AlfRecyclingGridElement::AlfRecyclingGridElement::EColumnsFirst, aNumColumns);
+    }
+
+//----------------------------------------------------------------
+// Class Destructor
+//----------------------------------------------------------------
+AlfRecyclingGridElementImpl::~AlfRecyclingGridElementImpl()
+    {
+    }
+
+//----------------------------------------------------------------
+// Sets the fill style for the Recycle grid element
+//----------------------------------------------------------------
+void AlfRecyclingGridElementImpl::setFillStyle(AlfRecyclingGridElement::FillStyle aFillStyle, int aFillStyleParam)
+    {
+    mFillStyle = aFillStyle;
+    mFillStyleParam = aFillStyleParam;
+    mNumRows = mNumVisibleRows;
+    mNumColumns = mNumVisibleColumns;
+    if (mFillStyle == AlfRecyclingGridElement::EColumnsFirst ||
+            (mFillStyle == AlfRecyclingGridElement::ERowsFirst && mFillStyleParam > mNumRows))
+        {
+        mNumRows++; // 1 extra row for scrolling
+        }
+    if (mFillStyle == AlfRecyclingGridElement::ERowsFirst ||
+            (mFillStyle == AlfRecyclingGridElement::EColumnsFirst && mFillStyleParam > mNumColumns))
+        {
+        mNumColumns++; // 1 extra column for scrolling
+        }
+    }
+
+
+void AlfRecyclingGridElementImpl::setAnimationTimes(
+    int aScrollingTime, int aFadeInTime, int aFadeInDelay,
+    int aFadeOutTime, int aFadeOutDelay )
+    {
+    mScrollingTime = aScrollingTime;
+    mFadeInTime = aFadeInTime;
+    mFadeInDelay = aFadeInDelay;
+    mFadeOutTime = aFadeOutTime;
+    mFadeOutDelay = aFadeOutDelay;
+    }
+
+
+CAlfVisual* AlfRecyclingGridElementImpl::createVisualTree(
+    IAlfVariantType& aData, uint aDataID, CAlfLayout* aParentLayout, int aLayoutIndex )
+    {
+    CAlfLayout *main = NULL;
+    CAlfGridLayout *grid = NULL;
+    CAlfVisual* visualTree = mOwner.findVisual(aDataID);
+
+    if ( visualTree )
+        {
+        main = (CAlfLayout *)visualTree;
+        grid = (CAlfGridLayout *)&main->Visual( 0 );
+        }
+    else
+        {
+        main = CAlfLayout::AddNewL((CAlfControl &)mOwner.control());
+        main->SetTagL(KMainLayoutName);
+
+        // Create grid layout
+        grid = CAlfGridLayout::AddNewL((CAlfControl&)mOwner.control(),mNumColumns, mNumRows, main);
+
+        // Scroll layout for additional content,
+        // created by the visual template or other elements.
+        CAlfLayout *scroll = CAlfLayout::AddNewL((CAlfControl&)mOwner.control(), main);
+        scroll->SetTagL(KScrollLayoutName);
+
+        if (mOwner.getVisualTemplate())
+            {
+            mOwner.getVisualTemplate()->createVisualTree(
+                mOwner.control(), aData.branch()->data(), scroll, scroll->Count());
+            }
+        if (aParentLayout)
+            {
+            aParentLayout->Insert(main, aLayoutIndex );
+            }
+        }
+
+    TAlfRealPoint size = main->Size().ValueNow();
+    TAlfRealPoint itemSize(size.iX / (TReal)mNumVisibleColumns,size.iY / (TReal)mNumVisibleRows);
+    TAlfRealPoint gridSize(itemSize.iX * mNumColumns, itemSize.iY * mNumRows);
+    grid->SetSize(gridSize);
+
+    mOwner.addVisualTree(main, aDataID);
+
+    CAlfLayout *parent = NULL;
+    if (mFillStyle == AlfRecyclingGridElement::EColumnsFirst)
+        {
+        // No reordering needed, add directly to the grid layout
+        parent = grid;
+        }
+    CAlfVisual** array = new( EMM ) CAlfVisual*[mNumColumns * mNumRows];
+
+    // Ownership transferred to the autoptr.
+    auto_arrayptr<CAlfVisual*> arrayCleanup( array );
+
+    int childIndex = 0;
+    // Create the children visual trees
+    if ( aData.type() == IAlfVariantType::EBranch &&
+            aData.branch()->childrenCount())
+        {
+        IAlfBranch* branch = aData.branch();
+        TPoint childPos = calculateChildPos(0);
+        int maxColumn = mScrollOffset.iX + mNumColumns;
+        int maxRow = mScrollOffset.iY + mNumRows;
+        for (int i = 0; i < branch->childrenCount() &&
+                ( childPos.iX < maxColumn || childPos.iY < maxRow); ++i)
+            {
+            childPos = calculateChildPos(i);
+            if (childPos.iX >= mScrollOffset.iX && childPos.iX < maxColumn &&
+                    childPos.iY >= mScrollOffset.iY && childPos.iY < maxRow)
+                {
+                IAlfElement* child = mOwner.control().findElement( aData.branch()->childName(i).getUtf8());
+                uint childID = mOwner.control().elementDataId(*child, i, aDataID);
+                array[childIndex] = child->createVisualTree(
+                                        *branch->childData( i ), *branch, i, aDataID, parent, childIndex );
+                childIndex++;
+                }
+
+            }
+        }
+
+    // Reorder and insert to the grid layout
+    if (mFillStyle == AlfRecyclingGridElement::ERowsFirst)
+        {
+        for (int i = 0; i < mNumRows && childIndex >= 0; ++i)
+            {
+            for (int j = 0; j < mNumColumns && childIndex >= 0; ++j)
+                {
+                int err=grid->Append(array[j * mNumRows + i]);
+				if(err!=KErrNone)
+					{
+					ALF_THROW ( AlfVisualException, err, "Grid Append Failed" )
+					}                
+                childIndex--;
+                }
+            }
+        }
+
+    return main;
+    }
+
+
+//----------------------------------------------------------------
+// Gets the Point of  a child at a given index
+//----------------------------------------------------------------
+TPoint AlfRecyclingGridElementImpl::calculateChildPos(int aInd) const
+    {
+    if (mFillStyle == AlfRecyclingGridElement::EColumnsFirst)
+        {
+        return TPoint(aInd % mFillStyleParam, aInd / mFillStyleParam);
+        }
+    else if (mFillStyle == AlfRecyclingGridElement::ERowsFirst)
+        {
+        return TPoint(aInd / mFillStyleParam, aInd % mFillStyleParam);
+        }
+    return TPoint(0, 0);
+    }
+
+//----------------------------------------------------------------
+// Gets the Index of  a child at a given point
+//----------------------------------------------------------------
+int AlfRecyclingGridElementImpl::calculateChildInd(TPoint aPos) const
+    {
+    if (aPos.iX < 0 || aPos.iY < 0)
+        {
+        return -1; // Does not exist
+        }
+    if (mFillStyle == AlfRecyclingGridElement::EColumnsFirst)
+        {
+        if (aPos.iX >= mFillStyleParam)
+            {
+            return -1; // Does not exist
+            }
+        return aPos.iY * mFillStyleParam + aPos.iX;
+        }
+    else if (mFillStyle == AlfRecyclingGridElement::ERowsFirst)
+        {
+        if (aPos.iY >= mFillStyleParam)
+            {
+            return -1; // Does not exist
+            }
+        return aPos.iX * mFillStyleParam + aPos.iY;
+        }
+    return 0;
+    }
+
+
+
+// ---------------------------------------------------------------------------
+// OfferEventL - Handle the Event.
+// ?implementation_description
+// ---------------------------------------------------------------------------
+bool AlfRecyclingGridElementImpl::offerEvent( CAlfWidgetControl& aControl, const TAlfEvent& aEvent )
+    {
+
+    if ( !accept( aControl, aEvent ) )
+        {
+        return false;
+        }
+    uint aEventID = aEvent.CustomParameter();
+
+    if ( aEventID == EEventScrollPrimaryNext )
+        {
+        aEventID = ( mFillStyle == AlfRecyclingGridElement::EColumnsFirst ? EEventScrollDown : EEventScrollRight );
+        }
+    else if ( aEventID == EEventScrollPrimaryPrev )
+        {
+        aEventID = ( mFillStyle == AlfRecyclingGridElement::EColumnsFirst ? EEventScrollUp : EEventScrollLeft );
+        }
+    else if ( aEventID == EEventScrollSecondaryNext )
+        {
+        aEventID = ( mFillStyle == AlfRecyclingGridElement::EColumnsFirst ? EEventScrollRight : EEventScrollDown );
+        }
+    else if ( aEventID == EEventScrollSecondaryPrev )
+        {
+        aEventID = ( mFillStyle == AlfRecyclingGridElement::EColumnsFirst ? EEventScrollLeft : EEventScrollUp );
+        }
+
+    if ((int)aEventID == (int)EEventScrollPageDown )
+        {
+        int iter=0;
+        if ((int)mFillStyle == (int)AlfRecyclingGridElement::EColumnsFirst )
+            {
+            iter = mNumRows-1 ;
+            }
+        else
+            {
+            iter = mNumColumns-1 ;
+            }
+
+        for (int i=0;i<iter;i++)
+            {
+            moveSingleRowOrColumn(aControl , false);
+            }
+        return true;
+        }
+    else if ((int)aEventID == (int)EEventScrollPageUp )
+        {
+        int iter=0;
+        if ((int)mFillStyle == (int)AlfRecyclingGridElement::EColumnsFirst )
+            {
+            iter = mNumRows-1 ;
+            }
+        else
+            {
+            iter = mNumColumns-1 ;
+            }
+
+        for (int i=0;i<iter;i++)
+            {
+            moveSingleRowOrColumn(aControl , true);
+            }
+        return true;
+
+        }
+    else
+        {
+        doPositioningAndScrolling(aControl,aEventID);
+        }
+    return true;
+
+    }
+
+// ---------------------------------------------------------------------------
+// ?implementation_description
+// ---------------------------------------------------------------------------
+//
+void AlfRecyclingGridElementImpl::setActiveStates( unsigned int aStates )
+    {
+    mActiveStates = aStates;
+    }
+
+
+void AlfRecyclingGridElementImpl::doPositioningAndScrolling( CAlfWidgetControl& aControl,uint aEventID)
+    {
+    //unsigned int16 id = aEvent.CustomEventData();//Index of the focus element
+
+    CAlfLayout *main = (CAlfLayout *)mOwner.findVisual(0);   //(CAlfLayout *)VisualTreeArray()[0];//root element
+    CAlfGridLayout *grid = (CAlfGridLayout *)&main->Visual(0);
+    CAlfLayout *scroll = (CAlfGridLayout *)&main->Visual(1);
+
+
+    TSize size;
+
+    // Grid/scroll layout movement
+    TPoint layoutMovement(0, 0);
+
+    // New number of the new items to reveal (and old items to hide)
+    int numNewItems = 0;
+
+    // Starting indices and increment step for recycling visuals
+    int recycleSrcInd = 0, recycleDstInd = 0;
+    int recycleIndStep = 0;
+
+    // Starting indices and increment step for fading in/out visuals
+    int fadeInInd = 0, fadeOutInd = 0;
+    int fadeIndStep = 0;
+
+    // Is recycling required?
+    bool recycle = false;
+
+    // Index of the first new child visual
+    TPoint firstNewChildPos(0, 0);
+
+    // Increment step for the new child indices
+    TPoint childPosStep(0, 0);
+
+    if (aEventID == EEventScrollUp) // Up
+        {
+        firstNewChildPos = mScrollOffset + TPoint(mHorizontalOffset ? -1 : 0, -1);
+        childPosStep = TPoint(1, 0);
+        mScrollOffset.iY--;
+        numNewItems = mNumColumns;
+        fadeInInd = mNumColumns - 1;
+        fadeOutInd = grid->Count() - 1;
+        recycleSrcInd = grid->Count() - mNumColumns;
+        recycleIndStep = 1;
+        fadeIndStep = -1;
+        grid->ChildSize(recycleDstInd, size);
+        layoutMovement.iY = -size.iHeight;
+        recycle = !mVerticalOffset;
+        mVerticalOffset = false;
+
+        }
+    else if (aEventID == EEventScrollDown) // Down
+        {
+        firstNewChildPos = mScrollOffset + TPoint(mHorizontalOffset ? -1 : 0, mNumRows - 1);
+        childPosStep = TPoint(1, 0);
+        mScrollOffset.iY++;
+        numNewItems = mNumColumns;
+        recycleDstInd = grid->Count()- 1;
+        fadeInInd = grid->Count() - mNumColumns;
+        fadeIndStep = 1;
+        grid->ChildSize(recycleDstInd, size);
+        layoutMovement.iY = size.iHeight;
+
+        recycle = mVerticalOffset;
+        mVerticalOffset = true;
+
+
+        }
+    else if (aEventID == EEventScrollLeft) // Left
+        {
+        firstNewChildPos = mScrollOffset + TPoint(-1, mVerticalOffset ? -1 : 0);
+        childPosStep = TPoint(0, 1);
+        mScrollOffset.iX--;
+        numNewItems = mNumRows;
+        fadeOutInd = recycleSrcInd = mNumColumns - 1;
+        fadeIndStep = recycleIndStep = mNumColumns;
+        grid->ChildSize(recycleDstInd, size);
+        layoutMovement.iX = -size.iWidth;
+        recycle = !mHorizontalOffset;
+        mHorizontalOffset = false;
+
+        }
+
+    else if (aEventID == EEventScrollRight) // Right
+        {
+        firstNewChildPos = mScrollOffset + TPoint(mNumColumns - 1, mVerticalOffset ? -1 : 0);
+        childPosStep = TPoint(0, 1);
+        mScrollOffset.iX++;
+        numNewItems = mNumRows;
+        fadeInInd = recycleDstInd = mNumColumns - 1;
+        fadeIndStep = recycleIndStep = mNumColumns;
+        grid->ChildSize(recycleDstInd, size);
+        layoutMovement.iX = size.iWidth;
+        recycle = mHorizontalOffset;
+        mHorizontalOffset = true;
+        }
+
+    IAlfVariantType *recyclingGridData = aControl.elementData(mOwner, 0);
+    if ( recyclingGridData->type()!=  IAlfVariantType::EBranch)
+        {
+        return ;
+        }
+
+    aControl.Env().PauseRefresh();
+
+    // Perform scrolling
+    if (aEventID == EEventScrollPageDown || aEventID == EEventScrollPageUp || aEventID == EEventScrollUp || aEventID == EEventScrollDown ||aEventID == EEventScrollLeft || aEventID == EEventScrollRight)
+        {
+        if (recycle)
+            {
+            // Move the layout
+            grid->SetPos(grid->Pos().Target() + layoutMovement);
+            // Recycle visual trees
+            for (int i = 0; i < numNewItems; ++i)
+                {
+                CAlfVisual &visual = grid->Visual(recycleSrcInd + i * recycleIndStep);
+                grid->Reorder(visual, recycleDstInd + i * recycleIndStep);
+                TPoint childPos = firstNewChildPos + TPoint(i * childPosStep.iX, i * childPosStep.iY);
+                int childInd = calculateChildInd(childPos);
+                if (childInd >= 0 && childInd < recyclingGridData->branch()->childrenCount())
+                    {
+                    IAlfVariantType *recyclingGridChildData = recyclingGridData->branch()->childData(childInd);
+
+                    const UString& childName  = recyclingGridData->branch()->childName(childInd);
+                    IAlfElement *childElement = mOwner.control().findElement(childName.getUtf8());
+                    if (childElement!=NULL)
+                        {
+                        int newDataID= mOwner.control().elementDataId(*childElement,childInd, 0);
+                        childElement->replaceVisualTree(
+                            *recyclingGridChildData,newDataID ,childElement->dataID(visual));
+                        }
+                    }
+                }
+            }
+        else
+            {
+            scroll->SetPos(scroll->Pos().Target() - layoutMovement, mScrollingTime);
+            }
+        // Fade in / out
+        for (int i = 0; i < numNewItems; ++i)
+            {
+            // Fade out the old items
+            CAlfVisual &oldItem = grid->Visual(fadeOutInd + i * fadeIndStep);
+            if ( mFadeOutDelay == 0 )
+                {
+                TAlfTimedValue zero;
+                zero.SetValueNow(1.f);
+                zero.SetTarget(0.f, mFadeOutTime);
+                oldItem.SetOpacity(zero);
+                }
+            else
+                {
+                TAlfValueCommand cmd((void*)&oldItem, EAlfValueCommandVisualSetOpacity, 0.f, mFadeOutTime);
+                aControl.Env().Send(cmd, mFadeOutDelay);
+                }
+            // Fade in the new items
+            CAlfVisual &newItem = grid->Visual(fadeInInd + i * fadeIndStep);
+            TAlfTimedValue zero2;
+            zero2.SetValueNow(0.f);
+            zero2.SetTarget(0.f, 0);
+            newItem.SetOpacity(zero2);
+            TPoint childPos = firstNewChildPos + TPoint(i * childPosStep.iX, i * childPosStep.iY);
+            int childInd = calculateChildInd(childPos);
+            IAlfVariantType *recyclingGridChildData = recyclingGridData->branch()->childData(childInd);
+            if (childInd >= 0 && recyclingGridChildData!=NULL)
+                {
+                if ( mFadeInDelay == 0 )
+                    {
+                    TAlfTimedValue one;
+                    one.SetValueNow(0.f);
+                    one.SetTarget(1.f, mFadeInTime);
+                    newItem.SetOpacity(one);
+                    }
+                else
+                    {
+                    TAlfValueCommand cmd((void*)&newItem, EAlfValueCommandVisualSetOpacity, 1.f, mFadeInTime);
+                    aControl.Env().Send(cmd, mFadeInDelay);
+                    }
+                }
+            else
+                {
+                newItem.SetOpacity( TAlfTimedValue(0) );
+                }
+            }
+        // Animate layout scrolling
+        grid->SetPos(grid->Pos().Target() - layoutMovement, mScrollingTime);
+        }
+
+    aControl.Env().ContinueRefresh();
+    }
+
+// ---------------------------------------------------------------------------
+// OfferEventL - Handle the Event.
+// ?implementation_description
+// ---------------------------------------------------------------------------
+bool AlfRecyclingGridElementImpl::moveSingleRowOrColumn( CAlfWidgetControl& aControl, bool aPageUp)
+    {
+    uint aEventID;
+
+    if (!aPageUp)
+        {
+        aEventID = (mFillStyle == AlfRecyclingGridElement::EColumnsFirst ? EEventScrollDown : EEventScrollRight);
+        }
+    else
+        {
+        aEventID = (mFillStyle == AlfRecyclingGridElement::EColumnsFirst ? EEventScrollUp : EEventScrollLeft);
+        }
+
+    doPositioningAndScrolling(aControl,aEventID);
+    return true;
+    }
+
+
+bool AlfRecyclingGridElementImpl::accept( CAlfWidgetControl& /*aControl*/, const TAlfEvent& aEvent ) const
+    {
+
+    uint aEventID;
+    if (!aEvent.IsCustomEvent())
+        {
+        return false;
+        }
+    aEventID = aEvent.CustomParameter();
+    if ( aEventID == EEventScrollPrimaryNext || aEventID == EEventScrollPrimaryPrev ||
+            aEventID == EEventScrollSecondaryNext || aEventID == EEventScrollSecondaryPrev ||
+            aEventID == EEventScrollToFirst || aEventID == EEventScrollToLast ||
+            aEventID == EEventScrollUp || aEventID == EEventScrollDown ||
+            aEventID == EEventScrollLeft || aEventID == EEventScrollRight ||
+            aEventID == EEventScrollPageDown || aEventID == EEventScrollPageUp)
+        {
+        return true;
+        }
+
+    return false;
+    }
+
+
+void AlfRecyclingGridElementImpl::createChildVisualTree(
+    IAlfElement* aElement, IAlfVariantType& aChildData,
+    IAlfBranch& aData, int aIndex, uint aDataID )
+    {
+    int firstVisibleInd=0, lastVisibleInd=0;
+    int firstVisibleDataId=0, lastVisibleDataId=0;
+    CAlfLayout *main = (CAlfLayout *)mOwner.findVisual(0);
+    CAlfGridLayout *grid = (CAlfGridLayout *)&main->Visual(0);
+
+    if (grid->Count() > 0)
+        {
+        CAlfVisual &first  = grid->Visual( 0 );
+        CAlfVisual &last   = grid->Visual( grid->Count() - 1 );
+
+        firstVisibleDataId= aElement->dataID(first);
+        lastVisibleDataId= aElement->dataID(last);
+
+        firstVisibleInd= mOwner.control().dataIdToIndex(*aElement, firstVisibleDataId);
+        lastVisibleInd= mOwner.control().dataIdToIndex(*aElement, lastVisibleDataId);
+
+        // Replace the visual tree
+        IAlfElement* child = mOwner.control().findElement( aData.branch()->childName(0).getUtf8());
+
+
+        if (aData.childrenCount()>= mNumColumns*mNumRows)
+            {
+            // Check that the child index is in the visible area
+            if ( aIndex >= firstVisibleInd && aIndex <= lastVisibleInd )
+                {
+                CAlfVisual &last   = grid->Visual( grid->Count()-1 );
+
+                // Move the last visual to the right position
+                grid->Reorder( last, aIndex - firstVisibleInd);
+
+
+                // Update data IDs
+                child->updateDataIDs( aData, aIndex, 1, aDataID, aDataID );
+
+                int oldElementDataID = aElement->dataID( last );
+                int newElementDataID = mOwner.control().elementDataId( *aElement, aIndex - firstVisibleInd, aDataID );
+
+                child->replaceVisualTree( aChildData, newElementDataID ,oldElementDataID );
+                }
+            }
+        else
+            {
+            int newElementDataID = mOwner.control().elementDataId( *aElement, aIndex - firstVisibleInd, aDataID );
+
+            //Update data IDs
+            child->updateDataIDs( aData, aIndex, 1, aDataID, aDataID );
+
+            //CAlfVisual* newItem = child->createVisualTree(aChildData, aData,aData.childrenCount(), aDataID, static_cast<CAlfLayout*>(grid ));
+            CAlfVisual* newItem = child->createVisualTree(aChildData, newElementDataID,static_cast<CAlfLayout*>(grid ),grid->Count()-1);
+
+            // Move the last visual to the right position
+            grid->Reorder( *newItem, aIndex - firstVisibleInd);
+            }
+        }
+    else
+        {
+        aElement->createVisualTree( aChildData, aData, aIndex, aDataID, grid, aIndex );
+        }
+    }
+
+void AlfRecyclingGridElementImpl::removeChildVisualTree(
+    IAlfElement* aElement, IAlfBranch& aData, int aIndex, uint aDataID )
+    {
+    int firstVisibleInd=0, lastVisibleInd=0;
+    int firstVisibleDataId=0, lastVisibleDataId=0;
+    CAlfLayout *main = (CAlfLayout *)mOwner.findVisual(0);
+    CAlfGridLayout *grid = (CAlfGridLayout *)&main->Visual(0);
+
+    CAlfVisual &first  = grid->Visual( 0 );
+
+    if (aData.childrenCount()-1 > (grid->Count() - 1) )
+        {
+        CAlfVisual &last   = grid->Visual( grid->Count() - 1 );
+        firstVisibleDataId= aElement->dataID(first);
+        lastVisibleDataId= aElement->dataID(last);
+
+        firstVisibleInd= mOwner.control().dataIdToIndex(*aElement, firstVisibleDataId);
+        lastVisibleInd= mOwner.control().dataIdToIndex(*aElement, lastVisibleDataId);
+
+        /*Check that the child index is in the visible area*/
+        if ( aIndex >= firstVisibleInd && aIndex <= lastVisibleInd )
+            {
+            // Find the visual to be removed - it's used to show the next visual tree below the visible area
+            CAlfVisual &removed = grid->Visual( aIndex  - firstVisibleInd );
+
+            // Move it to the end of the grid
+            grid->Reorder( removed, grid->Count() - 1 );
+
+
+            // Replace the visual tree
+            IAlfElement* child = mOwner.control().findElement( aData.branch()->childName(0).getUtf8());
+
+            IAlfVariantType* data =NULL;
+            data = aData.childData( lastVisibleInd + 1 );
+
+            int oldElementDataID = aElement->dataID( removed );
+
+            int newElementDataID ;
+            newElementDataID = mOwner.control().elementDataId( *aElement, lastVisibleInd + 1, aDataID );
+
+            if (data!=NULL)
+                {
+                child->replaceVisualTree(*data, newElementDataID, oldElementDataID);
+                }
+
+            if (aData.childrenCount()-1 <= (grid->Count() - 1 ))
+                {
+                child->removeVisualTree(aData, aData.childrenCount()-1,aDataID);
+                }
+
+            // Update data IDs
+            child->updateDataIDs( aData, aIndex, -1, aDataID, aDataID );
+            }
+        }
+    else
+        {
+        CAlfVisual &last   = grid->Visual(aData.childrenCount()-1);
+        firstVisibleDataId= aElement->dataID(first);
+        lastVisibleDataId= aElement->dataID(last);
+
+        firstVisibleInd= mOwner.control().dataIdToIndex(*aElement, firstVisibleDataId);
+        lastVisibleInd= mOwner.control().dataIdToIndex(*aElement, lastVisibleDataId);
+
+
+        /*Check that the child index is in the visible area*/
+        if ( aIndex >= firstVisibleInd && aIndex <= lastVisibleInd )
+            {
+            // Find the visual to be removed - it's used to show the next visual tree below the visible area
+            CAlfVisual &removed = grid->Visual( aIndex  - firstVisibleInd );
+
+            grid->Reorder( removed, aData.childrenCount()-1);
+
+            // Replace the visual tree
+            IAlfElement* child = mOwner.control().findElement( aData.branch()->childName(0).getUtf8());
+
+            IAlfVariantType* data =NULL;
+            data = aData.childData( aData.childrenCount() -1 );
+
+            // Replace the visual tree
+
+            CAlfVisual &last   = grid->Visual( aData.childrenCount()-1 );
+
+            int oldElementDataID = aElement->dataID( removed );
+
+            int newElementDataID ;
+            newElementDataID = mOwner.control().elementDataId( *aElement, aData.childrenCount()-1, aDataID );
+
+            if (data!=NULL)
+                {
+                child->replaceVisualTree(*data, newElementDataID, oldElementDataID);
+                }
+
+            if (aData.childrenCount()-1 <= (grid->Count() - 1 ))
+                {
+                child->removeVisualTree(aData, aData.childrenCount()-1,aDataID);
+                }
+
+            // Update data IDs
+            child->updateDataIDs( aData, aIndex, -1, aDataID, aDataID );
+            }
+        }
+    }
+// ---------------------------------------------------------------------------
+// Description: Do not destroy visuals, because it's done elsewhere.
+// ---------------------------------------------------------------------------
+void AlfRecyclingGridElementImpl::removeAndDestroyVisuals( int /*aTimeMilliseconds*/ )
+    {
+    }
+
+// End of File.