/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#include <aknsinglecolumnstyletreelist.h>

#include <AknsDrawUtils.h>

#include <AknUtils.h>

#include <avkon.mbg>

#include <barsread.h>

#include <swtlaffacade.h>

#include "eswtmobileextensions.h"

#include "swtfont.h"

#include "swttree.h"

#include "swtcontrolhelper.h"

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

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

CSwtTree* CSwtTree::NewL(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                         MSwtComposite& aParent, TInt aStyle)

{

    CCoeControl& parentCtrl = aParent.Control()->CoeControl();

    CSwtTree* self = new(ELeave) CSwtTree(aDisplay, aPeer, aParent, aStyle,

                                          parentCtrl.IsVisible(), parentCtrl.IsDimmed());

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

CSwtTree::CSwtTree(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                   MSwtComposite& aParent, TInt aStyle, TBool aVisibility, TBool aDimmed)

        : CSwtComposite(aDisplay, aPeer, &aParent, aStyle, aVisibility, aDimmed)

        , iItemHeightValid(EFalse)

{

}

void CSwtTree::ConstructL()

{

    CCoeControl& coeParent = iParent->Control()->CoeControl();

    SetContainerWindowL(coeParent);

    SetComponentsToInheritVisibility(ETrue);

    CCoeControl::MakeVisible(coeParent.IsVisible());

    CCoeControl::SetDimmed(coeParent.IsDimmed());

    iTree = CAknSingleColumnStyleTreeList::NewL(*this);

    TInt flags = KAknTreeListMarqueeScrolling;

    if (IsMarkable())

    {

        flags |= KAknTreeListMarkable;

    }

    iTree->SetFlags(flags);

    iTree->AddObserverL(this);

    // Eventhough container already given, we still need to do this for the skin background

    iTree->SetContainerWindowL(*this);

    // Give initial LAF value

    UpdateItemHeight();

    ActivateL();

    TDisplayMode displayMode(ENone);

    CEikonEnv* eikonEnv = iDisplay.CoeEnv();

    if (eikonEnv)

    {

        CWsScreenDevice* screenDevice = eikonEnv->ScreenDevice();

        if (screenDevice)

        {

            displayMode = screenDevice->DisplayMode();

        }

    }

    iMaskHandler = new CSwtMaskHandler(displayMode);

}

CSwtTree::~CSwtTree()

{

    delete iTree;

    iItems.Close();

    delete iMaskHandler;

    TInt count = iImages.Count();

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

    {

        TSize imageSize = iImages[i]->Bitmap().SizeInPixels();

        if (imageSize.iHeight > iImageMaxSize.iHeight ||

                imageSize.iWidth > iImageMaxSize.iWidth)

        {

            // If image size is bigger than the old maximum size, then

            // the image has been also previously scaled.

            imageSize = SwtControlHelper::GetAspectRatioScaledBitmapSize(

                            imageSize, iImageMaxSize);

        }

        iImages[i]->RemoveSubRef(imageSize);

        iImages[i]->RemoveRef();

    }

    iImages.Close();

    iImageIds.Close();

    iImageRefs.Close();

}

TInt CSwtTree::CountComponentControls() const

{

    return 1;

}

CCoeControl* CSwtTree::ComponentControl(TInt /*aIdx*/) const

{

    return iTree;

}

void CSwtTree::HandleResourceChange(TInt aType)

{

    if (aType == KEikDynamicLayoutVariantSwitch)

    {

        iItemHeightValid = EFalse;

        UpdateItemHeight();

    }

    CAknControl::HandleResourceChange(aType);

    UpdateImagesSize();

}

TKeyResponse CSwtTree::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

{

    TBool traversalDoIt = ETrue;

    if (iItems.Count() > 0)

    {

        switch (aKeyEvent.iCode)

        {

        case EKeyEnter:

        case EKeyOK:

        {

            if (IsMarkable())

            {

                traversalDoIt = EFalse;

            }

            break;

        }

        case EKeyUpArrow:

        {

            traversalDoIt = EFalse;

            if (iTree->FocusedItem() == iItems[0])

            {

                if (GetShell().FindTraversalTargetL(ESwtTraverseArrowPrevious, *this))

                {

                    traversalDoIt = ETrue;

                }

            }

            break;

        }

        case EKeyDownArrow:

        {

            traversalDoIt = EFalse;

            if (iTree->FocusedItem() == LastCollapsedItem())

            {

                if (GetShell().FindTraversalTargetL(ESwtTraverseArrowNext, *this))

                {

                    traversalDoIt = ETrue;

                }

            }

            break;

        }

        case EKeyLeftArrow:

        {

            // Left key collapses node

            TInt item = iTree->FocusedItem();

            if (item != KAknTreeIIDNone)

            {

                traversalDoIt = EFalse;

                if (iTree->Parent(item) == KAknTreeIIDRoot && !iTree->IsExpanded(item))

                {

                    if (GetShell().FindTraversalTargetL(ESwtTraverseArrowPrevious, *this))

                    {

                        traversalDoIt = ETrue;

                    }

                }

            }

            break;

        }

        case EKeyRightArrow:

        {

            // Right key expands node

            TInt item = iTree->FocusedItem();

            if (item != KAknTreeIIDNone)

            {

                traversalDoIt = EFalse;

                if (iTree->ChildCount(item) == 0)

                {

                    if (GetShell().FindTraversalTargetL(ESwtTraverseArrowNext, *this))

                    {

                        traversalDoIt = ETrue;

                    }

                }

            }

            break;

        }

        default:

            break;

        }

    }

    return HandleKeyL(aKeyEvent, aType, traversalDoIt);

}

void CSwtTree::SizeChanged()

{

    if (iTree)

    {

        iTree->SetRect(BorderInnerRect());

    }

    CSwtComposite::SizeChanged();

}

void CSwtTree::PositionChanged()

{

    if (iTree)

    {

        iTree->SetRect(BorderInnerRect());

    }

    CSwtComposite::PositionChanged();

}

void CSwtTree::FocusChanged(TDrawNow aDrawNow)

{

    // This gets called before contained list is created.

    if (iTree)

    {

        TBool isFocused = IsFocusControl();

        iTree->SetFocus(isFocused, aDrawNow);

        if (isFocused)

        {

            UpdateItemHeight();

        }

    }

    HandleFocusChanged(aDrawNow);

}

CCoeControl& CSwtTree::CoeControl()

{

    return *this;

}

const CCoeControl& CSwtTree::CoeControl() const

{

    return *this;

}

// Needed for finding the skin background

TTypeUid::Ptr CSwtTree::MopSupplyObject(TTypeUid aId)

{

    TTypeUid::Ptr id = ASwtControlBase::SwtMopSupplyObject(aId);

    if (id.Pointer() == NULL)

    {

        return CAknControl::MopSupplyObject(aId);

    }

    else

    {

        return id;

    }

}

TBool CSwtTree::IsFocusable(TInt aReason /*=KSwtFocusByApi*/) const

{

    // Bypass CSwtComposite's focusability behavior.

    return ASwtScrollableBase::IsFocusable(aReason);

}

TInt CSwtTree::FocusBackgroundPolicy() const

{

    // Bypass CSwtComposite's focus background.

    return ASwtControlBase::FocusBackgroundPolicy();

};

void CSwtTree::ProcessKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

{

    ASSERT(iTree);

    iTree->OfferKeyEventL(aKeyEvent, aType);

}

TBool CSwtTree::IsKeyUsed(TUint aKeyCode) const

{

    if (aKeyCode == EKeyBackspace)

    {

        return EFalse;

    }

    else if (aKeyCode == EKeyOK || aKeyCode == EKeyEnter)

    {

        if (!IsMarkable())

        {

            MSwtCommandArranger* commandArranger = iDisplay.CommandArranger();

            if (commandArranger)

            {

                if (commandArranger->IsContextSensitiveOperationSet())

                {

                    return EFalse;

                }

            }

            return ETrue;

        }

        else

        {

            return ETrue;

        }

    }

    else

    {

        return ETrue;

    }

}

TSize CSwtTree::ComputeSizeL(TInt aWHint, TInt aHHint)

{

    if (!iTree)

    {

        return TSize(0, 0);

    }

    TSize res(aWHint, aHHint);

    TInt count = iTree->ChildCount(KAknTreeIIDRoot);

    if (aWHint == KSwtDefault)

    {

        TRect mainRect(TRect::EUninitialized);

        AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainRect);

        TAknLayoutRect layoutRect = ItemLayoutRect();

        TRect rect = layoutRect.Rect();

        TInt vPadding = mainRect.Height() - rect.Height();

        TInt scrollBarAndTrimWidth = Max(0, mainRect.Width() - rect.Width());

        TAknLayoutText txtLayoutRect = CSwtLafFacade::GetLayoutText(CSwtLafFacade::EListSingle2HeadingMsgPaneT1,

                                       rect, IsMarkable() ? 3 : 2);

        TInt txtRightPadding = Max(0, rect.iBr.iX - txtLayoutRect.TextRect().iBr.iX);

        TInt txtLeftPadding = Max(0, txtLayoutRect.TextRect().iTl.iX);

        TInt markIconWidth(0);

        if (IsMarkable())

        {

            markIconWidth = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::EListSingle2HeadingMsgPaneG2,

                            txtLayoutRect.TextRect(), 1).Rect().Width();

        }

        res.iWidth = 0;

        const CFont* font = txtLayoutRect.Font();

        if (font)

        {

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

            {

                res.iWidth = Max(res.iWidth, font->TextWidthInPixels(iTree->Text(iTree->Child(KAknTreeIIDRoot, i))));

            }

        }

        res.iWidth += txtLeftPadding;

        res.iWidth += txtRightPadding;

        res.iWidth += scrollBarAndTrimWidth;

        res.iWidth += markIconWidth;

        res.iWidth += GetBorderWidth() * 2;

    }

    if (aHHint == KSwtDefault)

    {

        if (count == 0)

        {

            count = 1; // empty tree

        }

        res.iHeight = count * ItemHeight();

        res.iHeight += GetBorderWidth() * 2;

    }

    return res;

}

