diff -r 000000000000 -r 8466d47a6819 emailuis/uicomponents/src/fstreevisualizerbase.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/emailuis/uicomponents/src/fstreevisualizerbase.cpp	Thu Dec 17 08:39:21 2009 +0200
@@ -0,0 +1,5277 @@
+/*
+ * 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>
+//<cmail> removed __FS_ALFRED_SUPPORT flag
+//#include <fsconfig.h>
+//</cmail> removed __FS_ALFRED_SUPPORT flag
+#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 top(0);
+        TInt bottom(iItems.Count() - 1);
+        while (top <= bottom)
+            {
+            TInt middle(top + (bottom - top) / 2);
+            TInt topCoord(iItems[middle].Top());
+            TInt bottomCoord(iItems[middle].Bottom());
+            if (aY < topCoord)
+                {
+                if (bottom == middle)
+                    {
+                    bottom--;
+                    }
+                else
+                    {
+                    bottom = middle;
+                    }
+                }
+            else if (aY > bottomCoord)
+                {
+                if (top == middle)
+                    {
+                    top++;
+                    }
+                else
+                    {
+                    top = middle;
+                    }
+                }
+            else
+                {
+                aOffset = aY - topCoord;
+                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
+// ---------------------------------------------------------------------------
+void TViewPort::SetCenterPositionL(const TPoint& aPosition,
+        TBool aInformUpdate)
+    {
+    iPosition = TPoint(aPosition.iX - iSize.iWidth / 2, aPosition.iY
+            - iSize.iHeight / 2);
+    // Do validation!
+    if (aInformUpdate)
+        {
+        UpdatedL();
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::Position
+// ---------------------------------------------------------------------------
+const TPoint& TViewPort::Position() const
+    {
+    return iPosition;
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::CenterPosition
+// ---------------------------------------------------------------------------
+TPoint TViewPort::CenterPosition() const
+    {
+    TPoint result(iPosition.iX + iSize.iWidth / 2, iPosition.iY
+            + iSize.iHeight / 2);
+    return result;
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::SetSizeL
+// ---------------------------------------------------------------------------
+void TViewPort::SetSizeL(const TSize& aSize)
+    {
+    iSize = aSize;
+    // Do validation!
+    if (!iWorld.IsUpdating())
+        {
+        UpdatedL();
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::Size
+// ---------------------------------------------------------------------------
+const TSize& TViewPort::Size() const
+    {
+    return iSize;
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::GetVisibleItemsL
+// ---------------------------------------------------------------------------
+void TViewPort::GetVisibleItemsL(RArray<TFsTreeItemId>& aItemsToBeRemoved,
+        RArray<TFsTreeItemId>& aItemsToBeAdded, TInt& aOffset,
+        TBool& aFullUpdate)
+    {
+    RArray<TFsTreeItemId> tempItems;
+    CleanupClosePushL(tempItems);
+    iWorld.GetItemsL(tempItems, iPosition.iY, iSize.iHeight, aOffset);
+    iCache.UpdateL(tempItems, aItemsToBeRemoved, aItemsToBeAdded, aFullUpdate);
+    CleanupStack::PopAndDestroy(); // tempItems
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::IsScrollBarNeeded
+// ---------------------------------------------------------------------------
+TBool TViewPort::IsScrollBarNeeded() const
+    {
+    return iWorld.Height() > iSize.iHeight;
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::UpdatedL
+// ---------------------------------------------------------------------------
+void TViewPort::UpdatedL()
+    {
+    iObserver.ViewPortUpdatedL(*this);
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::WorldUpdatedL
+// ---------------------------------------------------------------------------
+void TViewPort::WorldUpdatedL(const TWorld& aWorld)
+    {
+    // recreate viewable set if needed
+    if (iPosition.iY > aWorld.Height() || (iPosition.iY + iSize.iHeight
+            > aWorld.Height() && iSize.iHeight <= aWorld.Height()))
+        {
+        iPosition.iY = Max(0, aWorld.Height() - iSize.iHeight);
+        }
+    else if (iSize.iHeight > aWorld.Height() && iPosition.iY > 0)
+        {
+        iPosition.iY = 0;
+        }
+    iObserver.ViewPortUpdatedL(*this);
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::ScrollToItemL
+// ---------------------------------------------------------------------------
+void TViewPort::ScrollToItemL(const TFsTreeItemId aItemId,
+        TBool aInformUpdate)
+    {
+    TRect itemRect;
+    if (iWorld.GetItemRect(aItemId, itemRect) != KErrNotFound)
+        {
+        SetPositionL(itemRect.iTl, aInformUpdate);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::CenterToItemL
+// ---------------------------------------------------------------------------
+void TViewPort::CenterToItemL(const TFsTreeItemId aItemId,
+        TBool aInformUpdate)
+    {
+    TRect itemRect;
+    if (iWorld.GetItemRect(aItemId, itemRect) != KErrNotFound)
+        {
+        TInt top(itemRect.iTl.iY);
+        top -= (iSize.iHeight - itemRect.Height()) / 2;
+        LimitTop(top);
+        SetPositionL(TPoint(iPosition.iX, top), aInformUpdate);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::ItemToPositionL
+// Tries to scroll view so that given item is in given position aPosition.
+// ---------------------------------------------------------------------------
+void TViewPort::ItemToPositionL(const TFsTreeItemId aItemId,
+        const TPoint& aPosition, const TBool aInformUpdate,
+        const TPositionHint aHint)
+    {
+    TRect itemRect;
+    if (iWorld.GetItemRect(aItemId, itemRect) != KErrNotFound)
+        {
+        TInt top(itemRect.iTl.iY);
+        top -= aPosition.iY;
+        LimitTop(top);            
+        if (aHint == EPositionAfterExpand)
+            {
+            const TInt error( iWorld.GetItemRectByIndex(
+                    iWorld.IndexOfItem(aItemId) + 1, itemRect) );
+            if (!error)
+                {
+                if (itemRect.iBr.iY - top > iSize.iHeight)
+                    {
+                    top += itemRect.iBr.iY - top - iSize.iHeight;
+                    LimitTop(top);            
+                    }
+                }
+            }
+        SetPositionL(TPoint(iPosition.iX, top), aInformUpdate);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::ScrollItemToViewL
+// Scrolls item to view. Item is set as top most item, if it is above the current
+// display area or bottom most item if it is below the current display area.
+// ---------------------------------------------------------------------------
+void TViewPort::ScrollItemToViewL(const TFsTreeItemId aItemId,
+        TBool aInformUpdate)
+    {
+    TRect itemRect;
+    if (iWorld.GetItemRect(aItemId, itemRect) != KErrNotFound)
+        {
+        if (itemRect.iTl.iY < iPosition.iY)
+            {
+            SetPositionL(itemRect.iTl, aInformUpdate);
+            }
+        if (itemRect.iBr.iY > iPosition.iY + iSize.iHeight)
+            {
+            SetPositionL(
+                    TPoint(iPosition.iX, itemRect.iBr.iY - iSize.iHeight),
+                    aInformUpdate);
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::MakeViewFullyOccupiedL
+// ---------------------------------------------------------------------------
+void TViewPort::MakeViewFullyOccupiedL(TBool aInformUpdate)
+    {
+    TInt top(iPosition.iY);
+    LimitTop(top);
+    SetPositionL(TPoint(iPosition.iX, top), aInformUpdate);
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::TopItem
+// ---------------------------------------------------------------------------
+TFsTreeItemId TViewPort::TopItem() const
+    {
+    return iCache.TopItem();
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::ClearCache
+// ---------------------------------------------------------------------------
+void TViewPort::ClearCache()
+    {
+    iCache.Clear();
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::ItemRect
+// ---------------------------------------------------------------------------
+TRect TViewPort::ItemRect(const TFsTreeItemId aItemId) const
+    {
+    TRect itemRect;
+    if (!iCache.IsClear() && iCache.ContainsItem(aItemId))
+        {
+        if (iWorld.GetItemRect(aItemId, itemRect) != KErrNotFound)
+            {
+            itemRect.Move(0, -iPosition.iY);
+            }
+        }
+    return itemRect;
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::ItemFullyVisible
+// ---------------------------------------------------------------------------
+TBool TViewPort::ItemFullyVisible(const TFsTreeItemId aItemId) const
+    {
+    TBool result(EFalse);
+    if (!iCache.IsClear() && iCache.ContainsItem(aItemId))
+        {
+        TRect itemRect;
+        if (iWorld.GetItemRect(aItemId, itemRect) != KErrNotFound)
+            {
+            if (itemRect.Height())
+                {
+                const TRect viewRect(iPosition, iSize);
+                result = viewRect.Contains(itemRect.iTl)
+                        && viewRect.Contains(itemRect.iBr);
+                }
+            }
+        }
+    return result;
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::ItemRect
+// ---------------------------------------------------------------------------
+void TViewPort::LimitTop(TInt& aTop) const
+    {
+    aTop = Min(iWorld.Height() - iSize.iHeight, aTop);
+    aTop = Max(0, aTop);
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::TCache::TCache
+// ---------------------------------------------------------------------------
+TViewPort::TCache::TCache() :
+    iClear(ETrue)
+    {
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::TCache::~TCache
+// ---------------------------------------------------------------------------
+TViewPort::TCache::~TCache()
+    {
+    iCachedItems.Reset();
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::TCache::Clear
+// ---------------------------------------------------------------------------
+void TViewPort::TCache::Clear()
+    {
+    iClear = ETrue;
+    iCachedItems.Reset();
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::TCache::IsClear
+// ---------------------------------------------------------------------------
+TBool TViewPort::TCache::IsClear() const
+    {
+    return iClear;
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::TCache::ContainsItem
+// ---------------------------------------------------------------------------
+TBool TViewPort::TCache::ContainsItem(const TFsTreeItemId aItemId) const
+    {
+    return iCachedItems.Find(aItemId) != KErrNotFound;
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::TCache::UpdateL
+// ---------------------------------------------------------------------------
+void TViewPort::TCache::UpdateL(const RArray<TFsTreeItemId>& aItems, RArray<
+        TFsTreeItemId>& aItemsToBeRemoved,
+        RArray<TFsTreeItemId>& aItemsToBeAdded, TBool& aFullUpdate)
+    {
+    aFullUpdate = iClear;
+    if (!iClear)
+        {
+        // find items in cache, missing in new set => items to be removed
+        aItemsToBeRemoved.Reset();
+        for (TInt i = 0; i < iCachedItems.Count(); i++)
+            {
+            if (aItems.Find(iCachedItems[i]) == KErrNotFound)
+                {
+                aItemsToBeRemoved.AppendL(iCachedItems[i]);
+                }
+            }
+
+        // find items in new set, missing in cache => items to be added
+        aItemsToBeAdded.Reset();
+        for (TInt i = 0; i < aItems.Count(); i++)
+            {
+            if (iCachedItems.Find(aItems[i]) == KErrNotFound)
+                {
+                aItemsToBeAdded.AppendL(aItems[i]);
+                }
+            else
+                {
+                aItemsToBeAdded.AppendL(KFsTreeNoneID);
+                }
+            }
+        }
+    else
+        {
+        // find items in new set, missing in cache => items to be added
+        aItemsToBeAdded.Reset();
+        for (TInt i = 0; i < aItems.Count(); i++)
+            {
+            aItemsToBeAdded.AppendL(aItems[i]);
+            }
+        }
+    // finally update cache
+    iCachedItems.Reset();
+    for (TInt i = 0; i < aItems.Count(); i++)
+        {
+        iCachedItems.AppendL(aItems[i]);
+        }
+    iClear = EFalse;
+    }
+
+// ---------------------------------------------------------------------------
+// TViewPort::TCache::TopItem
+// ---------------------------------------------------------------------------
+TFsTreeItemId TViewPort::TCache::TopItem() const
+    {
+    if (iClear || !iCachedItems.Count())
+        {
+        return KFsTreeNoneID;
+        }
+    return iCachedItems[0];
+    }
+
+// ---------------------------------------------------------------------------
+// Two-phased constructor.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CFsTreeVisualizerBase* CFsTreeVisualizerBase::NewL(
+        CAlfControl* aOwnerControl, CAlfLayout& aParent,
+        const TBool aDirectTouchMode)
+    {
+    FUNC_LOG;
+    CFsTreeVisualizerBase* self = new (ELeave) CFsTreeVisualizerBase(
+            aOwnerControl, aParent, aDirectTouchMode);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+// C++ destructor.
+// ---------------------------------------------------------------------------
+//
+CFsTreeVisualizerBase::~CFsTreeVisualizerBase()
+    {
+    FUNC_LOG;
+    delete iDragHandler;
+    delete iPhysics;
+    if (iOwnerControl)
+        {
+        iOwnerControl->Env().RemoveActionObserver(this);
+        }
+    delete iBorderBrush;
+    iVisibleItems.Close();
+    iVisibleItemsBackground.Close();
+    iCustomPageUpKeys.Close();
+    iCustomPageDownKeys.Close();
+    delete iFadeEffect;
+    delete iSlideEffect;
+    delete iWatermark;
+    delete iTextStyleManager;
+    delete iIntx;
+    // <cmail> Change scrollbar to avkon (to support skinning & touch)
+    delete iScrollBar;
+    // </cmail>
+    }
+
+// ---------------------------------------------------------------------------
+//Sets data model for the visualizer.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetTreeData(CFsTree& aTreeData)
+    {
+    FUNC_LOG;
+    iTreeData = &aTreeData;
+    }
+
+// ---------------------------------------------------------------------------
+// Adds custom key which triggers page-up event.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::AddCustomPageUpKey(TInt aKeyCode)
+    {
+    FUNC_LOG;
+    iCustomPageUpKeys.InsertInOrder(aKeyCode);
+    }
+
+// ---------------------------------------------------------------------------
+// Removes given key code from custom page-up event key codes.
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::RemoveCustomPageUpKey(TInt aKeyCode)
+    {
+    FUNC_LOG;
+    TBool keyRemoved = EFalse;
+
+    TInt index = iCustomPageUpKeys.FindInOrder(aKeyCode);
+    if (index != KErrNotFound)
+        {
+        iCustomPageUpKeys.Remove(index);
+        keyRemoved = ETrue;
+        }
+
+    return keyRemoved;
+    }
+
+// ---------------------------------------------------------------------------
+// Checks whether given key is a custom key for page-up event.
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::IsCustomPageUpKey(TInt aKeyCode)
+    {
+    FUNC_LOG;
+    TBool keyExists = EFalse;
+    TInt index = iCustomPageUpKeys.FindInOrder(aKeyCode);
+    if (index != KErrNotFound)
+        {
+        keyExists = ETrue;
+        }
+    return keyExists;
+    }
+
+// ---------------------------------------------------------------------------
+// Adds custom key which triggers page-down event.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::AddCustomPageDownKey(TInt aKeyCode)
+    {
+    FUNC_LOG;
+    iCustomPageDownKeys.InsertInOrder(aKeyCode);
+    }
+
+// ---------------------------------------------------------------------------
+// Removes given key code from custom page-down event key codes.
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::RemoveCustomPageDownKey(TInt aKeyCode)
+    {
+    FUNC_LOG;
+    TBool keyRemoved = EFalse;
+
+    TInt index = iCustomPageDownKeys.FindInOrder(aKeyCode);
+    if (index != KErrNotFound)
+        {
+        iCustomPageDownKeys.Remove(index);
+        keyRemoved = ETrue;
+        }
+
+    return keyRemoved;
+    }
+
+// ---------------------------------------------------------------------------
+//  Checks whether given key is a custom key for page-down event.
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::IsCustomPageDownKey(TInt aKeyCode)
+    {
+    FUNC_LOG;
+    TBool keyExists = EFalse;
+    TInt index = iCustomPageDownKeys.FindInOrder(aKeyCode);
+    if (index != KErrNotFound)
+        {
+        keyExists = ETrue;
+        }
+    return keyExists;
+    }
+
+// ---------------------------------------------------------------------------
+//  Sets icon for a mark sign.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetMarkIcon(CAlfTexture& aMarkIcon)
+    {
+    FUNC_LOG;
+    iMarkIcon = &aMarkIcon;
+    }
+
+// ---------------------------------------------------------------------------
+//  Returns icon used to mark items.
+// ---------------------------------------------------------------------------
+//
+CAlfTexture* CFsTreeVisualizerBase::MarkIcon()
+    {
+    FUNC_LOG;
+    return iMarkIcon;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::IsMarked(const TFsTreeItemId aItemId) const
+    {
+    FUNC_LOG;
+    MFsTreeItemVisualizer* vis = NULL;
+    vis = iTreeData->ItemVisualizer(aItemId);
+    return vis->IsMarked();
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::MarkItemL(const TFsTreeItemId aItemId,
+        TBool aMarked)
+    {
+    FUNC_LOG;
+    MFsTreeItemVisualizer* vis = NULL;
+    vis = iTreeData->ItemVisualizer(aItemId);
+    vis->SetMarked(aMarked);
+    if (iVisibleItems.Find(aItemId) != KErrNotFound)
+        {
+        MFsTreeItemData* data = NULL;
+        data = &(iTreeData->ItemData(aItemId));
+
+        vis->UpdateL(*data, IsItemFocused(aItemId) && IsFocusShown(),
+                iTreeData->Level(aItemId), iMarkIcon, iMenuIcon);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::GetMarkedItemsL(RFsTreeItemIdList& aMarkedItems) const
+    {
+    FUNC_LOG;
+    TFsTreeIterator treeIter = iTreeData->Iterator(KFsTreeRootID,
+            KFsTreeRootID);
+    TFsTreeItemId itemId;
+    MFsTreeItemVisualizer* vis = NULL;
+    while (treeIter.HasNext())
+        {
+        itemId = treeIter.Next();
+        vis = iTreeData->ItemVisualizer(itemId);
+        if (vis->IsMarked())
+            {
+            aMarkedItems.AppendL(itemId);
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  Function marks/unmarks all items in the list.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::MarkAllItemsL(TBool aMarkAll)
+    {
+    FUNC_LOG;
+    TFsTreeIterator treeIter = iTreeData->Iterator(KFsTreeRootID,
+            KFsTreeRootID);
+    TFsTreeItemId itemId;
+    MFsTreeItemVisualizer* vis = NULL;
+    while (treeIter.HasNext())
+        {
+        itemId = treeIter.Next();
+        vis = iTreeData->ItemVisualizer(itemId);
+        vis->SetMarked(aMarkAll);
+        }
+    RefreshListViewL();
+    }
+
+// ---------------------------------------------------------------------------
+//  Sets item indentation per hierarchy level.
+// ---------------------------------------------------------------------------
+void CFsTreeVisualizerBase::SetIndentationL(TInt aIndentation)
+    {
+    FUNC_LOG;
+    iLevelIndentation = aIndentation;
+
+    MFsTreeItemVisualizer* vis = NULL;
+    TFsTreeItemId itemId = KFsTreeNoneID;
+    //loop through the list and set items to always-extended state.
+    TFsTreeIterator iter = iTreeData->Iterator(KFsTreeRootID, KFsTreeRootID);
+    while (iter.HasNext())
+        {
+        itemId = iter.Next();
+        //get item's visualizer
+        vis = iTreeData->ItemVisualizer(itemId);
+        //set indentation in pixels
+        vis->SetIndentation(iLevelIndentation);
+        }
+
+    //refresh the list view
+    RefreshListViewL();
+    }
+
+// ---------------------------------------------------------------------------
+//  Returns indentation per hierarchy level in pixels.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::Indentation() const
+    {
+    FUNC_LOG;
+    return iLevelIndentation;
+    }
+
+// ---------------------------------------------------------------------------
+//  Sets icon for a menu sign.
+// ---------------------------------------------------------------------------
+void CFsTreeVisualizerBase::SetMenuIcon(CAlfTexture& aMenuIcon)
+    {
+    FUNC_LOG;
+    iMenuIcon = &aMenuIcon;
+    }
+
+// ---------------------------------------------------------------------------
+//  Returns menu icon.
+// ---------------------------------------------------------------------------
+CAlfTexture* CFsTreeVisualizerBase::MenuIcon() const
+    {
+    FUNC_LOG;
+    return iMenuIcon;
+    }
+
+// ---------------------------------------------------------------------------
+//  Used internally by the list. To make the list focused/not focused use
+//  CFsTreeList::SetFocusedL() instead.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetFocusedL(const TBool aFocused)
+    {
+    FUNC_LOG;
+    if (iDragHandler && !aFocused)
+        {
+        iDragHandler->Reset();
+        }
+    if (iFlags.IsSet(EListFocused) != aFocused)
+        {
+        iFlags.Assign(EListFocused, aFocused);
+        if (iTreeData->Count())
+            {
+            if (iFlags.IsSet(EListFocused))
+                {
+                //list will receive focus
+                if (iFocusedItem == KFsTreeNoneID)
+                    {
+                    TFsTreeIterator treeIter = iTreeData->Iterator(
+                            KFsTreeRootID, KFsTreeRootID,
+                            KFsTreeIteratorSkipCollapsedFlag
+                                    | KFsTreeIteratorSkipHiddenFlag);
+
+                    TFsTreeItemId id(KFsTreeNoneID);
+                    MFsTreeItemVisualizer* visualizer(NULL);
+                    id = treeIter.First();
+                    visualizer = iTreeData->ItemVisualizer(id);
+                    if (visualizer)
+                        {
+                        if (visualizer->IsFocusable())
+                            {
+                            iFocusedItem = id;
+                            }
+                        }
+                    }
+                // a workaround to make SetFocusedItemL work with timeout
+                SetFocusedItemL(iFocusedItem);
+                MakeSelectorVisibleL(ETrue);
+                }
+            else
+                {
+                if (iFocusedItem != KFsTreeNoneID)
+                    {
+                    //list will loose focus
+                    MFsTreeItemVisualizer* visualizer =
+                            iTreeData->ItemVisualizer(iFocusedItem);
+                    if (visualizer)
+                        {
+                        TInt index(iListLayout->FindVisual(
+                                &visualizer->Layout()));
+                        if (index != KErrNotFound)
+                            {
+                            MFsTreeItemData* data = &iTreeData->ItemData(
+                                    iFocusedItem);
+                            MakeSelectorVisibleL(EFalse);
+                            visualizer->UpdateL(*data, EFalse,
+                                    iTreeData->Level(iFocusedItem),
+                                    iMarkIcon, iMenuIcon, iCurrentScrollSpeed);
+                            }
+                        }
+                    }
+                }
+            iListLayout->UpdateChildrenLayout();
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// The function sets some properties of the selector like bitmap, type
+// of movement.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetSelectorPropertiesL(CAlfTexture* aTexture,
+        TFsSelectorMovement aMovementType, TInt aLeftBorderWidth,
+        TInt aRightBorderWidth, TInt aTopBorderHeight,
+        TInt aBottomBorderHeight)
+    {
+    FUNC_LOG;
+    iSelectorTexture = aTexture;
+    iSelectorBrush = NULL;
+    iSelectorMovementType = aMovementType;
+    iSelectorOpacity = 1.0;
+
+    iLeftSelectorBorderWidth = aLeftBorderWidth;
+    iRightSelectorBorderWidth = aRightBorderWidth;
+    iTopSelectorBorderHeight = aTopBorderHeight;
+    iBottomSelectorBorderHeight = aBottomBorderHeight;
+
+    DestroySelectorVisualL();
+    MakeSelectorVisibleL(ETrue);
+    }
+
+// ---------------------------------------------------------------------------
+// The function sets some properties of the selector.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetSelectorPropertiesL(CAlfBrush* aSelectorBrush,
+        TReal32 aOpacity, TFsSelectorMovement aMovementType)
+    {
+    FUNC_LOG;
+    iSelectorTexture = NULL;
+    iSelectorBrush = aSelectorBrush;
+    iSelectorMovementType = aMovementType;
+    //check value, selector cannot be fully transparent ( <= 0.0 )
+    if (aOpacity <= 0.0 || aOpacity > 1.0)
+        {
+        iSelectorOpacity = 1.0;
+        }
+    else
+        {
+        iSelectorOpacity = aOpacity;
+        }
+
+    iLeftSelectorBorderWidth = 0;
+    iRightSelectorBorderWidth = 0;
+    iTopSelectorBorderHeight = 0;
+    iBottomSelectorBorderHeight = 0;
+
+    DestroySelectorVisualL();
+    MakeSelectorVisibleL(ETrue);
+    }
+
+// ---------------------------------------------------------------------------
+// The function returnes selector's properties.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::GetSelectorProperties(CAlfTexture*& aTexture,
+        TFsSelectorMovement& aMovementType, TInt& aLeftBorderWidth,
+        TInt& aRightBorderWidth, TInt& aTopBorderHeight,
+        TInt& aBottomBorderHeight)
+    {
+    FUNC_LOG;
+    aTexture = iSelectorTexture;
+    aMovementType = iSelectorMovementType;
+
+    aLeftBorderWidth = iLeftSelectorBorderWidth;
+    aRightBorderWidth = iRightSelectorBorderWidth;
+    aTopBorderHeight = iTopSelectorBorderHeight;
+    aBottomBorderHeight = iBottomSelectorBorderHeight;
+    }
+
+// ---------------------------------------------------------------------------
+// The function sets a text for empty list's view.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetEmptyListTextL(const TDesC& aText)
+    {
+    FUNC_LOG;
+    if (iRootData)
+        {
+        iRootData->SetDataL(aText);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// The function returns a text for empty list's view.
+// ---------------------------------------------------------------------------
+//
+TDesC& CFsTreeVisualizerBase::GetEmptyListText() const
+    {
+    FUNC_LOG;
+    return iRootData->Data();
+    }
+
+// ---------------------------------------------------------------------------
+//  Handles key event forwarded by the controller.
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::HandleKeyEventL(const TAlfEvent& aEvent)
+    {
+    //ignore  KeyUp events
+    TBool eventHandled = aEvent.Code() == EEventKeyUp;
+
+    if (iTreeData->Count() && (!eventHandled))
+        {
+        TInt nowOffset = iListLayout->ScrollOffset().iY.ValueNow();
+        TInt targetOffset = iListLayout->ScrollOffset().iY.Target();
+
+        if (!(iFlags.IsSet(EIsPageUpDownActive)
+                && (nowOffset != targetOffset)))
+            {
+            iFlags.Clear(EIsPageUpDownActive);
+
+            switch (aEvent.KeyEvent().iScanCode)
+                {
+                case EStdKeyUpArrow:
+                    {
+                    if (iFocusedItem != KFsTreeNoneID)
+                        {
+                        SetCurrentScrollSpeed(aEvent.KeyEvent().iRepeats);
+                        MoveSelectionL(EFsTreeVisualizerMoveLineUp);
+                        //iCurrentScrollSpeed = iScrollSpeed;
+                        }
+                    eventHandled = ETrue;
+                    break;
+                    }
+                case EStdKeyDownArrow:
+                    {
+                    if (iFocusedItem != KFsTreeNoneID)
+                        {
+                        SetCurrentScrollSpeed(aEvent.KeyEvent().iRepeats);
+                        MoveSelectionL(EFsTreeVisualizerMoveLineDown);
+                        //iCurrentScrollSpeed = iScrollSpeed;
+                        }
+                    eventHandled = ETrue;
+                    break;
+                    }
+                case EStdKeyLeftArrow:
+                    {
+                    if (iVisualizerObserver)
+                        {
+                        // <cmail> Touch
+                        iVisualizerObserver->TreeVisualizerEventL(
+                                MFsTreeVisualizerObserver::EFsTreeKeyLeftArrow,
+                                iFocusedItem);
+                        // </cmail>
+                        }
+                    eventHandled = ETrue;
+                    break;
+                    }
+                case EStdKeyRightArrow:
+                    {
+                    if (iVisualizerObserver)
+                        {
+                        // <cmail>
+                        iVisualizerObserver->TreeVisualizerEventL(
+                                MFsTreeVisualizerObserver::EFsTreeKeyRightArrow,
+                                iFocusedItem);
+                        // </cmail>
+                        }
+                    eventHandled = ETrue;
+                    break;
+                    }
+                case EStdKeyDevice3:
+                    {
+                    if (iTreeData->IsNode(iFocusedItem))
+                        {
+                        if (iTreeData->NodeVisualizer(iFocusedItem)->IsExpanded())
+                            {
+                            CollapseNodeL(iFocusedItem);
+                            }
+                        else
+                            {
+                            ExpandNodeL(iFocusedItem);
+                            }
+                        }
+                    else
+                        {
+                        if (iVisualizerObserver)
+                            {
+                            if (iTreeData->ItemVisualizer(iFocusedItem)->Menu())
+                                {
+                                // <cmail> Touch
+                                iVisualizerObserver->TreeVisualizerEventL(
+                                        MFsTreeVisualizerObserver::EFsTreeItemWithMenuSelected,
+                                        iFocusedItem);
+                                }
+                            else
+                                {
+                                iVisualizerObserver->TreeVisualizerEventL(
+                                        MFsTreeVisualizerObserver::EFsTreeItemSelected,
+                                        iFocusedItem);
+                                // </cmail>
+                                }
+                            }
+                        }
+                    eventHandled = ETrue;
+                    break;
+                    }
+                default:
+                    {
+                    // the visualizer ignores all other events
+                    break;
+                    }
+                }
+            //page up/down
+            if (!eventHandled)
+                {
+                if (IsCustomPageUpKey(aEvent.KeyEvent().iScanCode))
+                    {
+                    SetCurrentScrollSpeed(aEvent.KeyEvent().iRepeats);
+                    MoveSelectionL(EFsTreeVisualizerMovePageUp);
+                    iFlags.Set(EIsPageUpDownActive);
+                    eventHandled = ETrue;
+                    //iCurrentScrollSpeed = iScrollSpeed;
+                    }
+                else if (IsCustomPageDownKey(aEvent.KeyEvent().iScanCode))
+                    {
+                    SetCurrentScrollSpeed(aEvent.KeyEvent().iRepeats);
+                    MoveSelectionL(EFsTreeVisualizerMovePageDown);
+                    iFlags.Set(EIsPageUpDownActive);
+                    eventHandled = ETrue;
+                    //iCurrentScrollSpeed = iScrollSpeed;
+                    }
+                }
+            }
+        else
+            {
+            eventHandled = EFalse;
+            }
+        }
+    else
+        {
+        eventHandled = EFalse;
+        }
+
+    return eventHandled;
+    }
+
+// ---------------------------------------------------------------------------
+// CFsTreeVisualizerBase::SetFlipState
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetFlipState( TBool aOpen )
+    {
+    iFlipOpen = aOpen;
+    }
+
+// ---------------------------------------------------------------------------
+// CFsTreeVisualizerBase::SetFocusVisibility
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetFocusVisibility( TBool aShow )
+    {
+    if( iFocusVisible != aShow )
+        {
+        iFocusVisible = aShow;
+        TRAP_IGNORE(
+            MakeSelectorVisibleL(aShow);
+            UpdateItemL(iFocusedItem); );
+        }
+    }
+
+// <cmail> "Base class modifications for using touch"
+
+// ---------------------------------------------------------------------------
+// CFsTreeVisualizerBase::HandlePointerEventL
+//
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::HandlePointerEventL(const TAlfEvent& aEvent)
+    {
+    TBool eventHandled(EFalse);
+    if (iDragHandler && iOwnerControl->ControlGroup()->AcceptInput())
+        {
+        TPointerEvent::TType type = aEvent.PointerEvent().iType;
+        const TInt id(EventItemId(aEvent));
+        INFO_1("visual: $%x", aEvent.Visual());
+        if (KErrNotFound != id || type == TPointerEvent::EDrag || 
+                type  == TPointerEvent::EButtonRepeat || 
+                type  == TPointerEvent::EButton1Up)
+            {
+            switch (type)
+                {
+                case TPointerEvent::EButton1Down:
+                    {
+                    eventHandled = ETrue;
+                    iTouchPressed = ETrue;
+                    const TPoint& pos(aEvent.PointerEvent().iParentPosition);
+                    INFO_2("EButton1Down (%d, %d)", pos.iX, pos.iY);
+                    if (!iFlags.IsSet(EPhysicsOn))
+                        {
+                        iPhysics->StopPhysics();
+                        iPhysics->ResetFriction();
+                        UpdatePhysicsL();
+                        }
+                    iDragHandler->PointerDown(aEvent.PointerEvent(), id);
+                    break;
+                    }
+                case TPointerEvent::EButton1Up:
+                    {
+                    const TPoint& pos(aEvent.PointerEvent().iParentPosition);
+                    if( iTouchPressed )
+                        {
+                        eventHandled = ETrue;
+                        iTouchPressed = EFalse;
+                        UpdateItemL( iFocusedItem );
+                        if( !IsFocusShown() )
+                            {
+                            MakeSelectorVisibleL( EFalse );
+                            }
+                        INFO_2( "EButton1Up (%d, %d)", pos.iX, pos.iY );
+                        if( !iDragHandler->IsFlicking() )
+                            {
+                            iPhysics->StopPhysics();
+                            }
+                        iDragHandler->PointerUp( aEvent.PointerEvent(), id );
+                        }
+                    break;
+                    }
+                case TPointerEvent::EDrag:
+                    {
+                    eventHandled = ETrue;
+                    const TPoint& pos(aEvent.PointerEvent().iPosition);
+                    INFO_2("EDrag (%d, %d)", pos.iX, pos.iY);
+                    if (iDragHandler->IsFlicking()
+                            || iDragHandler->DragDelta(aEvent.PointerEvent())
+                                    >= iPhysics->DragThreshold())
+                        {
+                        iDragHandler->PointerDrag(aEvent.PointerEvent(), id);
+                        iDragHandler->EnableFlicking();
+                        }
+                    break;
+                    }
+
+                case TPointerEvent::EButtonRepeat:
+                    {
+                    eventHandled = ETrue;
+                    const TPoint& pos(aEvent.PointerEvent().iParentPosition);
+                    INFO_2("EButtonRepeat (%d, %d)", pos.iX, pos.iY);
+                    iDragHandler->PointerRepeat(aEvent.PointerEvent());
+                    break;
+                    }
+
+                default:
+                    {
+                    //Unknown event, ignore.
+                    break;
+                    }
+                }
+            }
+        }
+    return eventHandled;
+    }
+// ---------------------------------------------------------------------------
+//  CFsTreeVisualizerBase::EventItemId
+// ---------------------------------------------------------------------------
+//
+TFsTreeItemId CFsTreeVisualizerBase::EventItemId(const TAlfEvent& aEvent) const
+    {
+    FUNC_LOG;
+    if (aEvent.Type() == TPointerEvent::EDrag)
+        {
+        return VisualItemId(FindVisualUnderDrag(
+                aEvent.PointerEvent().iPosition));
+        }
+    else
+        {
+        return VisualItemId(aEvent.Visual());
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  CFsTreeVisualizerBase::FindVisualUnderDrag
+// ---------------------------------------------------------------------------
+//
+const CAlfVisual* CFsTreeVisualizerBase::FindVisualUnderDrag(
+        const TPoint& aPosition) const
+    {
+    FUNC_LOG;
+    for (TInt i = 0; i < iListLayout->Count(); i++)
+        {
+        const TRect displayRect(iListLayout->Visual(i).DisplayRectTarget());
+        if (displayRect.Contains(aPosition))
+            {
+            return &iListLayout->Visual(i);
+            }
+        }
+    return NULL;
+    }
+
+// ---------------------------------------------------------------------------
+//  CFsTreeVisualizerBase::VisualItemId
+// ---------------------------------------------------------------------------
+//
+TFsTreeItemId CFsTreeVisualizerBase::VisualItemId(const CAlfVisual* aVisual) const
+    {
+    FUNC_LOG;
+    TInt itemId(KErrNotFound);
+    if (aVisual)
+        {
+        aVisual->PropertyFindInteger(KPropertyItemId(), &itemId);
+        }
+    return itemId;
+    }
+
+// ---------------------------------------------------------------------------
+// Sets the specified item as focused.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetFocusedItemL(const TFsTreeItemId aItemId,
+        TBool /*aCheckFocus*/)
+    {
+    FUNC_LOG;
+    MFsTreeItemVisualizer* visualizer = NULL;
+    if (aItemId != iFocusedItem)
+        {
+        visualizer = iTreeData->ItemVisualizer(iFocusedItem);
+        if (visualizer)
+            {
+            visualizer->UpdateL(iTreeData->ItemData(iFocusedItem), EFalse,
+                    iTreeData->Level(iFocusedItem), iMarkIcon, iMenuIcon, 0);
+            }
+        iFocusedItem = aItemId;
+        }
+    visualizer = iTreeData->ItemVisualizer(iFocusedItem);
+    if (visualizer)
+        {
+        TBool focused = IsFocusShown();    
+        visualizer->UpdateL(iTreeData->ItemData(iFocusedItem), focused,
+                iTreeData->Level(iFocusedItem), iMarkIcon, iMenuIcon, 0);
+        }
+    if (iFocusedItem != KFsTreeNoneID)
+        {
+        UpdateSelectorVisualL();
+        if (!iViewPort.ItemFullyVisible(iFocusedItem))
+            {
+            iViewPort.ScrollItemToViewL(iFocusedItem);
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Checks if the specified item is focused.
+// ---------------------------------------------------------------------------
+//
+TFsTreeItemId CFsTreeVisualizerBase::FocusedItem() const
+    {
+    FUNC_LOG;
+    return iFocusedItem;
+    }
+
+// ---------------------------------------------------------------------------
+// Checks if the specified item is focused.
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::IsFocused(const TFsTreeItemId aItemId) const
+    {
+    FUNC_LOG;
+    return iFocusedItem == aItemId ? ETrue : EFalse;
+    }
+
+// ---------------------------------------------------------------------------
+// Sets an item as first visible one in the list.
+// ---------------------------------------------------------------------------
+//
+// <cmail>
+void CFsTreeVisualizerBase::SetFirstVisibleItemL(const TFsTreeItemId /*aItemId*/)
+    {
+    FUNC_LOG;
+    }
+
+// ---------------------------------------------------------------------------
+// Get an id of the first visible item.
+// ---------------------------------------------------------------------------
+//
+TFsTreeItemId CFsTreeVisualizerBase::FirstVisibleItem()
+    {
+    FUNC_LOG;
+    TFsTreeItemId retId = KFsTreeNoneID;
+    if (iVisibleItems.Count())
+        {
+        // <cmail>
+        //        TRAP_IGNORE( ClearVisibleItemsListL(EFalse) );
+        // </cmail>
+        retId = iVisibleItems[0];
+        }
+    else
+        {
+        retId = KFsTreeNoneID;
+        }
+    return retId;
+    }
+
+// ---------------------------------------------------------------------------
+// Gets a pointer to the root's item data object.
+// ---------------------------------------------------------------------------
+//
+MFsTreeItemData* CFsTreeVisualizerBase::RootItemData()
+    {
+    FUNC_LOG;
+    return iRootData;
+    }
+
+// ---------------------------------------------------------------------------
+// Gets a pointer to the root's item visualizer object.
+// ---------------------------------------------------------------------------
+//
+MFsTreeNodeVisualizer* CFsTreeVisualizerBase::RootNodeVisualizer()
+    {
+    FUNC_LOG;
+    return iRootVisualizer;
+    }
+
+// ---------------------------------------------------------------------------
+// Displays the list.
+// ---------------------------------------------------------------------------
+//
+// <cmail>
+void CFsTreeVisualizerBase::ShowListL(const TBool aFadeIn,
+        const TBool aSlideIn)
+    {
+    FUNC_LOG;
+    UpdateViewPortL();
+    if (iTreeData->Count() == 0)
+        {
+        iRootVisualizer->ShowL(*iRootLayout);
+        iRootVisualizer->UpdateL(*iRootData, EFalse, 0, iMarkIcon, iMenuIcon);
+        }
+    else
+        {
+        TBool showFocus = IsFocusShown();
+        for (TUint i = 0; i < iVisibleItems.Count(); ++i)
+            {
+            TFsTreeItemId itemId(iVisibleItems[i]);
+            MFsTreeItemVisualizer* visualizer = iTreeData->ItemVisualizer(
+                    itemId);
+
+            TBool itemFocused( EFalse );
+            if( showFocus ) 
+                {
+                itemFocused = IsItemFocused(itemId);
+                }
+            visualizer->UpdateL(iTreeData->ItemData(itemId), itemFocused,
+                    iTreeData->Level(itemId), iMarkIcon, iMenuIcon,
+                    0);
+            }
+        }
+
+    TInt fadeInTime(KZero), slideInTime(KZero);
+    CFsSlideEffect::TSlideEffectDirection slideInDir(
+            CFsSlideEffect::ESlideNone);
+
+    iVisualizationState = EFsTreeVisible;
+
+    if (aFadeIn)
+        {
+        fadeInTime = iFadeInEffectTime;
+        if (aSlideIn)
+            {
+            iVisualizationState = EFsTreeFadingInSlidingIn;
+            }
+        else
+            {
+            iVisualizationState = EFsTreeFadingIn;
+            }
+        }
+    else
+        {
+        fadeInTime = KZero;
+        }
+
+    if (aSlideIn)
+        {
+        slideInTime = iSlideInDuration;
+        switch (iSlideInDirection)
+            {
+            case MFsTreeVisualizer::ESlideFromTop:
+                {
+                slideInDir = CFsSlideEffect::ESlideFromTop;
+                break;
+                }
+            case MFsTreeVisualizer::ESlideFromBottom:
+                {
+                slideInDir = CFsSlideEffect::ESlideFromBottom;
+                break;
+                }
+            case MFsTreeVisualizer::ESlideFromLeft:
+                {
+                slideInDir = CFsSlideEffect::ESlideFromLeft;
+                break;
+                }
+            case MFsTreeVisualizer::ESlideFromRight:
+                {
+                slideInDir = CFsSlideEffect::ESlideFromRight;
+                break;
+                }
+            case MFsTreeVisualizer::ESlideNone:
+            default:
+                {
+                slideInDir = CFsSlideEffect::ESlideNone;
+                break;
+                }
+            }
+        iVisualizationState = EFsTreeFadingInSlidingIn;
+        }
+    else
+        {
+        slideInTime = KZero;
+        slideInDir = CFsSlideEffect::ESlideNone;
+        }
+
+    iFadeEffect->SetTime(fadeInTime);
+    iSlideEffect->SetTime(slideInTime);
+
+    iFadeEffect->FadeIn();
+    iSlideEffect->SlideIn(slideInDir);
+
+    UpdateScrollBarL();
+    }
+// </cmail>
+
+// ---------------------------------------------------------------------------
+// The function assures that the list view is correct.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::ValidateListLayoutL(TInt /*aTime*/)
+    {
+    FUNC_LOG;
+    }
+
+// ---------------------------------------------------------------------------
+// Hides the list.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::HideList(const TBool aFadeOut,
+        const TBool aSlideOut)
+    {
+    FUNC_LOG;
+    iScrollBar->MakeVisible(EFalse);
+    if (iDragHandler)
+        {
+        iDragHandler->Reset();
+        }
+
+    if (aFadeOut)
+        {
+        iFadeEffect->SetTime(iFadeOutEffectTime);
+        iVisualizationState = EFsTreeFadingOut;
+        iFadeEffect->FadeOut();
+        }
+
+    if (aSlideOut)
+        {
+        iSlideEffect->SetTime(iSlideOutDuration);
+        if (iVisualizationState == EFsTreeFadingOut)
+            {
+            iVisualizationState = EFsTreeFadingOutSlidingOut;
+            }
+        else
+            {
+            iVisualizationState = EFsTreeSlidingOut;
+            }
+        switch (iSlideOutDirection)
+            {
+            case MFsTreeVisualizer::ESlideFromTop:
+                {
+                iSlideEffect->SlideOut(CFsSlideEffect::ESlideFromTop);
+                break;
+                }
+            case MFsTreeVisualizer::ESlideFromBottom:
+                {
+                iSlideEffect->SlideOut(CFsSlideEffect::ESlideFromBottom);
+                break;
+                }
+            case MFsTreeVisualizer::ESlideFromLeft:
+                {
+                iSlideEffect->SlideOut(CFsSlideEffect::ESlideFromLeft);
+                break;
+                }
+            case MFsTreeVisualizer::ESlideFromRight:
+                {
+                iSlideEffect->SlideOut(CFsSlideEffect::ESlideFromRight);
+                break;
+                }
+            case MFsTreeVisualizer::ESlideNone:
+            default:
+                {
+                iSlideEffect->SlideOut(CFsSlideEffect::ESlideNone);
+                break;
+                }
+            }
+        }
+
+    if (!aFadeOut && !aSlideOut)
+        {
+        iVisualizationState = EFsTreeFadingOut;
+        iFadeEffect->SetTime(KZero);
+        iFadeEffect->FadeOut();
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  The function sets duration of the slide-in effect.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetSlideInDuration(TInt aTimeMiliseconds)
+    {
+    FUNC_LOG;
+    iSlideInDuration = aTimeMiliseconds;
+    if (iSlideInDuration < KZero)
+        {
+        iSlideInDuration = KZero;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  The function returns slide in effect's duration.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::SlideInDuration() const
+    {
+    FUNC_LOG;
+    return iSlideInDuration;
+    }
+
+// ---------------------------------------------------------------------------
+//  The function sets direction of the slide in effect.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetSlideInDirection(TFsSlideEffect aDirection)
+    {
+    FUNC_LOG;
+    iSlideInDirection = aDirection;
+    }
+
+// ---------------------------------------------------------------------------
+//  The function returns direction of the slide in effect.
+// ---------------------------------------------------------------------------
+//
+MFsTreeVisualizer::TFsSlideEffect CFsTreeVisualizerBase::SlideInDirection() const
+    {
+    FUNC_LOG;
+    return iSlideInDirection;
+    }
+
+// ---------------------------------------------------------------------------
+//  The function sets duration of the slide-out effect.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetSlideOutDuration(TInt aTimeMiliseconds)
+    {
+    FUNC_LOG;
+    iSlideOutDuration = aTimeMiliseconds;
+    if (iSlideOutDuration < 0)
+        {
+        iSlideOutDuration = 0;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  The function returns slide out effect's duration.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::SlideOutDuration() const
+    {
+    FUNC_LOG;
+    return iSlideOutDuration;
+    }
+
+// ---------------------------------------------------------------------------
+//  The function sets direction of the slide out effect.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetSlideOutDirection(TFsSlideEffect aDirection)
+    {
+    FUNC_LOG;
+    iSlideOutDirection = aDirection;
+    }
+
+// ---------------------------------------------------------------------------
+//  The function returns direction of the slide out effect.
+// ---------------------------------------------------------------------------
+//
+MFsTreeVisualizer::TFsSlideEffect CFsTreeVisualizerBase::SlideOutDirection() const
+    {
+    return iSlideOutDirection;
+    }
+
+// ---------------------------------------------------------------------------
+// Returns information about looping type of the list.
+// ---------------------------------------------------------------------------
+//
+TFsTreeListLoopingType CFsTreeVisualizerBase::LoopingType() const
+    {
+    FUNC_LOG;
+    return iLooping;
+    }
+
+// ---------------------------------------------------------------------------
+// Sets type of list's looping.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetLoopingType(
+        const TFsTreeListLoopingType aLoopingType)
+    {
+    FUNC_LOG;
+    iLooping = aLoopingType;
+    }
+
+// ---------------------------------------------------------------------------
+// Sets item expansion delay.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetItemExpansionDelay(const TInt aDelay)
+    {
+    FUNC_LOG;
+    iScrollSpeed = aDelay;
+    if (iScrollSpeed < 0)
+        {
+        iScrollSpeed = 0;
+        }
+
+    iCurrentScrollSpeed = iScrollSpeed;
+    iScrollAccelerationRate = 0.5;
+    }
+
+// ---------------------------------------------------------------------------
+// Sets an item separator color.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetItemSeparatorColor(const TRgb& aColor)
+    {
+    FUNC_LOG;
+    static_cast<CAlfBorderBrush*> (iBorderBrush)->SetColor(aColor);
+    }
+
+// ---------------------------------------------------------------------------
+// Sets an item separator size.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetItemSeparatorSize(const TSize aSize)
+    {
+    FUNC_LOG;
+    static_cast<CAlfBorderBrush*> (iBorderBrush)->SetThickness(
+            TAlfTimedPoint(aSize.iWidth, aSize.iHeight));
+    }
+
+// ---------------------------------------------------------------------------
+// Sets an item separator size.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetItemSeparatorSize(
+        const TAlfTimedPoint& aThickness)
+    {
+    FUNC_LOG;
+    static_cast<CAlfBorderBrush*> (iBorderBrush)->SetThickness(aThickness);
+    }
+
+// ---------------------------------------------------------------------------
+// The functions sets fade-in's effect duration.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetFadeInEffectTime(TInt aFadeTime)
+    {
+    FUNC_LOG;
+    if (aFadeTime < 0)
+        {
+        iFadeInEffectTime = 0;
+        }
+    else
+        {
+        iFadeInEffectTime = aFadeTime;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// The functions returns fade-in's effect duration.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::FadeInEffectTime()
+    {
+    FUNC_LOG;
+    return iFadeInEffectTime;
+    }
+
+// ---------------------------------------------------------------------------
+// The functions sets fade-out's effect duration.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetFadeOutEffectTime(TInt aFadeTime)
+    {
+    FUNC_LOG;
+    if (aFadeTime < 0)
+        {
+        iFadeOutEffectTime = 0;
+        }
+    else
+        {
+        iFadeOutEffectTime = aFadeTime;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// The functions returns fade-out's effect duration.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::FadeOutEffectTime()
+    {
+    FUNC_LOG;
+    return iFadeOutEffectTime;
+    }
+
+// ---------------------------------------------------------------------------
+// Function sets the time of list scroll per item and the scroll
+// acceleration rate.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetScrollTime(TInt aScrollTime,
+        TReal aScrollAcceleration)
+    {
+    FUNC_LOG;
+    iScrollSpeed = aScrollTime;
+    if (iScrollSpeed < 0)
+        {
+        iScrollSpeed = 0;
+        }
+
+    iCurrentScrollSpeed = iScrollSpeed;
+    iScrollAccelerationRate = aScrollAcceleration;
+    if (iScrollAccelerationRate < 0.0)
+        {
+        iScrollAccelerationRate = 0.0;
+        }
+    else if (iScrollAccelerationRate > 1.0)
+        {
+        iScrollAccelerationRate = 1.0;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Gets the item expansion delay.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::ItemExpansionDelay() const
+    {
+    FUNC_LOG;
+    return iScrollSpeed;
+    }
+
+// ---------------------------------------------------------------------------
+// Function gets the values of scroll speed and its acceleration rate.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::GetScrollTime(TInt& aScrollTime,
+        TReal& aScrollAcceleration)
+    {
+    FUNC_LOG;
+    aScrollTime = iScrollSpeed;
+    aScrollAcceleration = iScrollAccelerationRate;
+    }
+
+// ---------------------------------------------------------------------------
+// Expand the node.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::ExpandNodeL(const TFsTreeItemId aNodeId)
+    {
+    FUNC_LOG;
+    MFsTreeNodeVisualizer* nodeVisualizer =
+            iTreeData->NodeVisualizer(aNodeId);
+    TRect rc;
+    TUint index = iWorld.GetItemRect(aNodeId, rc);
+    if (!nodeVisualizer->IsExpanded())
+        {
+        nodeVisualizer->SetExpanded(ETrue, &iTreeData->ItemData(aNodeId));
+        
+        TFsTreeIterator treeIter = iTreeData->Iterator(aNodeId, aNodeId,
+                KFsTreeIteratorSkipHiddenFlag);
+        if (treeIter.HasNext())
+            {
+            TPoint position;
+            if (iFocusedItem != KFsTreeNoneID)
+                {
+                position = iViewPort.ItemRect(iFocusedItem).iTl;
+                }
+            iWorld.BeginUpdate();
+            TFsTreeItemId itemId;
+            TSize size;
+            do
+                {
+                itemId = treeIter.Next();
+                ++index;
+                MFsTreeItemVisualizer* itemviz =
+                        iTreeData->ItemVisualizer(itemId);
+                ApplyListSpecificValuesToItem(itemviz);
+                size = itemviz->Size();
+                iWorld.InsertL(itemId, size, index);
+                } while (treeIter.HasNext()); 
+            if (iFocusedItem != KFsTreeNoneID)
+                {
+                iViewPort.ItemToPositionL(iFocusedItem, position, EFalse,
+                        TViewPort::EPositionAfterExpand);
+                }
+            iWorld.EndUpdateL();
+
+            if ( iVisualizerObserver )
+                {
+                iVisualizerObserver->TreeVisualizerEventL(
+                        MFsTreeVisualizerObserver::EFsTreeListItemExpanded,
+                        aNodeId );
+                }
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Collapse the node.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::CollapseNodeL(const TFsTreeItemId aNodeId)
+    {
+    FUNC_LOG;
+    MFsTreeNodeVisualizer* nodeVisualizer =
+            iTreeData->NodeVisualizer(aNodeId);
+    if (nodeVisualizer->IsExpanded())
+        {
+        TFsTreeIterator treeIter = iTreeData->Iterator(aNodeId, aNodeId,
+                KFsTreeIteratorSkipHiddenFlag);
+        nodeVisualizer->SetExpanded(EFalse, &iTreeData->ItemData(aNodeId));
+        if (treeIter.HasNext())
+            {
+            iWorld.BeginUpdate();
+            TFsTreeItemId itemId;
+            TSize size;
+            do
+                {
+                itemId = treeIter.Next();
+                if (itemId != KFsTreeNoneID)
+                    {
+                    iWorld.RemoveL(itemId);
+                    }
+                } while (treeIter.HasNext());
+            iWorld.EndUpdateL();
+
+            if ( iVisualizerObserver )
+                {
+                iVisualizerObserver->TreeVisualizerEventL(
+                        MFsTreeVisualizerObserver::EFsTreeListItemCollapsed,
+                        aNodeId );
+                }
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Expand all nodes in the tree.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::ExpandAllL()
+    {
+    FUNC_LOG;
+    iWorld.BeginUpdate();
+    TPoint position;
+    if (iFocusedItem != KFsTreeNoneID)
+        {
+        position = iViewPort.ItemRect(iFocusedItem).iTl;
+        }
+    iWorld.RemoveAllL();
+    TFsTreeIterator treeIter = iTreeData->Iterator(KFsTreeRootID,
+            KFsTreeRootID);
+    TFsTreeItemId itemId = KFsTreeNoneID;
+    TSize size;
+    while (treeIter.HasNext())
+        {
+        itemId = treeIter.Next();
+        if (itemId != KFsTreeNoneID)
+            {
+            if (iTreeData->IsNode(itemId))
+                {
+                MFsTreeNodeVisualizer* nodeviz = iTreeData->NodeVisualizer(
+                        itemId);
+                nodeviz->SetExpanded(ETrue, &iTreeData->ItemData(itemId));
+                size = nodeviz->Size();
+                }
+            else
+                {
+                MFsTreeItemVisualizer* itemviz = iTreeData->ItemVisualizer(
+                        itemId);
+                size = itemviz->Size();
+                }
+            iWorld.AppendL(itemId, size);
+            }
+        }
+    if (iFocusedItem != KFsTreeNoneID)
+        {
+        iViewPort.ItemToPositionL(iFocusedItem, position, EFalse,
+                TViewPort::EPositionAfterExpand);
+        }
+    iWorld.EndUpdateL();
+    // <cmail>
+    if ( iVisualizerObserver )
+        {
+        iVisualizerObserver->TreeVisualizerEventL(
+                MFsTreeVisualizerObserver::EFsTreeListExpandedAll );
+        }
+    // </cmail>
+    }
+
+// ---------------------------------------------------------------------------
+// Collapse all nodes in the tree.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::CollapseAllL()
+    {
+    FUNC_LOG;
+    iWorld.BeginUpdate();
+    TPoint position;
+    if (iFocusedItem != KFsTreeNoneID)
+        {
+        position = iViewPort.ItemRect(iFocusedItem).iTl;
+        }
+    iWorld.RemoveAllL();
+    if (iTreeData->Count() > 0)
+        {
+        TUint childcount = iTreeData->CountChildren(KFsTreeRootID);
+        for (TUint i = 0; i < childcount; ++i)
+            {
+            TFsTreeItemId itemId = iTreeData->Child(KFsTreeRootID, i);
+            TSize itemSize;
+            if (iTreeData->IsNode(itemId))
+                {
+                MFsTreeNodeVisualizer* nodeVis(iTreeData->NodeVisualizer(
+                        itemId));
+                nodeVis->SetExpanded(EFalse, &iTreeData->ItemData(itemId));
+                itemSize = nodeVis->Size();
+                }
+            else
+                {
+                itemSize = iTreeData->ItemVisualizer(itemId)->Size();
+                }
+            iWorld.AppendL(itemId, itemSize);
+            }
+        }
+    if (iFocusedItem != KFsTreeNoneID)
+        {
+        iViewPort.ItemToPositionL(iFocusedItem, position, EFalse);
+        }
+    iWorld.EndUpdateL();
+    // <cmail>
+    if ( iVisualizerObserver )
+        {
+        iVisualizerObserver->TreeVisualizerEventL(
+                MFsTreeVisualizerObserver::EFsTreeListCollapsedAll );
+        }
+    // </cmail>
+    }
+
+// ---------------------------------------------------------------------------
+//
+//
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::AllNodesCollapsed() const
+    {
+    FUNC_LOG;
+    TFsTreeIterator treeIter = iTreeData->Iterator(KFsTreeRootID,
+            KFsTreeRootID, KFsTreeIteratorSkipCollapsedFlag
+                    | KFsTreeIteratorSkipHiddenFlag);
+    TFsTreeItemId itemId = KFsTreeNoneID;
+    while (treeIter.HasNext())
+        {
+        itemId = treeIter.Next();
+        if (!iTreeData->IsNode(itemId))
+            {
+            return EFalse;
+            }
+        }
+    return ETrue;
+    }
+
+// ---------------------------------------------------------------------------
+//
+//
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::AllNodesExpanded() const
+    {
+    FUNC_LOG;
+    return iWorld.ItemCount() == iTreeData->Count();
+    }
+
+// ---------------------------------------------------------------------------
+// Update visual of the item given by id.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::UpdateItemL(const TFsTreeItemId aItemId)
+    {
+    FUNC_LOG;
+    TInt i = iVisibleItems.Find(aItemId);
+    if (i != KErrNotFound)
+        {
+        MFsTreeItemVisualizer* vis = iTreeData->ItemVisualizer(aItemId);
+        if (vis)
+            {
+            vis->UpdateL(iTreeData->ItemData(aItemId),
+                    IsItemFocused(aItemId) && IsFocusShown(),
+                    iTreeData->Level(aItemId),
+                    iMarkIcon, iMenuIcon, 0);
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  The functions sets wether all item in the list should be always in
+//  extended state or in normal state.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetItemsAlwaysExtendedL(TBool aAlwaysExtended)
+    {
+    FUNC_LOG;
+    iFlags.Assign(EItemsAlwaysExtended, aAlwaysExtended);
+    TFsTreeIterator treeIter(
+            iTreeData->Iterator(KFsTreeRootID, KFsTreeRootID));
+    while (treeIter.HasNext())
+        {
+        TFsTreeItemId itemId(treeIter.Next());
+        if (itemId != KFsTreeNoneID && !iTreeData->IsNode(itemId))
+            {
+            MFsTreeItemVisualizer* itemviz(iTreeData->ItemVisualizer(itemId));
+            ApplyListSpecificValuesToItem(itemviz);
+            }
+        }
+    iWorld.BeginUpdate();
+    iWorld.RemoveAllL();
+    treeIter = iTreeData->Iterator(KFsTreeRootID, KFsTreeRootID,
+            KFsTreeIteratorSkipCollapsedFlag);
+    while (treeIter.HasNext())
+        {
+        TFsTreeItemId itemId(treeIter.Next());
+        if (itemId != KFsTreeNoneID)
+            {
+            MFsTreeItemVisualizer* itemviz(iTreeData->ItemVisualizer(itemId));
+            iWorld.AppendL(itemId, itemviz->Size());
+            }
+        }
+    iViewPort.SetPositionL(TPoint(), EFalse);
+    iViewPort.ClearCache();
+    iWorld.EndUpdateL();
+    }
+
+// ---------------------------------------------------------------------------
+//  The function returns if items are always in extended state or in normal.
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::IsItemsAlwaysExtended()
+    {
+    FUNC_LOG;
+    return iFlags.IsSet(EItemsAlwaysExtended);
+    }
+
+// ---------------------------------------------------------------------------
+// Set the background texture, clears the background color.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CFsTreeVisualizerBase::SetBackgroundTextureL(CAlfTexture& /*aBgTexture*/)
+    {
+    FUNC_LOG;
+    }
+
+// ---------------------------------------------------------------------------
+// Sets the background color, clears the background texture.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CFsTreeVisualizerBase::SetBackgroundColorL(TRgb aColor)
+    {
+    FUNC_LOG;
+    if (iWatermarkLayout && iWatermarkLayout->Brushes())
+        {
+        TInt count = iWatermarkLayout->Brushes()->Count();
+        if (count > 0)
+            {//there is only background brush attached to this layout
+            iWatermarkLayout->Brushes()->Remove(KZero);
+            iWatermarkLayout->Brushes()->Reset();
+            iWatermarkLayout->SetFlag(EAlfVisualChanged);
+            }
+        }
+
+    CAlfGradientBrush* backgroundBrush = CAlfGradientBrush::NewL(
+            iOwnerControl->Env());
+    backgroundBrush->SetLayer(EAlfBrushLayerBackground);
+    backgroundBrush->SetColor(aColor);
+
+    iWatermarkLayout->Brushes()->AppendL(backgroundBrush, EAlfHasOwnership);
+    }
+
+// ---------------------------------------------------------------------------
+// Sets a given brush as a list background.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CFsTreeVisualizerBase::SetBackgroundBrushL(CAlfBrush* aBrush)
+    {
+    FUNC_LOG;
+
+    if (iWatermarkLayout && iWatermarkLayout->Brushes())
+        {
+        TInt count = iWatermarkLayout->Brushes()->Count();
+        if (count > 0)
+            {//there is only background brush attached to this layout
+            iWatermarkLayout->Brushes()->Remove(KZero);
+            iWatermarkLayout->Brushes()->Reset();
+            iWatermarkLayout->SetFlag(EAlfVisualChanged);
+            }
+        }
+
+    aBrush->SetLayer(EAlfBrushLayerBackground);
+    iWatermarkLayout->Brushes()->AppendL(aBrush, EAlfHasOwnership);
+    }
+
+// ---------------------------------------------------------------------------
+// The function clears list's background.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CFsTreeVisualizerBase::ClearBackground()
+    {
+    FUNC_LOG;
+    if (iWatermarkLayout && iWatermarkLayout->Brushes())
+        {
+        TInt count = iWatermarkLayout->Brushes()->Count();
+        if (count > 0)
+            {//there is only background brush attached to this layout
+            iWatermarkLayout->Brushes()->Remove(KZero);
+            iWatermarkLayout->Brushes()->Reset();
+            iWatermarkLayout->SetFlag(EAlfVisualChanged);
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Sets watermark position.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CFsTreeVisualizerBase::SetWatermarkPos(const TPoint& aPosition)
+    {
+    FUNC_LOG;
+    if (iWatermark)
+        {
+        TAlfTimedPoint position;
+        position.SetTarget(TAlfRealPoint(aPosition));
+        iWatermark->SetPos(position);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Sets watermark's size.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CFsTreeVisualizerBase::SetWatermarkSize(const TSize& aSize)
+    {
+    FUNC_LOG;
+    if (iWatermark)
+        {
+        TAlfTimedPoint size;
+        size.SetTarget(TAlfRealPoint(aSize.AsPoint()));
+        iWatermark->SetSize(size);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Sets watermark opacity.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CFsTreeVisualizerBase::SetWatermarkOpacity(const float aOpacity)
+    {
+    FUNC_LOG;
+    if (iWatermark)
+        {
+        TAlfTimedValue opacity;
+        opacity.SetTarget(aOpacity, 0);
+        iWatermark->SetOpacity(opacity);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Sets watermark texture.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CFsTreeVisualizerBase::SetWatermarkL(CAlfTexture* aTexture)
+    {
+    FUNC_LOG;
+    if (aTexture)
+        {
+        if (!iWatermark)
+            {
+            iWatermark
+                    = CFsWatermark::NewL(*iOwnerControl, *iWatermarkLayout);
+            }
+        // <cmail>
+        iWatermark->SetWatermarkTextureL(*aTexture);
+        // </cmail>
+        }
+    else
+        {
+        delete iWatermark;
+        iWatermark = NULL;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::TreeEventL(
+    const TFsTreeEvent aEvent,
+    const MFsTreeObserver::TFsTreeEventParams& aParams)
+    {
+    FUNC_LOG;
+    switch (aEvent)
+        {
+        case EFsTreeItemAdded:
+        case EFsTreeNodeAdded:
+            {
+            MFsTreeItemVisualizer* itemVisualizer(iTreeData->ItemVisualizer(
+                    aParams.iItemId));
+            const TBool isHidden(itemVisualizer->IsHidden());
+            if (!isHidden)
+                {
+                if (!iListLayout->Count())
+                    {
+                    // Hide empty list marker
+                    iRootVisualizer->Hide();
+                    iComponentLayout->UpdateChildrenLayout();
+                    iListLayout->UpdateChildrenLayout();
+                    }
+                if (aParams.iTargetNodeId != KFsTreeRootID)
+                    {
+                    MFsTreeNodeVisualizer* nodeVisualizer =
+                            iTreeData->NodeVisualizer(aParams.iTargetNodeId);
+                    if (nodeVisualizer->IsExpanded())
+                        {
+                        // look for parent's index
+                        TInt indexAdd = 0;
+                        while (iWorld.Item(indexAdd) != aParams.iTargetNodeId)
+                            {
+                            indexAdd++;
+                            }
+
+                        // look for how many children parent already has in
+                        // the tree model
+                        TInt childCount( 0 );
+                        if ( aParams.iIndex >= 0 )
+                            {
+                            childCount = aParams.iIndex;
+                            }
+                        else
+                            {
+                            // -1 is for excluding the item that is now being
+                            // inserted to visualiser
+                            // (it has already been inserted to the tree model)
+                            childCount = iTreeData->CountChildrenRecursively(
+                                aParams.iTargetNodeId ) - 1;
+                            }
+
+                        InsertItemL( aParams.iItemId, indexAdd + 1 + childCount );
+                        }
+                    }
+                else if (iWorld.ItemCount() > 0)
+                    {
+                    if (aParams.iIndex >= 0)
+                        {
+                        TInt indexAdd = 0;
+                        TInt nodeCount = 0;
+                        while (indexAdd < iWorld.ItemCount() - 1 && nodeCount
+                                != aParams.iIndex)
+                            {
+                            indexAdd++;
+                            if (iTreeData->Parent(iWorld.Item(indexAdd))
+                                    == KFsTreeRootID)
+                                {
+                                nodeCount++;
+                                }
+                            }
+                        InsertItemL(aParams.iItemId, indexAdd);
+                        }
+                    else
+                        {
+                        InsertItemL(aParams.iItemId, KErrNotFound);
+                        }
+                    }
+                else
+                    {
+                    InsertItemL(aParams.iItemId, aParams.iIndex);
+                    }
+                }
+            }
+            break;
+        case EFsTreeItemRemoved:
+        case EFsTreeNodeRemoved:
+            {
+            RemoveItemL(aParams.iItemId);
+            }
+            break;
+        case EFsTreeRemovedAll:
+            {
+            iRootVisualizer->ShowL(*iRootLayout);
+            iRootVisualizer->UpdateL(*iRootData, EFalse, 0, iMarkIcon,
+                    iMenuIcon);
+            //iListLayout->RemoveAndDestroyAllD();
+            iWorld.RemoveAllL();
+            iFocusedItem = KFsTreeNoneID;
+            }
+            break;
+        case EFsTreeItemVisualizerChanged:
+            //the selector visual will be destroyed only when changing visualizer
+            if (aParams.iItemId == iFocusedItem)
+                {
+                iSelectorVisual = NULL;
+                }
+        case EFsTreeItemDataChanged:
+            {
+            const TFsTreeItemId itemId(aParams.iItemId);
+            MFsTreeItemVisualizer* visualizer = iTreeData->ItemVisualizer(
+                    itemId);
+            if (visualizer)
+                {
+                visualizer->UpdateL(iTreeData->ItemData(itemId),
+                        IsItemFocused(itemId), iTreeData->Level(itemId),
+                        iMarkIcon, iMenuIcon, 0);
+                }
+            }
+            break;
+
+        default:
+            break;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// The function implements tree observer's reaction to removing a list item
+// from the model. If the item was visible then it's removed from the visible
+// area. If the focused item was removed then the focus is moved to the next
+// item in the tree hierarchy (if the next item is not present, then the focus
+// is moved to the previous one).
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::RemoveItemL(TFsTreeItemId aItemId)
+    {
+    FUNC_LOG;
+    TInt removedindex = iWorld.IndexOfItem(aItemId);
+    iWorld.RemoveL(aItemId);
+    if (iFocusedItem == aItemId)
+        {
+        if (iWorld.ItemCount() > removedindex)
+            {
+            SetFocusedItemL(iWorld.Item(removedindex), EFalse);
+            }
+        else if (iWorld.ItemCount() > 0)
+            {
+            SetFocusedItemL(iWorld.Item(removedindex - 1), EFalse);
+            }
+        else
+            {
+            iFocusedItem = KFsTreeNoneID;
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  The function checks whether the focused item is not outside the visible
+//  area and if needed scrolls the list so that selected item is fully visible.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::MakeFocusedItemFullyVisible()
+    {
+    FUNC_LOG;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::RefreshListViewL()
+    {
+    FUNC_LOG;
+    if (iTreeData->Count() == 0)
+        {
+        iRootVisualizer->ShowL(*iRootLayout);
+        iRootVisualizer->UpdateL(*iRootData, EFalse, 0, iMarkIcon, iMenuIcon);
+        }
+    else
+        {
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Hides item.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::HideItemL(const TFsTreeItemId /*aItemId*/)
+
+    {
+    FUNC_LOG;
+    }
+
+// ---------------------------------------------------------------------------
+// Unhides item.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::UnhideItemL(const TFsTreeItemId /*aItemId*/)
+    {
+    FUNC_LOG;
+
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetPadding(const TAlfBoxMetric& aPadding)
+    {
+    FUNC_LOG;
+
+    iWatermarkLayout->SetPadding(aPadding);
+
+    }
+
+// ---------------------------------------------------------------------------
+// List pane's padding taken from Layout Manager or switched off.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::EnableListPanePadding(TBool aEnable)
+    {
+    FUNC_LOG;
+    if (aEnable)
+        {
+        TRect listPane;
+        CFsLayoutManager::LayoutMetricsRect(TRect(
+                iComponentLayout->Size().Target().AsSize()),
+                CFsLayoutManager::EFsLmMainSpFsListPane, listPane);
+
+        if (CFsLayoutManager::IsMirrored())
+            {
+            iListLayout->SetPadding(TPoint(
+                    iComponentLayout->Size().Target().AsSize().iWidth
+                            - listPane.iBr.iX, 0));
+            iListItemBackgroundLayout->SetPadding(TPoint(
+                    iComponentLayout->Size().Target().AsSize().iWidth
+                            - listPane.iBr.iX, 0));
+            }
+        else
+            {
+            TInt xPadd;
+            xPadd = listPane.iTl.iX;
+            iListLayout->SetPadding(TPoint(xPadd, 0));
+            iListItemBackgroundLayout->SetPadding(TPoint(xPadd, 0));
+            }
+        }
+    else
+        {
+        //no padding
+        TInt padd(0);
+        iListLayout->SetPadding(TPoint(padd, padd));
+        iListItemBackgroundLayout->SetPadding(TPoint(padd, padd));
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  Sets the type of text marquee.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetTextMarqueeType(
+        const TFsTextMarqueeType aMarqueeType)
+    {
+    FUNC_LOG;
+    iMarqueeType = aMarqueeType;
+    }
+
+// ---------------------------------------------------------------------------
+//  Gets the type of text marquee.
+// ---------------------------------------------------------------------------
+//
+TFsTextMarqueeType CFsTreeVisualizerBase::TextMarqueeType() const
+    {
+    FUNC_LOG;
+    return iMarqueeType;
+    }
+
+// ---------------------------------------------------------------------------
+//  Sets the speed of marquee.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetTextMarqueeSpeed(const TInt aPixelsPerSec)
+    {
+    FUNC_LOG;
+    iMarqueeSpeed = aPixelsPerSec;
+    }
+
+// ---------------------------------------------------------------------------
+//  Gets the speed of marquee.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::TextMarqueeSpeed() const
+    {
+    FUNC_LOG;
+    return iMarqueeSpeed;
+    }
+
+// ---------------------------------------------------------------------------
+//  Sets delay for text marquee start.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetTextMarqueeStartDelay(const TInt aStartDelay)
+    {
+    FUNC_LOG;
+    iMarqueStartDelay = aStartDelay;
+    }
+
+// ---------------------------------------------------------------------------
+//  Gets delay for text marquee.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::TextMarqueeStartDelay() const
+    {
+    FUNC_LOG;
+    return iMarqueStartDelay;
+    }
+
+// ---------------------------------------------------------------------------
+//  Sets a delay for each cycle start.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetTextMarqueeCycleStartDelay(
+        const TInt aCycleStartDelay)
+    {
+    FUNC_LOG;
+    iMarqueCycleStartDelay = aCycleStartDelay;
+    }
+
+// ---------------------------------------------------------------------------
+//  Returns a delay for each cycle start.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::TextMarqueeCycleStartDelay() const
+    {
+    FUNC_LOG;
+    return iMarqueCycleStartDelay;
+    }
+
+// ---------------------------------------------------------------------------
+//  Sets number of marquee cycles.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetTextMarqueeRepetitions(
+        const TInt aMarqueeRepetitions)
+    {
+    FUNC_LOG;
+    iMarqueeRepetitions = aMarqueeRepetitions;
+    }
+
+// ---------------------------------------------------------------------------
+//  Gets number of marquee cycles.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::TextMarqueeRepetitions() const
+    {
+    FUNC_LOG;
+    return iMarqueeRepetitions;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::GetItemDisplayRectTarget(
+        const TFsTreeItemId aItemId, TAlfRealRect& aRect)
+    {
+    FUNC_LOG;
+    TInt retVal(KErrNotFound);
+    MFsTreeItemVisualizer* itemVis(NULL);
+    CAlfLayout* lay(NULL);
+
+    aRect.iTl = TAlfRealPoint(0.0, 0.0);
+    aRect.iBr = TAlfRealPoint(0.0, 0.0);
+
+    retVal = iVisibleItems.Find(aItemId);
+    if (retVal != KErrNotFound)
+        {//item visible
+        itemVis = iTreeData->ItemVisualizer(aItemId);
+        if (itemVis)
+            {
+            lay = &itemVis->Layout();
+            if (lay)
+                {
+                aRect = lay->DisplayRectTarget();
+                retVal = KErrNone;
+                }
+            else
+                {
+                retVal = KErrNotFound;
+                }
+            }
+        else
+            {
+            retVal = KErrNotFound;
+            }
+        }
+    else
+        {
+        retVal = KErrNotFound;
+        }
+
+    return retVal;
+    }
+
+// ---------------------------------------------------------------------------
+//  Internall to TreeList. Do not use directly.
+//  Used to block update during addition of many items/nodes. Currently only
+//  scrollbar is blocked from beign updated.Gets number of marquee cycles.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetAutoRefreshAtInsert(TBool aAllowRefresh)
+    {
+    FUNC_LOG;
+    if (!aAllowRefresh && iFlags.IsSet(EAutoRefresh))
+        {
+        iWorld.BeginUpdate();
+        }
+    else if (aAllowRefresh && !iFlags.IsSet(EAutoRefresh))
+        {
+        TInt error( KErrNone );
+        TRAP( error, iWorld.EndUpdateL() );
+        ERROR_1( error, "iWorld.EndUpdateL failed with error: %d", error );
+        }
+    iFlags.Assign(EAutoRefresh, aAllowRefresh);
+    }
+
+// ---------------------------------------------------------------------------
+//  Internall to TreeList. Do not use directly.
+//  Used to block update during addition of many items/nodes. Currently only
+//  scrollbar is blocked from beign updated.Gets number of marquee cycles.
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::IsAutoRefreshAtInsert()
+    {
+    FUNC_LOG;
+    return iFlags.IsSet(EAutoRefresh);
+    }
+
+// ---------------------------------------------------------------------------
+//  CFsTreeVisualizerBase::SetDirectTouchMode
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetDirectTouchMode(const TBool aDirectTouchMode)
+    {
+    FUNC_LOG;
+    iFlags.Assign(EDirectTouchMode, aDirectTouchMode);
+    }
+
+// ---------------------------------------------------------------------------
+//  CFsTreeVisualizerBase::SetExpandCollapseAllOnLongTap
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetExpandCollapseAllOnLongTap( TBool aExpandCollapse )
+    {
+    FUNC_LOG;
+    iFlags.Assign( EExpandCollapseOnLongTap, aExpandCollapse );
+    }
+
+// ---------------------------------------------------------------------------
+//  CFsTreeVisualizerBase::IsExpandCollapseAllOnLongTap
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::IsExpandCollapseAllOnLongTap()
+    {
+    FUNC_LOG;
+    return iFlags.IsSet( EExpandCollapseOnLongTap );
+    }
+
+// ---------------------------------------------------------------------------
+// From MFsFadeEffectObserver
+// Function which will receive notifications about fade effect state changes.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::FadeEffectEvent(
+        MFsFadeEffectObserver::TFadeEffectState aState)
+    {
+    FUNC_LOG;
+    switch (aState)
+        {
+        case MFsFadeEffectObserver::EFadeInFinished:
+            {
+            if (iVisualizationState == EFsTreeFadingInSlidingIn)
+                {//slide in effect still on
+                iVisualizationState = EFsTreeSlidingIn;
+                }
+            else if (iVisualizationState == EFsTreeFadingIn)
+                {
+                iVisualizationState = EFsTreeVisible;
+                UpdateScrollBar();
+                }
+            break;
+            }
+        case MFsFadeEffectObserver::EFadeOutFinished:
+            {
+            if (iVisualizationState == EFsTreeFadingOutSlidingOut)
+                {//slide out effect still on
+                iVisualizationState = EFsTreeSlidingOut;
+                }
+            else if (iVisualizationState == EFsTreeFadingOut)
+                {
+                iScrollBar->MakeVisible(EFalse);
+                iVisualizationState = EFsTreeHidden;
+                }
+            break;
+            }
+        default:
+            {
+            break;
+            }
+        }
+
+    if (iVisualizationState == EFsTreeVisible && iVisualizerObserver)
+        {
+            // <cmail> Touch
+            TRAP_IGNORE(iVisualizerObserver->TreeVisualizerEventL(
+                            MFsTreeVisualizerObserver::EFsTreeListVisualizerShown,
+                            KFsTreeNoneID ));
+        // </cmail>
+        }
+
+    if (iVisualizationState == EFsTreeHidden && iVisualizerObserver)
+        {
+            // <cmail> Touch
+            TRAP_IGNORE(iVisualizerObserver->TreeVisualizerEventL(
+                            MFsTreeVisualizerObserver::EFsTreeListVisualizerHidden,
+                            KFsTreeNoneID ));
+        // </cmail>
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// From MFsSlideEffectObserver
+// Function which will receive notifications about slide effect state changes.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SlideEffectEvent(
+        MFsSlideEffectObserver::TSlideEffectState aState)
+    {
+    FUNC_LOG;
+    switch (aState)
+        {
+        case MFsSlideEffectObserver::ESlideInFinished:
+            {
+            if (iVisualizationState == EFsTreeFadingInSlidingIn)
+                {//fade in effect still on
+                iVisualizationState = EFsTreeFadingIn;
+                }
+            else if (iVisualizationState == EFsTreeSlidingIn)
+                {
+                iVisualizationState = EFsTreeVisible;
+                UpdateScrollBar();
+                }
+            break;
+            }
+        case MFsSlideEffectObserver::ESlideOutFinished:
+            {
+            if (iVisualizationState == EFsTreeFadingOutSlidingOut)
+                {//fade out effect still on
+                iVisualizationState = EFsTreeFadingOut;
+                }
+            else if (iVisualizationState == EFsTreeSlidingOut)
+                {
+                iScrollBar->MakeVisible(EFalse);
+                iVisualizationState = EFsTreeHidden;
+                }
+            break;
+            }
+        default:
+            {
+            break;
+            }
+        }
+
+    if (iVisualizationState == EFsTreeVisible && iVisualizerObserver)
+        {
+            // <cmail> Touch
+            TRAP_IGNORE(iVisualizerObserver->TreeVisualizerEventL(
+                            MFsTreeVisualizerObserver::EFsTreeListVisualizerShown,
+                            KFsTreeNoneID ));
+
+        }
+
+    if (iVisualizationState == EFsTreeHidden && iVisualizerObserver)
+        {
+            TRAP_IGNORE(iVisualizerObserver->TreeVisualizerEventL(
+                            MFsTreeVisualizerObserver::EFsTreeListVisualizerHidden,
+                            KFsTreeNoneID ));
+        // </cmail>
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// From MAlfActionObserver
+// Called by the server when an action command is executed.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::HandleActionL(
+        const TAlfActionCommand& aActionCommand)
+    {
+    // <cmail> Change scrollbar to avkon (to support skinning & touch)
+    if (KAknsMessageSkinChange == aActionCommand.Id())
+        {//layoout has changed
+        //        HideList(EFalse, EFalse);
+        //        ShowListL(ETrue, EFalse);
+        iScrollBar->HandleResourceChange(KAknsMessageSkinChange);
+        }
+    // </cmail>
+    }
+
+// ---------------------------------------------------------------------------
+// Hides visible list items. Clears the visible items table.
+// ---------------------------------------------------------------------------
+//
+// <cmail>
+void CFsTreeVisualizerBase::ClearVisibleItemsListL(TBool /*aRemoveAll*/,
+        TBool /*aScrollList*/)
+// </cmail>
+    {
+    FUNC_LOG;
+    }
+
+// ---------------------------------------------------------------------------
+// Applies focus brush to the selected item.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::ChangeFocusL(const TFsTreeItemId /*aPrevious*/)
+    {
+    FUNC_LOG;
+
+    }
+
+// ---------------------------------------------------------------------------
+// CFsTreeVisualizerBase::AdjustVisibleItemsL
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::AdjustVisibleItemsL()
+    {
+    FUNC_LOG;
+
+    }
+
+// ---------------------------------------------------------------------------
+// CFsTreeVisualizerBase::InsertItemL
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::InsertItemL(TFsTreeItemId aItemId,
+        const TInt aSlot)
+    {
+    MFsTreeItemVisualizer* visualizer = iTreeData->ItemVisualizer(aItemId);
+    ApplyListSpecificValuesToItem(visualizer);
+    //TUint32 oldflags = visualizer->Flags();
+    //visualizer->SetFlags(oldflags | KFsTreeListItemManagedLayout);
+    const TSize size(visualizer->Size());
+    //visualizer->SetFlags(oldflags);
+    if (aSlot != KErrNotFound)
+        {
+        iWorld.InsertL(aItemId, size, aSlot);
+        }
+    else
+        {
+        iWorld.AppendL(aItemId, size);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Move selection in the list.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::MoveSelectionL(
+        const TFsTreeVisualizerMove aMoveType)
+    {
+    FUNC_LOG;
+    TInt focusedIndex = iWorld.IndexOfItem(iFocusedItem);
+    switch (aMoveType)
+        {
+        case EFsTreeVisualizerMoveLineUp:
+            {
+            while (focusedIndex > 0)
+                {
+                focusedIndex -= 1;
+                if (iTreeData->ItemData(iWorld.Item(focusedIndex)).Type()
+                        != KFsSeparatorDataType)
+                    {
+                    SetFocusedItemL(iWorld.Item(focusedIndex));
+                    break;
+                    }
+                }
+            break;
+            }
+        case EFsTreeVisualizerMoveLineDown:
+            {
+            while (focusedIndex < iWorld.ItemCount() - 1)
+                {
+                focusedIndex += 1;
+                if (iTreeData->ItemData(iWorld.Item(focusedIndex)).Type()
+                        != KFsSeparatorDataType)
+                    {
+                    SetFocusedItemL(iWorld.Item(focusedIndex));
+                    break;
+                    }
+                }
+            break;
+            }
+        case EFsTreeVisualizerMovePageUp:
+            {
+            focusedIndex -= iVisibleItems.Count() - 2;
+            while (focusedIndex > 0)
+                {
+                if (iTreeData->ItemData(iWorld.Item(focusedIndex)).Type()
+                        != KFsSeparatorDataType)
+                    {
+                    break;
+                    }
+                else
+                    {
+                    focusedIndex--;
+                    }
+                }
+            if (focusedIndex < 0)
+                {
+                focusedIndex = 0;
+                }
+            if (iWorld.ItemCount() > 0)
+                {
+                SetFocusedItemL(iWorld.Item(focusedIndex));
+                }
+            break;
+            }
+        case EFsTreeVisualizerMovePageDown:
+            {
+            focusedIndex += iVisibleItems.Count() - 2;
+            while (focusedIndex < iWorld.ItemCount() - 1)
+                {
+                if (iTreeData->ItemData(iWorld.Item(focusedIndex)).Type()
+                        != KFsSeparatorDataType)
+                    {
+                    break;
+                    }
+                else
+                    {
+                    focusedIndex++;
+                    }
+                }
+            if (focusedIndex > iWorld.ItemCount() - 1)
+                {
+                focusedIndex = iWorld.ItemCount() - 1;
+                }
+            if (iWorld.ItemCount() > 0)
+                {
+                SetFocusedItemL(iWorld.Item(focusedIndex));
+                }
+            break;
+            }
+        }
+    iViewPort.ScrollItemToViewL(iFocusedItem, ETrue);
+    }
+
+// ---------------------------------------------------------------------------
+// Moves selection in the list by one item upwards.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::MoveSelectionByLineUpL(const TBool /*aChangeFocus*/)
+    {
+    FUNC_LOG;
+    return 0;
+    }
+
+// ---------------------------------------------------------------------------
+// Moves selection in the list by one item downwards.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::MoveSelectionByLineDownL(const TBool /*aChangeFocus*/)
+    {
+    FUNC_LOG;
+    return 0;
+    }
+
+// ---------------------------------------------------------------------------
+// Scrolling
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::Scroll(const TFsTreeItemId aPrevious,
+        TBool aAlignTop)
+    {
+    FUNC_LOG;
+    TInt currScrollOffset = iListLayout->ScrollOffset().iY.Target();
+    TInt listItemsHeight = 0;
+    TInt visibleHeight = iComponentLayout->Size().iY.Target();
+    TInt scrollOffset = 0;
+
+    listItemsHeight = VisibleItemsHeight(aPrevious);
+
+    if (aAlignTop)
+        {
+        scrollOffset = 0;
+        }
+    else
+        {
+        if (listItemsHeight > visibleHeight)
+            {
+            scrollOffset = listItemsHeight - visibleHeight;
+            }
+        else
+            {
+            scrollOffset = currScrollOffset;
+            }
+        }
+
+    ScrollListLayouts(scrollOffset, iCurrentScrollSpeed);
+    }
+
+// ---------------------------------------------------------------------------
+// Counts height items from iVisibleItems array which will
+// be drawn on the screen
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::VisibleItemsHeight(const TFsTreeItemId aPrevious)
+    {
+    FUNC_LOG;
+    TInt listItemsHeight = 0;
+    MFsTreeItemVisualizer* vis = 0;
+    TFsTreeItemId itemId;
+    TInt itemCount = iVisibleItems.Count();
+
+    for (TInt index = 0; index < itemCount; ++index)
+        {
+        itemId = iVisibleItems[index];
+        vis = iTreeData->ItemVisualizer(itemId);
+
+        if (itemId == iFocusedItem)
+            {
+            if (vis->IsExtendable())
+                {
+                listItemsHeight += vis->ExtendedSize().iHeight;
+                }
+            else
+                {
+                listItemsHeight += vis->Size().iHeight;
+                }
+            }
+        else if (itemId == aPrevious && iFocusedItem != aPrevious)
+            {
+            listItemsHeight += vis->Size().iHeight;
+            }
+        else if (vis->IsExtended() && vis->IsExtendable())
+            {
+            listItemsHeight += vis->ExtendedSize().iHeight;
+            }
+        else
+            {
+            listItemsHeight += vis->Size().iHeight;
+            }
+        }
+
+    return listItemsHeight;
+    }
+
+// ---------------------------------------------------------------------------
+// Check if item is in expanded node
+// ---------------------------------------------------------------------------
+TBool CFsTreeVisualizerBase::IsInExpanded(TFsTreeItemId aItemId)
+    {
+    FUNC_LOG;
+    TBool result(ETrue);
+    TFsTreeItemId parentId = iTreeData->Parent(aItemId);
+    while (parentId != KFsTreeRootID && parentId != KFsTreeNoneID)
+        {
+        if (iTreeData->IsNode(parentId))
+            {
+            if (iTreeData->NodeVisualizer(parentId)->IsExpanded())
+                {
+                result = ETrue;
+                parentId = iTreeData->Parent(parentId);
+                }
+            else
+                {
+                result = EFalse;
+                break;
+                }
+            }
+        else
+            {
+            parentId = iTreeData->Parent(parentId);
+            }
+        }
+
+    return result;
+    }
+
+// ---------------------------------------------------------------------------
+//  CFsTreeVisualizerBase::UpdateViewPortL
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::UpdateViewPortL()
+    {
+    FUNC_LOG;
+    TRect mainPaneRect;
+    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
+    TRect listRect(iRootLayout->DisplayRectTarget());
+    listRect.Move(mainPaneRect.iTl);
+    TRect listPane;
+    CFsLayoutManager::LayoutMetricsRect(listRect,
+            CFsLayoutManager::EFsLmMainSpFsListPane, listPane);
+    iWorld.BeginUpdate();
+    TBool keepFocusedItemInView(EFalse);
+    if (iFocusedItem != KFsTreeNoneID)
+        {
+        keepFocusedItemInView = iViewPort.ItemRect(iFocusedItem).Height() > 0;
+        }
+    iViewPort.SetSizeL(listPane.Size());
+    iWorld.Recalculate(*iTreeData);   
+    if (keepFocusedItemInView)
+        {
+        iViewPort.ScrollItemToViewL(iFocusedItem, EFalse);
+        }
+    else
+        {
+        iViewPort.MakeViewFullyOccupiedL();
+        }
+    iViewPort.ClearCache();
+    iWorld.EndUpdateL();
+    }
+
+// ---------------------------------------------------------------------------
+//  Updates scrollbar, only if update is needed.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::UpdateScrollBarIfNeededL()
+    {
+    FUNC_LOG;
+    if (iScrollBar->ThumbPosition() != iViewPort.Position().iY)
+        {
+        iScrollbarModel.SetFocusPosition(iViewPort.Position().iY);
+        iScrollBar->SetModelL(&iScrollbarModel);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  Updates scrollbar.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::UpdateScrollBarL(const TInt /*aTimeout*/)
+    {
+    FUNC_LOG;
+    
+    TRect mainPaneRect;
+    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
+    TRect listRect(iRootLayout->DisplayRectTarget());
+    listRect.Move(mainPaneRect.iTl);
+    TRect scrollPane, listPane;
+    CFsLayoutManager::LayoutMetricsRect(listRect,
+            CFsLayoutManager::EFsLmSpFsScrollPane, scrollPane);
+    CFsLayoutManager::LayoutMetricsRect(listRect,
+            CFsLayoutManager::EFsLmMainSpFsListPane, listPane);
+
+    const TInt pageSize(iViewPort.Size().iHeight);
+    iScrollbarModel.SetScrollSpan(Max(iWorld.Height(), pageSize));
+    iScrollbarModel.SetWindowSize(pageSize);
+    iScrollbarModel.SetFocusPosition(iViewPort.Position().iY);
+    iScrollBar->SetModelL(&iScrollbarModel);
+
+    RArray<TInt> columns;
+    CleanupClosePushL(columns);
+    TBool updateLayouts(EFalse);
+    if (iViewPort.IsScrollBarNeeded() && iVisualizationState
+            == EFsTreeVisible)
+        {
+        iScrollBar->SetRect(scrollPane);
+        columns.AppendL(listPane.Width());
+        columns.AppendL(scrollPane.Width());
+        iComponentLayout->SetColumnsL(columns);
+        iScrollBar->MakeVisible(ETrue);
+        updateLayouts = ETrue;
+        }
+    else if (!iViewPort.IsScrollBarNeeded())
+        {
+        columns.AppendL(listPane.Width());
+        iComponentLayout->SetColumnsL(columns);
+        iScrollBar->MakeVisible(EFalse);
+        updateLayouts = ETrue;
+        }
+    CleanupStack::PopAndDestroy(); // columns.Close()
+    if (updateLayouts)
+        {
+        iComponentLayout->UpdateChildrenLayout();
+
+        for (TUint i = 0; i < iVisibleItems.Count(); ++i)
+            {
+            TFsTreeItemId itemId(iVisibleItems[i]);
+            MFsTreeItemVisualizer* viz = iTreeData->ItemVisualizer(itemId);
+            viz->UpdateL(iTreeData->ItemData(itemId),
+                    IsItemFocused(itemId) && IsFocusShown(),
+                    iTreeData->Level(itemId), iMarkIcon, iMenuIcon, 0, EFalse);
+            }
+        UpdateSelectorVisualL();
+        }
+
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::UpdateScrollBar(const TInt aTimeout)
+    {
+    FUNC_LOG;
+    TRAPD( error, UpdateScrollBarL( aTimeout ) );
+    return error;
+    }
+
+// ---------------------------------------------------------------------------
+//  Old API to be removed. Turns on or off vertical scrollbar.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetVScrollBarL(TBool /*aSetOn*/)
+    {
+    FUNC_LOG;
+    UpdateScrollBarL(iCurrentScrollSpeed);
+    }
+
+// ---------------------------------------------------------------------------
+//  Turns on or off vertical scrollbar.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetScrollBarVisibilityL(
+        const TFsScrollbarVisibility aVisibility)
+    {
+    iScrollbarVisibility = aVisibility;
+    UpdateScrollBarL(iCurrentScrollSpeed);
+    }
+
+// ---------------------------------------------------------------------------
+//  Gets scrollbar visibility.
+// ---------------------------------------------------------------------------
+//
+TFsScrollbarVisibility CFsTreeVisualizerBase::ScrollbarVisibility() const
+    {
+    FUNC_LOG;
+    return iScrollbarVisibility;
+    }
+
+// ---------------------------------------------------------------------------
+// Sets border status
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetBorderL(const TBool aVisible,
+        CAlfTexture* aBorderTexture)
+    {
+    FUNC_LOG;
+    if (!aBorderTexture)
+        {
+        FsGenericPanic(EFsListPanicBorderNotSet);
+        }
+
+    if (aVisible)
+        {
+        CAlfImageBrush* border = CAlfImageBrush::NewL(iOwnerControl->Env(),
+                TAlfImage(*aBorderTexture));
+        border->SetLayer(EAlfBrushLayerBackground);
+
+        border->SetBorders(-8, -8, -8, -8);
+        //<cmail>
+        // layout values needed here (not: only used from FS action menu)
+        //</cmail>
+        iBorderLayout->SetPadding(TPoint(5, 5));
+
+        if (iBorderLayout->Brushes()->Count() > 0)
+            {
+            iBorderLayout->Brushes()->Remove(0);
+            iBorderLayout->Brushes()->Reset();
+            }
+
+        iBorderLayout->Brushes()->AppendL(border, EAlfHasOwnership);
+        }
+    else
+        {
+        if (iBorderLayout->Brushes()->Count() > 0)
+            {
+            iBorderLayout->Brushes()->Remove(0);
+            iBorderLayout->Brushes()->Reset();
+            iBorderLayout->SetPadding(0);
+            }
+        }
+
+    iBorderLayout->SetFlag(EAlfVisualChanged);
+    iBorderLayout->UpdateChildrenLayout();
+    RefreshListViewL();
+    }
+
+// ---------------------------------------------------------------------------
+// Sets shadow status
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetShadowL(const TBool aVisible)
+    {
+    FUNC_LOG;
+    if (aVisible)
+        {
+        //remove shadow if it's already set
+        if (iShadowLayout && iShadowLayout->Brushes())
+            {
+            TInt count = iShadowLayout->Brushes()->Count();
+            if (count > 0)
+                {//there is only a shadow brush attached to this layout
+                iShadowLayout->Brushes()->Remove(KZero);
+                iShadowLayout->Brushes()->Reset();
+                iShadowLayout->SetFlag(EAlfVisualChanged);
+                }
+            }
+        //attach shadow brush to layout
+        CAlfShadowBorderBrush* shadow = CAlfShadowBorderBrush::NewLC(
+                iOwnerControl->Env(), KDefaultShadowWidth);
+        shadow->SetOpacity(.25f);
+
+        //set paddind to root layout so the shadow can be visible
+        TAlfBoxMetric m;
+        m.iBottom.iMagnitude = KDefaultShadowWidth;
+        m.iLeft.iMagnitude = KZero;
+        m.iRight.iMagnitude = KDefaultShadowWidth;
+        m.iTop.iMagnitude = KZero;
+        iRootLayout->SetPadding(m);
+
+        iShadowLayout->EnableBrushesL(ETrue);
+        iShadowLayout->Brushes()->AppendL(shadow, EAlfHasOwnership);
+        CleanupStack::Pop(shadow);
+
+        iShadowLayout->SetFlag(EAlfVisualChanged);
+        iRootLayout->UpdateChildrenLayout(KZero);
+        }
+    else
+        {
+        //remove shadow if it's already set
+        if (iShadowLayout && iShadowLayout->Brushes())
+            {
+            TInt count = iShadowLayout->Brushes()->Count();
+            if (count > 0)
+                {//there is only a shadow brush attached to this layout
+                iShadowLayout->Brushes()->Remove(KZero);
+                iShadowLayout->Brushes()->Reset();
+                iShadowLayout->SetFlag(EAlfVisualChanged);
+
+                //remove paddind from root layout
+                TAlfBoxMetric m;
+                m.iBottom.iMagnitude = KZero;
+                m.iLeft.iMagnitude = KZero;
+                m.iRight.iMagnitude = KZero;
+                m.iTop.iMagnitude = KZero;
+                iRootLayout->SetPadding(m);
+                iRootLayout->UpdateChildrenLayout(KZero);
+                }
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  Sets visualizer observer
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetVisualizerObserver(
+        MFsTreeVisualizerObserver* aObserver)
+    {
+    FUNC_LOG;
+    iVisualizerObserver = aObserver;
+    }
+
+// ---------------------------------------------------------------------------
+//  Returns parent layout.
+// ---------------------------------------------------------------------------
+//
+CAlfLayout& CFsTreeVisualizerBase::ParentLayout() const
+    {
+    FUNC_LOG;
+    return iParentLayout;
+    }
+
+// ---------------------------------------------------------------------------
+//  Function shows selector or hides it.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CFsTreeVisualizerBase::MakeSelectorVisibleL(TBool aVisible)
+    {
+    MakeSelectorVisibleL( aVisible, 0 );
+    }
+
+// ---------------------------------------------------------------------------
+//  Function shows selector or hides it.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::MakeSelectorVisibleL(TBool aVisible, TInt aDelay)
+    {
+    FUNC_LOG;
+    TAlfTimedValue opacity;
+
+    if (aVisible)
+        {
+        if (!iSelectorVisual)
+            {
+            CreateSelectorVisualL();
+            }
+
+        TBool isFocused = IsItemFocused(iFocusedItem);
+
+        if (iSelectorVisual)
+            {
+            if (isFocused && IsFocusShown())
+                {
+                if( aDelay )
+                    opacity.SetTarget(iSelectorOpacity, aDelay);
+                else
+                    opacity.SetValueNow(iSelectorOpacity);
+                }
+            else
+                {
+                if( aDelay )
+                    opacity.SetTarget(0.0, aDelay);
+                else
+                    opacity.SetValueNow(0.0);
+                }
+
+            iSelectorVisual->SetOpacity(opacity);
+            }
+        UpdateSelectorVisualL();
+        }
+    else
+        {
+        if (iSelectorVisual)
+            {
+            opacity.SetValueNow(0);
+            iSelectorVisual->SetOpacity(opacity);
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::UpdateSelectorVisualL(TInt /*aTime*/)
+    {
+    FUNC_LOG;
+    if (iSelectorVisual)
+        {
+        if (iFocusedItem == KFsTreeNoneID || !iFlags.IsSet(EListFocused) || !IsFocusShown())
+            {
+            TAlfTimedValue opacity;
+            opacity.SetValueNow(0.0f);
+            iSelectorVisual->SetOpacity(opacity);
+            }
+        else
+            {
+            //check if item is visible
+            MFsTreeItemVisualizer* vis(NULL);
+
+            iListLayout->SetFlag(EAlfVisualFlagFreezeLayout);
+            iListItemBackgroundLayout->SetFlag(EAlfVisualFlagFreezeLayout);
+
+            TRect itemRect(iViewPort.ItemRect(iFocusedItem));
+            if (itemRect.Height())
+                {
+                TSize currSize;
+                currSize.iWidth = iListLayout->Size().iX.Target() - 2
+                        * iListLayout->PaddingInPixels().iTl.iX;
+                currSize.iHeight = itemRect.Height();
+                iSelectorVisual->SetSize(currSize, 0);
+                TAlfRealPoint pNow;
+                pNow.iY = itemRect.iTl.iY;
+                pNow.iX = iListLayout->PaddingInPixels().iTl.iX;
+                iSelectorVisual->SetPos(pNow, 0);
+
+                TAlfTimedValue opacity(iSelectorOpacity, 0);
+                iSelectorVisual->SetOpacity(opacity);
+                if (iMarqueeType != EFsTextMarqueeNone)
+                    {
+                    vis = iTreeData->ItemVisualizer(iFocusedItem);
+                    vis->MarqueeL(iMarqueeType, iMarqueeSpeed,
+                            iMarqueStartDelay, iMarqueCycleStartDelay,
+                            iMarqueeRepetitions);
+                    }
+                }
+            else
+                {
+                TAlfTimedValue opacity;
+                opacity.SetValueNow(0.0f);
+                iSelectorVisual->SetOpacity(opacity);
+                }
+
+            iListLayout->ClearFlag(EAlfVisualFlagFreezeLayout);
+            iListItemBackgroundLayout->ClearFlag(EAlfVisualFlagFreezeLayout);
+            }
+        }
+    else if (iFocusedItem != KFsTreeNoneID && iFlags.IsSet(EListFocused))
+        {
+        MakeSelectorVisibleL(ETrue);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  The function deletes selector visual.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::DestroySelectorVisualL()
+    {
+    FUNC_LOG;
+
+    if (iSelectorVisual && iSelectorLayout)
+        {
+        iSelectorLayout->Remove(iSelectorVisual);
+        //destroy
+        iSelectorVisual->RemoveAndDestroyAllD();
+        iSelectorVisual = NULL;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  The function creates selector visual.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::CreateSelectorVisualL()
+    {
+    FUNC_LOG;
+    TAlfTimedValue opacity;
+
+    if (!iSelectorVisual)
+        {
+        if (iFocusedItem != KFsTreeNoneID)
+            {
+            MFsTreeItemVisualizer* vis =
+                    iTreeData->ItemVisualizer( iFocusedItem );
+            MFsTreeItemData* data = &iTreeData->ItemData( iFocusedItem );
+
+            iListLayout->SetFlag( EAlfVisualFlagFreezeLayout );
+            iListItemBackgroundLayout->SetFlag( EAlfVisualFlagFreezeLayout );
+            
+            iSelectorVisual = CAlfImageVisual::AddNewL(*iOwnerControl, iSelectorLayout);
+            opacity.SetValueNow(0.0f);
+            iSelectorVisual->SetOpacity(opacity);
+            iSelectorVisual->SetScaleMode( CAlfImageVisual::EScaleFit);
+            iSelectorVisual->EnableBrushesL();
+
+            // Set the selector visual size and pos.
+            iSelectorVisual->SetFlags(EAlfVisualFlagManualLayout | 
+                    EAlfVisualFlagIgnorePointer);           
+            
+            TRect itemRect(iViewPort.ItemRect(iFocusedItem));
+            itemRect.SetWidth(iListLayout->Size().iX.Target() - 2 * iListLayout->PaddingInPixels().iTl.iX);
+            if ( itemRect.Height() )
+                {
+                iSelectorVisual->SetPos(itemRect.iTl);
+                iSelectorVisual->SetSize(itemRect.Size());
+                }
+
+            //create a selector from skin or from a supplied bitmap
+            if ( iSelectorTexture )
+                {
+                CAlfImageBrush* brush = CAlfImageBrush::NewLC(
+                        iOwnerControl->Env(),TAlfImage(*iSelectorTexture));
+
+                brush->SetBorders(iLeftSelectorBorderWidth,
+                                  iRightSelectorBorderWidth,
+                                  iTopSelectorBorderHeight,
+                                  iBottomSelectorBorderHeight);
+
+                iSelectorVisual->Brushes()->AppendL(brush, EAlfHasOwnership);
+                CleanupStack::Pop(brush);
+                }
+            else if ( iSelectorBrush )
+                {
+                //append brush supplied by the user to the selector visual
+                iSelectorVisual->Brushes()->AppendL(
+                        iSelectorBrush, EAlfDoesNotHaveOwnership);
+
+                if ( iSelectorOpacity <= 0.0 || iSelectorOpacity > 1.0 )
+                        {
+                        iSelectorOpacity = 1.0;
+                        }
+
+                opacity.SetValueNow(iSelectorOpacity);
+                iSelectorVisual->SetOpacity(opacity);
+                }
+            else //no bitmap/brush given - create selector from skin
+                {
+                // apply a image brush to the visual
+                CAlfFrameBrush* brush = CAlfFrameBrush::NewLC(iOwnerControl->Env(),
+                                        KAknsIIDQsnFrList);
+
+                iSelectorVisual->Brushes()->AppendL(brush, EAlfHasOwnership);
+                CleanupStack::Pop(brush);
+
+                CAlfBrush& skinbrush( iSelectorVisual->Brushes()->At(
+                        iSelectorVisual->Brushes()->Count() - 1 ) );
+                CAlfFrameBrush*
+                    selectorBrush( static_cast<CAlfFrameBrush*>( &skinbrush ) );
+
+                const TRect outerRect( itemRect.Size() ); //outer rect has the size of item
+                TRect innerRect( outerRect );
+
+                innerRect.Shrink( 5, 5 );
+                if ( outerRect.Width() > 0 && outerRect.Height() > 0 &&
+                        innerRect.Width() > 0 && innerRect.Height() > 0   )
+                    {
+                    // aInnerRect, const TRect& aOuterRect
+                    selectorBrush->SetFrameRectsL( innerRect, outerRect );
+                    }
+                }
+
+            iListLayout->ClearFlag( EAlfVisualFlagFreezeLayout );
+            iListItemBackgroundLayout->ClearFlag( EAlfVisualFlagFreezeLayout );
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::UpdateListItemSizes()
+    {
+    FUNC_LOG;
+    TInt focused = iVisibleItems.Find(iFocusedItem);
+    if (focused == KErrNotFound)
+        {
+        return;
+        }
+    TInt count = iVisibleItemsBackground.Count();
+    for (TInt i = 0; i < count; ++i)
+        {
+        if (i == focused)
+            {//focused item already updated
+            continue;
+            }
+        else
+            {
+            UpdateListItemSize(i);
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::UpdateListItemSize(TInt aIndex)
+    {
+    FUNC_LOG;
+    TSize size;
+    TReal32 diff(0);
+    TReal32 speed(0);
+    TAlfTimedPoint sizeTarg;
+    TAlfTimedPoint sizeNow;
+    CAlfDeckLayout* lay;
+
+    lay = iVisibleItemsBackground[aIndex];
+
+    sizeNow.iY.SetTarget(lay->Size().iY.ValueNow(), 0);
+    sizeNow.iX.SetTarget(lay->Size().iX.ValueNow(), 0);
+    sizeTarg.iY.SetTarget(lay->Size().iY.Target(), 0);
+    sizeTarg.iX.SetTarget(lay->Size().iX.Target(), 0);
+
+    if (sizeNow.iY.Target() != sizeTarg.iY.Target())
+        {
+        diff = sizeNow.iY.Target() - sizeTarg.iY.Target();
+        if (diff < 0)
+            {
+            diff *= -1;
+            }
+
+        if (iCurrentScrollSpeed != 0)
+            {
+            speed = diff / iCurrentScrollSpeed * 1000;
+            }
+
+        TAlfTimedPoint p;
+        p.iY.SetTargetWithSpeed(sizeTarg.iY.Target(), speed);
+        p.iX.SetTarget(sizeTarg.iX.Target(), 0);
+        p.SetStyle(EAlfTimedValueStyleLinear);
+
+        lay->SetSize(p);
+        iListLayout->Visual(aIndex).SetSize(p);
+
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::ScrollListLayoutsL(TInt aScrollOffset, TInt /*aScrollTime*/)
+    {
+    FUNC_LOG;
+    TPoint position(iViewPort.Position());
+    if (position.iY != aScrollOffset)
+        {
+        position.iY = aScrollOffset;
+        iViewPort.SetPositionL(position);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::ScrollListLayouts(TInt aScrollOffset,
+        TInt aScrollTime)
+    {
+    TRAPD( error, ScrollListLayoutsL(aScrollOffset, aScrollTime) );
+    return error;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TFsTreeItemId CFsTreeVisualizerBase::NextFocusableItem(
+        const TFsTreeItemId aItemId)
+    {
+    FUNC_LOG;
+    TFsTreeItemId treeItem = KFsTreeNoneID;
+    TFsTreeItemId foundItem = KFsTreeNoneID;
+
+    TFsTreeIterator treeIter = iTreeData->Iterator(KFsTreeRootID, aItemId,
+            KFsTreeIteratorSkipCollapsedFlag | KFsTreeIteratorSkipHiddenFlag);
+
+    while (treeIter.HasNext())
+        {
+        treeItem = treeIter.Next();
+        if (iTreeData->ItemVisualizer(treeItem)->IsFocusable())
+            {
+            foundItem = treeItem;
+            break;
+            }
+        }
+
+    return foundItem;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TFsTreeItemId CFsTreeVisualizerBase::PrevFocusableItem(
+        const TFsTreeItemId aItemId)
+    {
+    FUNC_LOG;
+    TFsTreeItemId treeItem = KFsTreeNoneID;
+    TFsTreeItemId foundItem = KFsTreeNoneID;
+
+    TFsTreeIterator treeIter = iTreeData->Iterator(KFsTreeRootID, aItemId,
+            KFsTreeIteratorSkipCollapsedFlag | KFsTreeIteratorSkipHiddenFlag);
+
+    while (treeIter.HasPrevious())
+        {
+        treeItem = treeIter.Previous();
+        if (iTreeData->ItemVisualizer(treeItem)->IsFocusable())
+            {
+            foundItem = treeItem;
+            break;
+            }
+        }
+
+    return foundItem;
+    }
+
+// ---------------------------------------------------------------------------
+//  Function sets current scroll speed based on the up/down key repeats.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetCurrentScrollSpeed(TInt aKeyRepeats)
+    {
+    FUNC_LOG;
+    TInt time(0);
+    if (iScrollSpeed > 0)
+        {
+        time = iIntx->Interval(iScrollSpeed);
+        if (time != iScrollSpeed)
+            {
+            iCurrentScrollSpeed = time;
+            if (aKeyRepeats > 0)
+                {
+                iCurrentScrollSpeed = iCurrentScrollSpeed * (1 - aKeyRepeats
+                        * iScrollAccelerationRate);
+                if (iCurrentScrollSpeed < 0)
+                    {
+                    iCurrentScrollSpeed = 1;
+                    }
+                }
+            }
+        else
+            {
+            iCurrentScrollSpeed = iScrollSpeed;
+            }
+
+        if (iCurrentScrollSpeed < iScrollSpeed)
+            {
+            iCurrentScrollSpeed = KZero;
+            }
+        //        TInt part(0);
+        //        part = iScrollSpeed * 0.9;
+
+        //        if ( iCurrentScrollSpeed <= part )
+        //            {
+        //            iCurrentScrollSpeed = 0;
+        //            }
+        //        if (iCurrentScrollSpeed < 200)
+        //            {
+        //            iCurrentScrollSpeed = 200;
+        //            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  Gets default settings from Central Repository.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::ReadDefaultValuesFromCenRep()
+    {
+    FUNC_LOG;
+    CRepository *crep(NULL);
+        TRAP_IGNORE( crep = CRepository::NewL( KCRUidFSGenericUI ) );
+
+    //scroll time
+    if (!crep || crep->Get(KFSGenericUIDefScrollSpeed, iScrollSpeed)
+            != KErrNone)
+        {
+        iScrollSpeed = KFsListDefaultScrollSpeed;
+        }
+    if (iScrollSpeed < 0)
+        {
+        iScrollSpeed = 0;
+        }
+
+    //duration of the fade-in effect
+    if (!crep || crep->Get(KFSGenericUIFadeIn, iFadeInEffectTime) != KErrNone)
+        {
+        iFadeInEffectTime = KFsListDefaultFadeInTime;
+        }
+    if (iFadeInEffectTime < 0)
+        {
+        iFadeInEffectTime = 0;
+        }
+
+    //duration of the fade-out effect
+    if (!crep || crep->Get(KFSGenericUIFadeOut, iFadeOutEffectTime)
+            != KErrNone)
+        {
+        iFadeOutEffectTime = KFsListDefaultFadeOutTime;
+        }
+    if (iFadeOutEffectTime < 0)
+        {
+        iFadeOutEffectTime = 0;
+        }
+
+    //duration of the slide-in effect
+    if (!crep || crep->Get(KFSGenericUISlideInTime, iSlideInDuration)
+            != KErrNone)
+        {
+        iSlideInDuration = KFsListDefaultSlideInTime;
+        }
+    if (iSlideInDuration < 0)
+        {
+        iSlideInDuration = KFsListDefaultSlideInTime;
+        }
+
+    //duration of the slide-out effect
+    if (!crep || crep->Get(KFSGenericUISlideOutTime, iSlideOutDuration)
+            != KErrNone)
+        {
+        iSlideOutDuration = KFsListDefaultSlideOutTime;
+        }
+    if (iSlideOutDuration < 0)
+        {
+        iSlideOutDuration = 0;
+        }
+
+    //direction of the slide-in effect
+    TInt slideInDir;
+    if (!crep || crep->Get(KFSGenericUISlideInDir, slideInDir) != KErrNone)
+        {
+        slideInDir = KFsListDefaultSlideInDir;
+        }
+    if (slideInDir < 0 || slideInDir > 4)
+        {
+        slideInDir = 0;
+        }
+    iSlideInDirection
+            = static_cast<MFsTreeVisualizer::TFsSlideEffect> (slideInDir);
+
+    //direction of the slide-out effect
+    TInt slideOutDir;
+    if (!crep || crep->Get(KFSGenericUISlideOutDir, slideOutDir) != KErrNone)
+        {
+        slideOutDir = KFsListDefaultSlideOutDir;
+        }
+    if (slideOutDir < 0 || slideOutDir > 4)
+        {
+        slideOutDir = 0;
+        }
+    iSlideOutDirection =
+                   static_cast<MFsTreeVisualizer::TFsSlideEffect>(slideOutDir);
+
+    //item expansion time
+    if ( !crep || crep->Get( KFSGenericUIListExpTimeOut, iCurrentScrollSpeed ) !=
+        KErrNone  )
+        {
+        iCurrentScrollSpeed = KFsListDefaultListExpTimeOut;
+        }
+    if (iCurrentScrollSpeed < 1)
+        {
+        iCurrentScrollSpeed = 1;
+        }
+
+    //list looping type
+    TInt listLooping;
+    if ( !crep || crep->Get( KFSGenericUIListLooping, listLooping) !=
+        KErrNone )
+        {
+        listLooping = KFsListDefaultListLooping;
+        }
+    if (listLooping < 0 || listLooping > 2)
+        {
+        listLooping = 0;
+        }
+    iLooping = static_cast<TFsTreeListLoopingType> (listLooping);
+
+    delete crep;
+    }
+
+// ---------------------------------------------------------------------------
+//  Sets values to an item which are default for the whole list (e.g. if
+//  items are always extended.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::ApplyListSpecificValuesToItem(
+        MFsTreeItemVisualizer *aItemVis)
+    {
+    FUNC_LOG;
+    //list can have all items in extended or in a normal state
+    aItemVis->SetAlwaysExtended(IsItemsAlwaysExtended());
+
+    //global indentation in pixels for a list component
+    aItemVis->SetIndentation(iLevelIndentation);
+
+    //global indentation in pixels for a list component
+    aItemVis->SetTextStyleManager(*iTextStyleManager);
+    }
+
+// ---------------------------------------------------------------------------
+// The function calculates tree height up to the specified item.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::CalculateTreeHeightUpToItem(
+        const TFsTreeItemId aItemId, TInt& aHeight) const
+    {
+    FUNC_LOG;
+    TFsTreeItemId tmpItem(KFsTreeNoneID);
+    TFsTreeItemId itemToFind(KFsTreeNoneID);
+    itemToFind = aItemId;
+    TInt retVal(KErrNone);
+    //validate given item id
+    if (!iTreeData->Contains(itemToFind))
+        {
+        retVal = KErrNotFound;
+        }
+    if (retVal == KErrNone)
+        {
+        //create an iterator
+        TFsTreeIterator iter = iTreeData->Iterator(KFsTreeRootID,
+                KFsTreeRootID, KFsTreeIteratorSkipCollapsedFlag
+                        | KFsTreeIteratorSkipHiddenFlag);
+
+        TBool notFound(ETrue);
+        TInt height(0);
+        MFsTreeItemVisualizer* vis = NULL;
+
+        //iterate up to the given item id and calculate the tree height
+        while (notFound && iter.HasNext())
+            {
+            tmpItem = iter.Next();
+            if (tmpItem == itemToFind)
+                {
+                notFound = EFalse;
+                continue;
+                }
+            else
+                {//add item's height
+                vis = iTreeData->ItemVisualizer(tmpItem);
+                if (vis->IsExtendable() && vis->IsExtended())
+                    {
+                    height += vis->ExtendedSize().iHeight;
+                    }
+                else
+                    {
+                    height += vis->Size().iHeight;
+                    }
+                }
+            }
+
+        if (notFound)
+            {
+            retVal = KErrNotFound;
+            }
+        else
+            {
+            retVal = KErrNone;
+            aHeight = height;
+            }
+        }
+    return retVal;
+    }
+
+// ---------------------------------------------------------------------------
+//  Update list's visual content by appending items into empty gap in list.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::FillGapWithItemsL(const TInt /*aHeight*/)
+    {
+    FUNC_LOG;
+    }
+
+// ---------------------------------------------------------------------------
+//  The function checks if the given item id matches the focused one.
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::IsItemFocused(TFsTreeItemId aItemId) const
+    {
+    FUNC_LOG;
+    TBool isFocused(EFalse);
+
+    if (iFocusedItem != KFsTreeNoneID)
+        {
+        if (iFlags.IsSet(EListFocused) && (aItemId == iFocusedItem))
+            {
+            isFocused = ETrue;
+            }
+        }
+    return isFocused;
+    }
+
+// <cmail> "Base class modifications for using touch"
+
+// ---------------------------------------------------------------------------
+//  C++ constructor.
+// ---------------------------------------------------------------------------
+//
+CFsTreeVisualizerBase::CFsTreeVisualizerBase( CAlfControl* aOwnerControl,
+        CAlfLayout& aParent, const TBool aDirectTouchMode )
+    : iVisualizationState(EFsTreeHidden),
+      iOwnerControl ( aOwnerControl ),
+      iParentLayout ( aParent ),
+      iTreeData ( NULL ),
+      iFocusedItem ( KFsTreeNoneID ),
+      iListLayout ( NULL ),
+      iLooping ( EFsTreeListLoopingDisabled ),
+      iSelectorTexture(NULL),
+      iSelectorBrush(NULL),
+      iSelectorOpacity(1.0),
+      iLeftSelectorBorderWidth(KFSListDefaultSelectorBorderWidth),
+      iRightSelectorBorderWidth(KFSListDefaultSelectorBorderWidth),
+      iTopSelectorBorderHeight(KFSListDefaultSelectorBorderWidth),
+      iBottomSelectorBorderHeight(KFSListDefaultSelectorBorderWidth),
+      iSelectorMovementType(EFsSelectorMoveImmediately),
+      iMarqueeSpeed(30),
+      iScrollSpeed( 0 ),
+      iCurrentScrollSpeed(0),
+      iScrollAccelerationRate(0.4),
+      iFadeInEffectTime(0),
+      iFadeOutEffectTime(0),
+      iWatermark(NULL),
+      iLevelIndentation ( KFsDefaultIndentation ),
+      iSlideInDuration ( 0 ),
+      iSlideInDirection ( ESlideFromTop ),
+      iSlideOutDuration ( 0 ),
+      iSlideOutDirection ( ESlideFromTop ),
+      iScrollOffset(0),
+      iMarqueeType(EFsTextMarqueeForth),
+      iMarqueStartDelay( 1000 ), //one sec of delay
+      iMarqueCycleStartDelay ( 500 ), //half a sec cycle delay
+      iMarqueeRepetitions (-1), //infinite loop
+      iViewPort( *this, iWorld )
+    {
+    FUNC_LOG;
+    iFlags.Set(EAutoRefresh);
+    iFlags.Assign(EDirectTouchMode, aDirectTouchMode);
+    iFlags.Set( EExpandCollapseOnLongTap );
+    }
+// </cmail>
+
+// ---------------------------------------------------------------------------
+//  Second phase constructor.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::ConstructL()
+    {
+    FUNC_LOG;
+    ReadDefaultValuesFromCenRep();
+
+    if (CAknPhysics::FeatureEnabled())
+        {
+        iPhysics = CAknPhysics::NewL(*this, NULL );
+        iDragHandler = CDragHandler::NewL(*this,
+                iPhysics->HighlightTimeout(), iFlags);
+        }
+
+    iRootData = CFsTreePlainOneLineItemData::NewL();
+    HBufC* empty = StringLoader::LoadL(R_AVKON_EMPTY_POPUP_LIST_TEXT);
+    CleanupStack::PushL(empty);
+    iRootData->SetDataL(*empty);
+    CleanupStack::PopAndDestroy(empty);
+
+    iParentLayout.UpdateChildrenLayout();
+
+    iRootVisualizer = CFsTreePlainRootVisualizer::NewL(*iOwnerControl);
+
+    iRootLayout = CAlfDeckLayout::AddNewL(*iOwnerControl, &iParentLayout);
+    iRootLayout->EnableBrushesL();
+    iRootLayout->SetClipping(ETrue);
+    iRootLayout->UpdateChildrenLayout();
+
+    iTextStyleManager = CFsAlfTextStyleManager::NewL(
+            iRootLayout->Env().TextStyleManager());
+
+    iRootVisualizer->SetTextStyleManager(*iTextStyleManager);
+
+    iShadowLayout = CAlfDeckLayout::AddNewL(*iOwnerControl, iRootLayout);
+    iShadowLayout->EnableBrushesL();
+    iShadowLayout->UpdateChildrenLayout();
+
+    iBorderLayout = CAlfDeckLayout::AddNewL(*iOwnerControl, iShadowLayout);
+    iBorderLayout->EnableBrushesL();
+    iBorderLayout->UpdateChildrenLayout();
+
+    iWatermarkLayout = CAlfDeckLayout::AddNewL(*iOwnerControl, iBorderLayout);
+    iWatermarkLayout->EnableBrushesL();
+    iWatermarkLayout->UpdateChildrenLayout();
+
+    iComponentLayout = CAlfGridLayout::AddNewL(*iOwnerControl, 1, 1,
+            iWatermarkLayout);
+    iComponentLayout->SetClipping(ETrue);
+    iComponentLayout->EnableBrushesL();
+    iComponentLayout->UpdateChildrenLayout();
+
+    iListDeck = CAlfDeckLayout::AddNewL(*iOwnerControl, iComponentLayout);
+
+    iListItemBackgroundLayout = CAlfFlowLayout::AddNewL(*iOwnerControl,
+            iListDeck);
+    iListItemBackgroundLayout->SetFlowDirection(CAlfFlowLayout::EFlowVertical);
+    iListItemBackgroundLayout->SetClipping(ETrue);
+    iListItemBackgroundLayout->EnableScrollingL(ETrue);
+    TAlfTimedPoint tpListScrollOffset;
+    tpListScrollOffset.SetStyle(EAlfTimedValueStyleLinear);
+    iListItemBackgroundLayout->SetScrollOffset(tpListScrollOffset);
+
+    iSelectorLayout = CAlfDeckLayout::AddNewL(*iOwnerControl, iListDeck);
+    iSelectorLayout->SetClipping(ETrue);
+
+    iListLayout = CAlfFlowLayout::AddNewL(*iOwnerControl, iListDeck);
+    iListLayout->SetFlowDirection(CAlfFlowLayout::EFlowVertical);
+
+    iListLayout->EnableBrushesL();
+    iListLayout->EnableScrollingL(ETrue);
+    iListLayout->SetScrollOffset(tpListScrollOffset);
+
+    //list pane's padding taken from layout manager
+    EnableListPanePadding(ETrue);
+
+    iListLayout->UpdateChildrenLayout();
+    iListItemBackgroundLayout->UpdateChildrenLayout();
+
+    iBorderBrush = CAlfBorderBrush::NewL(iOwnerControl->Env(), 0, 1, 0, 0);
+    static_cast<CAlfBorderBrush*> (iBorderBrush)->SetColor(KRgbGray);
+    static_cast<CAlfBorderBrush*> (iBorderBrush)->SetThickness(
+            TAlfTimedPoint(0.0f, 0.5f));
+    iBorderBrush->SetLayer(EAlfBrushLayerForeground);
+
+    iScrollbarVisibility = EFsScrollbarShowAlways;
+
+    iScrollBar = new (ELeave) CAknDoubleSpanScrollBar(0);
+    iScrollBar->ConstructL(ETrue, this, 0, CEikScrollBar::EVertical, 1000);
+
+    iScrollbarModel.SetScrollSpan(iComponentLayout->Size().Target().iY);
+    iScrollbarModel.SetFocusPosition(iViewPort.Position().iY);
+    iScrollbarModel.SetWindowSize(iListLayout->Size().iY.Target());
+
+    iScrollBar->MakeVisible(EFalse);
+    iScrollBar->SetModelL(&iScrollbarModel);
+
+    iDummyScrollbar = CAlfImageVisual::AddNewL(*iOwnerControl);
+    iComponentLayout->Append(iDummyScrollbar);
+
+    // </cmail>
+
+    iFadeEffect = CFsFadeEffect::NewL(iOwnerControl, this, iRootLayout, 0);
+    iSlideEffect = CFsSlideEffect::NewL(iOwnerControl, this, iRootLayout, 0);
+
+    iFadeInEffectTime = KFsListDefaultFadeInTime;
+    iFadeOutEffectTime = KFsListDefaultFadeOutTime;
+
+    iIntx = new (ELeave) CFsInteractionInterval;
+
+    iOwnerControl->Env().AddActionObserverL(this);
+
+    iWorld.AddObserverL(iViewPort);
+    iWorld.AddObserverL(*this);
+    UpdateViewPortL();
+    }
+
+// <cmail> Change scrollbar to avkon (to support skinning & touch)
+// ---------------------------------------------------------------------------
+//  Handle scrollbar events
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::HandleScrollEventL(CEikScrollBar* aScrollBar,
+        TEikScrollEvent aEventType)
+    {
+    FUNC_LOG;
+
+    if (iPhysics)
+        {
+        iPhysics->StopPhysics();
+        }
+
+    if (aScrollBar == iScrollBar)
+        {
+
+        switch (aEventType)
+            {
+            case EEikScrollHome:
+                //Jump to beginning
+                break;
+            case EEikScrollEnd:
+                //Jump to end
+                break;
+            default:
+                TPoint position(iViewPort.Position());
+                position.iY = aScrollBar->ThumbPosition();
+                iViewPort.SetPositionL(position);
+                break;
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//  Handle visibility change
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::NotifyControlVisibilityChange(TBool aIsVisible)
+    {
+    FUNC_LOG;
+
+    if (aIsVisible && iVisualizationState == EFsTreeVisible)
+        {
+        UpdateScrollBar();
+        }
+    else
+        {
+        iScrollBar->MakeVisible(EFalse);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::DisableKineticScrolling( TBool aDisable )
+    {
+    FUNC_LOG;
+    iKineticScrollingDisabled = aDisable;
+    }
+
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::IsKineticScrollingDisabled() const
+    {
+    FUNC_LOG;
+    return iKineticScrollingDisabled;
+    }
+
+// ---------------------------------------------------------------------------
+// World updated
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::WorldUpdatedL(const TWorld& /*aWorld*/)
+    {
+    FUNC_LOG;
+    if (iFlags.IsSet(EPhysicsOn))
+        {
+        iFlags.Set(EUpdatePhysicsAfterSimulationFinished);
+        }
+    else
+        {
+        UpdatePhysicsL();
+        }
+    UpdateScrollBarL();
+    }
+
+// ---------------------------------------------------------------------------
+// ViewPort updated
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::ViewPortUpdatedL(TViewPort& aViewPort)
+    {
+    FUNC_LOG;
+    RArray<TFsTreeItemId> visibleItems;
+    RArray<TFsTreeItemId> removableItems;
+    TInt scrollOffset;
+    TBool fullUpdate;
+    CleanupClosePushL(visibleItems);
+    CleanupClosePushL(removableItems);
+    aViewPort.GetVisibleItemsL(removableItems, visibleItems, scrollOffset,
+            fullUpdate);
+    TAlfRefreshMode rm(EAlfRefreshModeAutomatic);
+    rm = CAlfStatic::Env().RefreshMode();
+    CAlfStatic::Env().SetRefreshMode(EAlfRefreshModeManual);
+    iListLayout->SetFlag(EAlfVisualFlagFreezeLayout);
+    // clear list
+    TInt removed(0);
+    if (fullUpdate)
+        {
+        removed += iListLayout->Count();
+        for (TInt i = removed - 1; i >= 0; i--)
+            {
+            iTreeData->ItemVisualizer(VisualItemId(&iListLayout->Visual(i)))->Hide();
+            }
+        iVisibleItems.Reset();
+        }
+    else
+        {
+        for (TInt i = 0; i < removableItems.Count(); i++)
+            {
+            CAlfVisual* visual(
+                    &iTreeData->ItemVisualizer(removableItems[i])->Layout());
+            if (iListLayout->FindVisual(visual) != KErrNotFound)
+                {
+                removed++;
+                }
+            iTreeData->ItemVisualizer(removableItems[i])->Hide();
+            iVisibleItems.Remove(iVisibleItems.Find(removableItems[i]));
+            }
+        }
+
+    // update items to list
+    TInt added(0);
+    for (TInt i = 0; i < visibleItems.Count(); i++)
+        {
+        const TFsTreeItemId itemId(visibleItems[i]);
+        if (itemId != KFsTreeNoneID)
+            {
+            MFsTreeItemVisualizer* visualizer = iTreeData->ItemVisualizer(
+                    itemId);
+            visualizer->ShowL(*iListLayout);
+            TSize size(visualizer->Size());
+            TInt listInnerWidth(iListLayout->Size().IntTarget().iX);
+            TAlfTimedPoint tpItemSize(listInnerWidth, size.iHeight);
+            tpItemSize.SetTarget(TAlfRealPoint(listInnerWidth, size.iHeight),
+                    0);
+            CAlfLayout& visualizerLayout(visualizer->Layout());
+            visualizerLayout.SetSize(tpItemSize);
+            visualizerLayout.PropertySetIntegerL(KPropertyItemId(), itemId);
+            visualizer->UpdateL(iTreeData->ItemData(itemId), 
+                    IsItemFocused(itemId) && IsFocusShown(),
+                    iTreeData->Level(itemId), iMarkIcon, iMenuIcon,
+                    0);
+            visualizerLayout.Brushes()->AppendL(iBorderBrush,
+                    EAlfDoesNotHaveOwnership);
+            CAlfBrush* bgBrush(NULL);
+            if (visualizer->GetBackgroundBrush(bgBrush))
+                {
+                bgBrush->SetLayer(EAlfBrushLayerBackground);
+                visualizerLayout.Brushes()->AppendL(bgBrush,
+                        EAlfDoesNotHaveOwnership);
+                }
+            const TInt orderPosition(
+                    i < iListLayout->Count() ? i : iListLayout->Count() - 1);
+            iListLayout->Reorder(visualizerLayout, orderPosition);
+            iVisibleItems.AppendL(itemId);
+            added++;
+            }
+        }
+
+    INFO_2("totalItems: %d, visibleItems: %d", iWorld.ItemCount(), visibleItems.Count());
+    CleanupStack::PopAndDestroy(2); // visibleItems.Close(), removableItems.Close()
+    // scroll list layout by offset
+    TAlfTimedPoint alfOffset;
+    alfOffset.iY.SetTarget(scrollOffset, 0);
+    iListLayout->SetScrollOffset(alfOffset);
+    iListLayout->ClearFlag(EAlfVisualFlagFreezeLayout);
+    iListLayout->UpdateChildrenLayout();
+    UpdateSelectorVisualL();
+    UpdateScrollBarIfNeededL();
+    CAlfStatic::Env().RefreshCallBack(&CAlfStatic::Env());
+    CAlfStatic::Env().SetRefreshMode(rm);
+    }
+
+// ---------------------------------------------------------------------------
+// Set panning position
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetPanningPosition(const TPoint& aDelta)
+    {
+    FUNC_LOG;
+    iPhysics->RegisterPanningPosition(aDelta);
+    }
+
+// ---------------------------------------------------------------------------
+// Starts flicking.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::StartPhysics(TPoint& aDrag,
+        const TTime& aStartTime)
+    {
+    FUNC_LOG;
+    TTime startTime( aStartTime );
+    TTime now;
+    now.HomeTime();
+    TInt moveTime( now.MicroSecondsFrom( aStartTime ).Int64() );
+    if (moveTime > KFlickMaxDuration) 
+        {
+        startTime = now - TTimeIntervalMicroSeconds( KFlickMaxDuration - 1 );
+        aDrag.iY = aDrag.iY * KFlickMaxDuration / moveTime;
+        }
+    iPhysics->StartPhysics(aDrag, startTime);
+    iFlags.Set(EPhysicsOn);
+    }
+
+// ---------------------------------------------------------------------------
+// Update physics
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::UpdatePhysicsL()
+    {
+    FUNC_LOG;
+    if (iPhysics)
+        {
+        SafeDelete(iPhysics);
+        iPhysics = CAknPhysics::NewL(*this, NULL );
+        const TSize viewSize(iViewPort.Size());
+        const TSize worldSize(viewSize.iWidth, Max(iWorld.Height(),
+                viewSize.iHeight));
+        iPhysics->InitPhysicsL(worldSize, viewSize, EFalse);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// Physic updated view position
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::ViewPositionChanged(const TPoint& aNewPosition,
+        TBool /*aDrawNow*/, TUint /*aFlags*/)
+    {
+    FUNC_LOG;
+    TInt error(KErrNone);
+    TRAP( error, iViewPort.SetCenterPositionL(aNewPosition) );
+    ERROR_1( error, "iViewPort.SetCenterPositionL failed with error: %d", error );
+    }
+
+// ---------------------------------------------------------------------------
+// Physic emulation has finished
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::PhysicEmulationEnded()
+    {
+    FUNC_LOG;
+    iFlags.Clear(EPhysicsOn);
+    if (iFlags.IsSet(EUpdatePhysicsAfterSimulationFinished))
+        {
+        iFlags.Clear(EUpdatePhysicsAfterSimulationFinished);
+            TRAP_IGNORE( UpdatePhysicsL() );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TPoint CFsTreeVisualizerBase::ViewPosition() const
+    {
+    FUNC_LOG;
+    return iViewPort.CenterPosition();
+    }
+
+// ---------------------------------------------------------------------------
+// Wrapper for SetFocusedItemAndSendEventL to trap the error and return it
+// instead of leaving.
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::SetFocusedItemAndSendEvent(
+    const TFsTreeItemId aItemId, TPointerEventType aEventType )
+    {
+    FUNC_LOG;
+    TRAPD(error, SetFocusedItemAndSendEventL( aItemId, aEventType ) );
+    return error;
+    }
+
+// ---------------------------------------------------------------------------
+// Sets the specified item as focused and sends event about touch focusing if
+// the same item is already focused, action event will be sent instead.
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::SetFocusedItemAndSendEventL(
+        const TFsTreeItemId aItemId, TPointerEventType aEventType )
+    {
+    FUNC_LOG;
+
+    // Handles all other than pointer up events.
+    // Focus is drawn when:
+    //  - new item is selected (FocusedItem() != aItemId)
+    //  - pointer is pressed down and focus is not visible by default
+    //    (aEventType == EPointerDown ) && IsFocusShown())
+    if( ( aEventType < EPointerUp ) &&
+        ( !iFlags.IsSet( EListFocused ) || FocusedItem() != aItemId ||
+            ( ( aEventType == EPointerDown ) && IsFocusShown() ) ) )
+        {
+        SetFocusedItemL( aItemId );
+        iVisualizerObserver->TreeVisualizerEventL(
+            MFsTreeVisualizerObserver::EFsTreeItemTouchFocused,
+            FocusedItem() );
+
+        // If DirectTouchMode (actions happens in pointer down events)
+        if( iFlags.IsSet( EDirectTouchMode ) && aEventType == EPointerDown )
+            {
+            iTouchPressed = EFalse;
+            iVisualizerObserver->TreeVisualizerEventL(
+                MFsTreeVisualizerObserver::EFsTreeItemTouchAction,
+                aItemId );
+            }
+        }
+    else if( aEventType == ELongTap )
+        {
+		iVisualizerObserver->TreeVisualizerEventL(
+				MFsTreeVisualizerObserver::EFsTreeItemTouchLongTap,
+  			    aItemId );
+        }
+    else if( aEventType == EPointerUp )
+        {
+        iVisualizerObserver->TreeVisualizerEventL(
+            MFsTreeVisualizerObserver::EFsTreeItemTouchAction, aItemId );
+        }
+    }
+
+// CFsTreeVisualizerBase::CDragHandler
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+CFsTreeVisualizerBase::CDragHandler* CFsTreeVisualizerBase::CDragHandler::NewL(
+        CFsTreeVisualizerBase& aTree, const TInt aHighlightTimeout,
+        const TBitFlagsT<TUint>& aFlags)
+    {
+    FUNC_LOG;
+    CDragHandler* self = new (ELeave) CDragHandler(aTree, aHighlightTimeout,
+            aFlags);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+CFsTreeVisualizerBase::CDragHandler::~CDragHandler()
+    {
+    FUNC_LOG;
+    delete iHighlightTimer;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::CDragHandler::Reset()
+    {
+    FUNC_LOG;
+    iFlags.ClearAll();
+    iHighlightTimer->Cancel();
+    iItemId = KFsTreeNoneID;
+    iDragDirection = EDraggingNone;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+CFsTreeVisualizerBase::CDragHandler::TDragDirection 
+    CFsTreeVisualizerBase::CDragHandler::DragDirection( 
+        const TPoint& aCurrent, const TPoint aPrevious ) const
+    {
+    FUNC_LOG;
+    if (aCurrent.iY > aPrevious.iY) 
+        {
+        return EDraggingDown;
+        }
+    else if (aCurrent.iY < aPrevious.iY)
+        {
+        return EDraggingUp;
+        }
+    else 
+        {
+        return iDragDirection;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::CDragHandler::PointerDown(
+        const TPointerEvent& aEvent, const TFsTreeItemId aItemId)
+    {
+    FUNC_LOG;
+    Reset();
+    iItemId = aItemId;
+    iPosition = aEvent.iParentPosition;
+    iLastPointerPosition = aEvent.iParentPosition;
+    iStartTime.HomeTime();
+    iFlags.Set( EPointerDownReceived );
+
+    iTree.SetFocusedItemAndSendEvent( iItemId, EPointerDown );
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::CDragHandler::PointerRepeat(
+        const TPointerEvent& /*aEvent*/ )
+    {
+    if( iItemId != KFsTreeNoneID && !IsFlicking() )
+        {
+        iFlags.Set( EWasRepeat );
+        iTree.SetFocusedItemAndSendEvent( iItemId, ELongTap );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::CDragHandler::PointerUp(
+        const TPointerEvent& aEvent, const TFsTreeItemId aItemId )
+    {
+    FUNC_LOG;
+    // If kinetic scrolling is disabled
+    if( iTree.IsKineticScrollingDisabled() )
+        {
+        if( ( aItemId != KFsTreeNoneID ) &&
+            ( iTree.FocusedItem() == aItemId  ) )
+            {
+            iTree.SetFocusedItemAndSendEvent( iItemId, EPointerUp );
+            }
+        }
+    else if ( IsFlicking() )
+        {
+        TPoint drag(iPosition - aEvent.iParentPosition);
+        iTree.StartPhysics( drag, iStartTime );
+        }
+    else if( !iFlags.IsSet( EWasRepeat ) && iItemId != KFsTreeNoneID )
+        {
+        iTree.SetFocusedItemAndSendEvent( iItemId, EPointerUp );
+        }
+    iLastPointerPosition = iPosition = TPoint();
+    iFlags.Clear( EPointerDownReceived );
+    iDragDirection = EDraggingNone;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::CDragHandler::DragDelta(
+        const TPointerEvent& aEvent) const
+    {
+    FUNC_LOG;
+    return Abs(iPosition.iY - aEvent.iPosition.iY);
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TPoint CFsTreeVisualizerBase::CDragHandler::PointerDrag(
+        const TPointerEvent& aEvent, const TFsTreeItemId /*aItemId*/)
+    {
+    FUNC_LOG;
+    // If kinetic scrolling is disabled
+    if( iTree.IsKineticScrollingDisabled() )
+        {
+        iLastPointerPosition = iPosition;
+        return aEvent.iPosition;
+        }
+
+    if (!iFlags.IsSet(EPointerDownReceived))
+        {
+        iLastPointerPosition = iPosition = aEvent.iPosition;
+        iFlags.Set(EPointerDownReceived);
+        }
+    else
+        {
+        iHighlightTimer->Cancel();
+        if (!iTreeVisualizerFlags.IsSet(EPhysicsOn))
+            {
+            iTree.SetPanningPosition(TPoint(0, iLastPointerPosition.iY
+                    - aEvent.iPosition.iY));
+            }
+        TDragDirection dragDirection(DragDirection(aEvent.iPosition, iLastPointerPosition));
+        const TBool dragDirectionChanged( 
+                (dragDirection == EDraggingUp && iDragDirection == EDraggingDown ) ||
+                (dragDirection == EDraggingDown && iDragDirection == EDraggingUp ) );
+        if (dragDirectionChanged)
+            {
+            iPosition = aEvent.iPosition;
+            iStartTime.HomeTime();
+            }
+        iDragDirection = dragDirection;
+        iLastPointerPosition = aEvent.iPosition;
+        }
+    return iPosition - aEvent.iPosition;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::CDragHandler::EnableFlicking()
+    {
+    FUNC_LOG;
+    iFlags.Set(EFlicking);
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::CDragHandler::IsFlicking() const
+    {
+    FUNC_LOG;
+    return iFlags.IsSet(EFlicking);
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+CFsTreeVisualizerBase::CDragHandler::CDragHandler(
+        CFsTreeVisualizerBase& aTree, const TInt aHighlightTimeout,
+        const TBitFlagsT<TUint>& aFlags) :
+    iTree(aTree), iHighlightTimeout(aHighlightTimeout * 1000),
+            iTreeVisualizerFlags(aFlags)
+    {
+    FUNC_LOG;
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CFsTreeVisualizerBase::CDragHandler::ConstructL()
+    {
+    FUNC_LOG;
+    iHighlightTimer = CPeriodic::NewL(CActive::EPriorityStandard);
+    }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TInt CFsTreeVisualizerBase::CDragHandler::HighlightTimerCallback( TAny* aPtr )
+    {
+    FUNC_LOG;
+    CDragHandler* self = reinterpret_cast<CDragHandler*>( aPtr );
+    self->iHighlightTimer->Cancel();
+    return self->iTree.SetFocusedItemAndSendEvent( self->iItemId, ELongTap );
+    }
+
+// ---------------------------------------------------------------------------
+// CFsTreeVisualizerBase::IsFocusShown
+// ---------------------------------------------------------------------------
+//
+TBool CFsTreeVisualizerBase::IsFocusShown()
+    {
+    if( iTouchPressed || iFocusVisible ) 
+        {
+        return ETrue;
+        }
+    return EFalse;
+    }
+
+
+// </cmail>