/*

 * Copyright (c) 2007 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 : Freestyle tree list visualizer implementation

 *

 *

 */

//////SYSTEM INCLUDES

#include "emailtrace.h"

#include <AknUtils.h>

#include <StringLoader.h>

#include <avkon.rsg> // R_AVKON_EMPTY_POPUP_LIST_TEXT

#include <centralrepository.h>

//////TOOLKIT INCLUDES

// <cmail> SF

#include <alf/alfstatic.h>

#include <alf/alfownership.h>

#include <alf/alfevent.h>

#include <alf/alfimage.h>

#include <alf/alfenv.h>

#include <alf/alfcontrolgroup.h>

//layouts

#include <alf/alfflowlayout.h>

#include <alf/alfdecklayout.h>

#include <alf/alfgridlayout.h>

//brushes

#include <alf/alfbrusharray.h>

#include <alf/alfbrush.h>

#include <alf/alfborderbrush.h>

#include <alf/alfimagebrush.h>

#include <alf/alfgradientbrush.h>

#include <alf/alfframebrush.h>

#include <alf/alfshadowborderbrush.h>

//metrics

#include <alf/alfmetric.h>

#include <alf/alftimedvalue.h>

//visuals

#include <alf/alfvisual.h>

#include <alf/alfimagevisual.h>

// </cmail>

//////PROJECT INCLUDES

#include "fstreevisualizerbase.h"

#include "fstreeplainrootvisualizer.h"

#include "fstree.h"

#include "fstreeiterator.h"

#include "fsgenericpanic.h"

#include "fsfadeeffect.h"

#include "fstreeplainonelineitemdata.h"

#include "fsslideeffect.h"

#include "fstreeplainonelineitemvisualizer.h"

#include "fstreelist.h"

#include "fstreevisualizerobserver.h"

#include "fscenrepkeys.h"

#include "fswatermark.h"

#include "fslayoutmanager.h"

#include "fsseparatordata.h"

////alf specific

#include "fsalfscrollbarlayout.h"

#include "fsalftextstylemanager.h"

#include "fsinteractioninterval.h"

#include <aknphysics.h>

//CONSTANTS

const TInt KDefaultShadowWidth = 4;

const TInt KFSListDefaultSelectorBorderWidth = 0;

const TInt KZero = 0;

_LIT8( KPropertyItemId, "PropItemID" );

// check from aknphysicsconstants.h

const TInt KFlickMaxDuration( 500000 );

// ======== LOCAL FUNCTIONS ========

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

// Deletes and sets pointer to NULL.

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

template<class T> void SafeDelete(T*& aPtr)

    {

    delete aPtr;

    aPtr = NULL;

    }

// ======== MEMBER FUNCTIONS ========

// TWorld::TItem

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

// TWorld::TItem::TItem

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

TWorld::TItem::TItem(const TFsTreeItemId aId, const TRect& aRect) :

    iId(aId)

    {

    SetRect(aRect);

    }

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

// TWorld::TItem::Rect

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

TRect TWorld::TItem::Rect() const

    {

    return TRect(TPoint(0, iY), TPoint(0, iY + iHeight));

    }

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

// TWorld::TItem::SetRect

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

void TWorld::TItem::SetRect(const TRect& aRect)

    {

    iY = aRect.iTl.iY;

    iHeight = aRect.Height();

    }

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

// TWorld::TItem::Move

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

void TWorld::TItem::Move(TInt aDy)

    {

    iY += aDy;

    }

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

// TWorld::TItem::Top

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

TInt TWorld::TItem::Top() const

    {

    return iY;

    }

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

// TWorld::TItem::TopLeft

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

TPoint TWorld::TItem::TopLeft() const

    {

    return TPoint(0, iY);

    }

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

// TWorld::TItem::Height

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

TInt TWorld::TItem::Height() const

    {

    return iHeight;

    }

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

// TWorld::TItem::Bottom

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

TInt TWorld::TItem::Bottom() const

    {

    return iY + iHeight;

    }

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

