/*

* 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) );

                }