void CSwtTree::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    //Native control used for tree doesn't have flag for MULTI, so

    //given feedback is normal list feedback.

    //When tree is MULTI, we should give checkbox feedback on touch down.

    //So first we disable feedback for native side and do our

    //checkbox feedback. Then feedback for native side is restored.

    MTouchFeedback* feedback = NULL;

    if (aPointerEvent.iType == TPointerEvent::EButton1Up)

    {

        TUint32 flags = iTree->Flags();

        if ((flags & KAknTreeListMarkable) &&

                iTree->IsLeaf(iTree->FocusedItem()))

        {

            feedback = MTouchFeedback::Instance();

            if (feedback)

            {

                feedback->EnableFeedbackForControl(iTree, EFalse);

                feedback->InstantFeedback(ETouchFeedbackCheckbox);

            }

        }

    }

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    iLastFocusedItem = iTree->FocusedItem();

    CSwtComposite::HandlePointerEventL(aPointerEvent);

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    if (feedback)

    {

        //Restore native feedback.

        feedback->EnableFeedbackForControl(iTree, ETrue);

    }

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

}

MSwtComposite* CSwtTree::Composite()

{

    return this;

}

TInt CSwtTree::AddL(TInt aItemHandle)

{

    ASSERT(iTree);

    TInt flags = CAknSingleColumnStyleTreeList::EPersistent;

    if (aItemHandle < KAknTreeIIDRoot)

    {

        aItemHandle = KAknTreeIIDRoot;

    }

    TInt id = iTree->AddSubtitleRowL(aItemHandle, KNullDesC, flags, ETrue);

    // Ids of the children items are inserted after the id of the parent.

    // This is to facilitate 'insert with sort' mechanism.

    TBool parentFound = EFalse;

    if (aItemHandle != KAknTreeIIDRoot)

    {

        TInt index = iItems.Find(aItemHandle);

        if (index != KErrNotFound)

        {

            // Always at least +1 since item already added

            index += iTree->ChildCount(aItemHandle);

            User::LeaveIfError(iItems.Insert(id, index));

            parentFound = ETrue;

        }

    }

    if (!parentFound)

    {

        User::LeaveIfError(iItems.Append(id));

    }

    return id;

}