// TWorld::TItem::Bottom

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

TPoint TWorld::TItem::BottomRight() const

    {

    return TPoint(0, iY + iHeight);

    }

// TWorld

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

// TWorld::TWorld

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

TWorld::TWorld() :

    iBatchUpdateOngoing(EFalse)

    {

    }

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

// TWorld::~TWorld

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

TWorld::~TWorld()

    {

    iItems.Reset();

    iObservers.Reset();

    }

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

// TWorld::AddObserverL

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

void TWorld::AddObserverL(MObserver& aObserver)

    {

    iObservers.AppendL(&aObserver);

    }

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

// TWorld::RemoveObserver

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

void TWorld::RemoveObserver(MObserver& aObserver)

    {

    const TInt index(iObservers.Find(&aObserver));

    if (index != KErrNotFound)

        {

        iObservers.Remove(index);

        }

    }

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

// TWorld::AppendL

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

void TWorld::AppendL(const TFsTreeItemId aId, const TSize& aSize)

    {

    const TInt count(iItems.Count());

    TPoint tl;

    if (count > 0)

        {

        tl.iY = iItems[count - 1].Bottom();

        }

    const TRect modifiedRect(TRect(tl, aSize));

    iItems.AppendL(TItem(aId, modifiedRect));

    iHeight += aSize.iHeight;

    UpdatedL();

    }

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

// TWorld::InsertL

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

void TWorld::InsertL(const TFsTreeItemId aId, const TSize& aSize,

        const TInt aSlot)

    {

    if (aSlot >= iItems.Count())

        {

        AppendL(aId, aSize);

        }

    else

        {

        const TPoint topLeft(iItems[aSlot].TopLeft());

        iItems.InsertL(TItem(aId, TRect(topLeft, aSize)), aSlot);

        MoveBy(aSlot + 1, aSize.iHeight);

        iHeight += aSize.iHeight;

        UpdatedL();

        }

    }

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

// TWorld::RemoveL

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

void TWorld::RemoveL(const TFsTreeItemId aId)

    {

    for (TInt i = iItems.Count() - 1; i >= 0; i--)

        {

        const TFsTreeItemId itemId(iItems[i].iId);

        if (itemId == aId)

            {

            const TItem item(iItems[i]);

            iItems.Remove(i);

            const TInt delta(-item.Height());

            MoveBy(i, delta);

            iHeight += delta;

            UpdatedL();

            break;

            }

        }

    }

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

// TWorld::RemoveAllL

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

void TWorld::RemoveAllL()

    {

    iHeight = 0;

    iItems.Reset();

    UpdatedL();

    }

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

// TWorld::Height

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

TInt TWorld::Height() const

    {

    return iHeight;

    }

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

// TWorld::ItemCount

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

TInt TWorld::ItemCount() const

    {

    return iItems.Count();

    }

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

// TWorld::Item

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

TFsTreeItemId TWorld::Item(TInt aIndex) const

    {

    return iItems[aIndex].iId;

    }

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

// TWorld::IndexOfItem

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

TInt TWorld::IndexOfItem(TFsTreeItemId aItem) const

    {

    for (TInt i = 0; i < iItems.Count(); i++)

        {

        if (iItems[i].iId == aItem)

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

// TWorld::MoveBy

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

void TWorld::MoveBy(const TInt aSlot, const TInt aDelta)

    {

    const TInt count(iItems.Count());

    for (TInt i = aSlot; i < count; i++)

        {

        iItems[i].Move(aDelta);

        }

    }

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

// TWorld::UpdatedL

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

void TWorld::UpdatedL()

    {

    if (!iBatchUpdateOngoing)

        {

        for (TInt i = iObservers.Count() - 1; i >= 0; i--)

            {

            iObservers[i]->WorldUpdatedL(*this);

            }

        }

    }

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

// TWorld::GetItemsL

// Uses binary search.

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

void TWorld::GetItemsL(RArray<TFsTreeItemId>& aItems, TInt aY, TInt aHeight,

        TInt& aOffset)

    {

    // First find first visible item using binary search algorithm

    aItems.Reset();

    TInt i(0);

    aOffset = 0;

    if (aY > Height())

        {

        aHeight = -1;

        }

    else if (aY > 0)

        {

        TInt min(0);

        TInt max(iItems.Count() - 1);

        while (min <= max)

            {

            const TInt middle(min + (max - min) / 2);

            if (aY < iItems[middle].Top())

                {

                max = middle - 1;

                }

            else if (aY > iItems[middle].Bottom())

                {

                min = middle + 1;

                }

            else

                {

                aOffset = aY - iItems[middle].Top();

                aHeight += aOffset;

                i = middle;

                break;

                }

            }

        }

    else

        {

        aOffset = aY;

        aHeight += aY;

        }

    // If item was found, collect enough items to fill the view

    while (aHeight >= 0 && i < iItems.Count())

        {

        aItems.AppendL(iItems[i].iId);

        aHeight -= iItems[i++].Height();

        }

    }

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

// TWorld::BeginUpdate

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

void TWorld::BeginUpdate()

    {

    iBatchUpdateOngoing = ETrue;

    }

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

// TWorld::EndUpdateL

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

void TWorld::EndUpdateL()

    {

    if (iBatchUpdateOngoing)

        {

        iBatchUpdateOngoing = EFalse;

        UpdatedL();

        }

    }

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

// TWorld::IsUpdating

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

TBool TWorld::IsUpdating() const

    {

    return iBatchUpdateOngoing;

    }

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

// TWorld::Recalculate

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

void TWorld::Recalculate(const CFsTree& aTree)

    {

    TPoint tl;

    iHeight = 0;

    for (TInt i = 0; i < iItems.Count(); i++)

        {

        TItem& item(iItems[i]);

        MFsTreeItemVisualizer* visualizer(aTree.ItemVisualizer(item.iId));

        TSize size(visualizer->Size());

        item.SetRect(TRect(tl, size));

        tl.iY += size.iHeight;

        iHeight += size.iHeight;

        }

    }

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

// TWorld::GetItemRect

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

TInt TWorld::GetItemRect(const TFsTreeItemId aItemId, TRect& aRect) const

    {

    TInt result(KErrNotFound);

    for (TInt i = iItems.Count() - 1; i >= 0; i--)

        {

        if (iItems[i].iId == aItemId)

            {

            result = i;

            aRect = iItems[i].Rect();

            break;

            }

        }

    return result;

    }

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

// TWorld::GetItemRectByIndex

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

TInt TWorld::GetItemRectByIndex(const TInt aIndex, TRect& aRect) const

    {

    TInt result(KErrNotFound);

    if (aIndex < iItems.Count() && aIndex >= 0)

        {

        aRect = iItems[aIndex].Rect();

        result = KErrNone;

        }

    return result;

    }

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

// TWorld::CheckIntegrity

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

TBool TWorld::CheckIntegrity() const

    {

    TBool result(ETrue);

    if (iItems.Count() > 1)

        {

        TRect prev(iItems[0].Rect());

        for (TInt i = 1; i < iItems.Count() - 1; i++)

            {

            const TRect& curr(iItems[i].Rect());

            if (prev.Intersects(curr))

                {

                result = EFalse;

                break;

                }

            prev.iBr.iY += curr.Height();

            }

        }

    return result;

    }

// TViewPort

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

// TViewPort::TViewPort

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

TViewPort::TViewPort(MObserver& aObserver, TWorld& aWorld) :

    iObserver(aObserver), iWorld(aWorld)

    {

    }

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

// TViewPort::SetPositionL

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

void TViewPort::SetPositionL(const TPoint& aPosition, TBool aInformUpdate)

    {

    iPosition = aPosition;

    // Do validation!

    if (aInformUpdate)

        {

        UpdatedL();

        }

    }

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

// TViewPort::SetCenterPositionL

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