TRect CSwtTree::Bounds(TInt aItemHandle) const

{

    ASSERT(iTree);

    TRect rect(0, 0, 0, 0);

    TInt posInScreen = iTree->VisibleItemIndex(aItemHandle);

    if (posInScreen >= 0)

    {

        TInt itemHeight = ItemHeight();

        rect.iTl.iY = itemHeight * posInScreen;

        rect.SetWidth(iTree->Rect().Width());

        rect.SetHeight(itemHeight);

    }

    return rect;

}

void CSwtTree::Check(TInt aItemHandle, TBool aState)

{

    ASSERT(iTree);

    iTree->SetMarked(aItemHandle, aState, ETrue);

}

void CSwtTree::Collapse(TInt aItemHandle)

{

    ASSERT(iTree);

    if (iTree->ChildCount(aItemHandle) > 0)

    {

        iTree->CollapseNode(aItemHandle, ETrue);

    }

}

void CSwtTree::Expand(TInt aItemHandle)

{

    ASSERT(iTree);

    if (iTree->ChildCount(aItemHandle) > 0)

    {

        iTree->ExpandNode(aItemHandle, ETrue);

    }

}

TInt CSwtTree::InsertL(TInt aItemHandle, TInt aIndex)

{

    ASSERT(iTree);

    TInt flags = CAknSingleColumnStyleTreeList::EPersistent;

    if (aItemHandle < KAknTreeIIDRoot)

    {

        aItemHandle = KAknTreeIIDRoot;

    }

    TInt id = iTree->AddSubtitleRowL(aItemHandle, KNullDesC, flags, EFalse);

    // Insert id in the list ordered item id array

    if (KAknTreeIIDRoot == aItemHandle)

    {

        // Root item ids are inserted before the id position of aIndex sibbling

        TInt sibbling = iTree->Child(KAknTreeIIDRoot, aIndex);

        TInt index = iItems.Find(sibbling);

        if (index != KErrNotFound)

        {

            // Insert at sibbling's position

            ASSERT(index <= iItems.Count());

            User::LeaveIfError(iItems.Insert(id, index));

            iTree->Sort(this, ETrue);

        }

        else

        {

            // Insertion failure, just append the item id and pray

            User::LeaveIfError(iItems.Append(id));

        }