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

 * 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 <aknappui.h>

#include <aknenv.h>

#include <AknUtils.h>

#include <eikenv.h>

#include <eiksbfrm.h>

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <AknsFrameBackgroundControlContext.h>

#include <centralrepository.h>

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#include <swtlaffacade.h>

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#include "swtcomposite.h"

#include "swtscrollbar.h"

#include "swtuiutils.h"

#include "swtshell.h"

const TInt CSwtComposite::KChildrenGranularity = 5;

const TInt KMaxScrollBarCount = 2;

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

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

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

        : ASwtScrollableBase(aDisplay, aPeer, aParent, aStyle)

{

    CAknControl::MakeVisible(aVisibility);

    SetComponentsToInheritVisibility(ETrue);

    CAknControl::SetDimmed(aDimmed);

    SetFocusing(ETrue);

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    iFeedback = MTouchFeedback::Instance();

    UpdateTactileFeedbackDensity();

#endif // RD_JAVA_ADVANCED_TACTILE_FEEDBACK

}

CSwtComposite::~CSwtComposite()

{

    ASSERT(iChildren.Count() == 0);

    if (iPhysics)

    {

        delete iPhysics;

        iPhysics = NULL;

    }

    if (iPhysicsTimer)

    {

        iPhysicsTimer->Cancel();

    }

    delete iPhysicsTimer;

    iPhysicsTimer = NULL;

    iScrlCompContent = NULL;

    if (iPhysicsLib.Handle())

    {

        iPhysicsLib.Close();

    }

    iTabList.Close();

    iChildren.Close();

    delete iSbFrame;

}

void CSwtComposite::ConstructL()

{

    if (!IsShell())

    {

        ASSERT(iParent!=NULL);

        SetContainerWindowL(iParent->Control()->CoeControl());

    }

    CreateScrollBarFrameL();

    SetBackground(this); // Back will be drawn by ASwtControlBase::Draw

    EnableDragEvents();

    ActivateL();

}

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

                                   MSwtComposite& aParent, TInt aStyle)

{

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

    CSwtComposite* self = new(ELeave) CSwtComposite(aDisplay, aPeer,

            &aParent, aStyle, parentCtrl.IsVisible(), parentCtrl.IsDimmed());

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

// From class MCoeControlBackground.

// Draw the Background. This method was called by the eSWT and Symbian

// drawing framework.

void CSwtComposite::Draw(CWindowGc& aGc, const CCoeControl& aControl,

                         const TRect& aRect) const

{

    if (!(iStyle & KSwtStyleNoBackground))

    {

        ASwtControlBase::Draw(aGc, aControl, aRect);

    }

}

void CSwtComposite::CreateScrollBarFrameL()

{

    ASSERT(iSbFrame==NULL);

    if (iStyle & (KSwtStyleHScroll | KSwtStyleVScroll))

    {

        iSbFrame = new(ELeave) CEikScrollBarFrame(this, this, ETrue);

#ifdef RD_SCALABLE_UI_V2

        // WARNING!!! The expanded touch area does not move correctly togehter with the scrollbars!

        iSbFrame->SetScrollBarFrameFlags(CEikScrollBarFrame::EDisableExpandedTouchArea);

#endif // RD_SCALABLE_UI_V2

        if (AknLayoutUtils::DefaultScrollBarType(iAvkonAppUi) == CEikScrollBarFrame::EDoubleSpan)

        {

            // Vertical scrollbar always needs to be created.

            iSbFrame->CreateDoubleSpanScrollBarsL(EFalse, EFalse, ETrue, iStyle & KSwtStyleHScroll);

        }

        CEikScrollBarFrame::TScrollBarVisibility horizVis = (iStyle & KSwtStyleHScroll) ?

                CEikScrollBarFrame::EOn : CEikScrollBarFrame::EOff;

        CEikScrollBarFrame::TScrollBarVisibility vertVis  = (iStyle & KSwtStyleVScroll) ?

                CEikScrollBarFrame::EOn : CEikScrollBarFrame::EOff;

        iSbFrame->SetScrollBarVisibilityL(horizVis, vertVis);

        TEikScrollBarModel vEmptyModel(0,0,0);

        TEikScrollBarModel hEmptyModel(0,0,0);

        TEikScrollBarFrameLayout layout;

        layout.iTilingMode = TEikScrollBarFrameLayout::EInclusiveRectConstant;

        layout.SetClientMargin(0);

        layout.SetInclusiveMargin(0);

        TRect inclusiveRect(BorderInnerRect());

        TRect clientRect(SbInnerRect(inclusiveRect));

        iSbFrame->DrawBackground(EFalse,EFalse);

        // Cannot use non double span models for double span scrollbars! Avoiding panics.

        if (iSbFrame->TypeOfVScrollBar() == CEikScrollBarFrame::EDoubleSpan)

        {

            TAknDoubleSpanScrollBarModel hDsSbarModel(hEmptyModel);

            TAknDoubleSpanScrollBarModel vDsSbarModel(vEmptyModel);

            iSbFrame->TileL(&hDsSbarModel, &vDsSbarModel, clientRect, inclusiveRect, layout);

        }

        else

        {

            iSbFrame->TileL(&hEmptyModel, &vEmptyModel, clientRect, inclusiveRect, layout);

        }

    }

}

void CSwtComposite::UpdateFrameL()

{

    if (iSbFrame == NULL)

        return;

    TEikScrollBarModel hModel;

    CEikScrollBar* hsb = iSbFrame->GetScrollBarHandle(CEikScrollBar::EHorizontal);

    if (hsb)

        hModel = *hsb->Model();

    TEikScrollBarModel vModel;

    CEikScrollBar* vsb = iSbFrame->GetScrollBarHandle(CEikScrollBar::EVertical);

    if (vsb)

        vModel = *vsb->Model();

    TEikScrollBarFrameLayout layout;

    layout.iTilingMode = TEikScrollBarFrameLayout::EInclusiveRectConstant;

    layout.SetClientMargin(0);

    layout.SetInclusiveMargin(0);

    TRect inclusiveRect(BorderInnerRect());

    TRect clientRect(SbInnerRect(inclusiveRect));

    InvalidateScrollBars();

    // Cannot use non double span models for double span scrollbars! Avoiding panics.

    if (iSbFrame->TypeOfVScrollBar() == CEikScrollBarFrame::EDoubleSpan)

    {

        TAknDoubleSpanScrollBarModel hDsSbarModel(hModel);

        TAknDoubleSpanScrollBarModel vDsSbarModel(vModel);

        iSbFrame->TileL(&hDsSbarModel, &vDsSbarModel, clientRect, inclusiveRect, layout);

    }

    else

    {

        iSbFrame->TileL(&hModel, &vModel, clientRect, inclusiveRect, layout);

    }

}

// This is needed only due to problems with the base class implementation of

// updating the scrollbars. Without doing this the scrollbars won't get

// correctly updated when the control is moved around.

void CSwtComposite::InvalidateScrollBars()

{

    if (iSbFrame)

    {

        CEikScrollBar* vBar = iSbFrame->GetScrollBarHandle(CEikScrollBar::EVertical);

        CEikScrollBar* hBar = iSbFrame->GetScrollBarHandle(CEikScrollBar::EHorizontal);

        if (vBar)

        {

            vBar->SetExtent(TPoint(0, 0), TSize(0, 0));

        }

        if (hBar)

        {

            hBar->SetExtent(TPoint(0, 0), TSize(0, 0));

        }

    }

}

void CSwtComposite::RectChanged()

{

    const TRect oldRect(iRect);

    const TRect newRect(Rect());

    if (newRect == oldRect)

        return;

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    // Reset last kinetic scrolling tactile feedback position

    iLastTactileFeedbackPos = 0;

#endif

    // Take care of scroll-bars

    TRAP_IGNORE(UpdateFrameL());

    // Forward new position to children

    if (newRect.iTl != oldRect.iTl)

    {

        if (!OwnsWindow())

        {

            const TPoint delta(newRect.iTl - oldRect.iTl);

            const TInt childCount = iChildren.Count();

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

            {

                MSwtControl* child = iChildren[i];

                if (!child->IsShell())

                {

                    CCoeControl& coeChild = child->CoeControl();

                    TPoint pos(coeChild.Position());

                    pos += delta;

                    coeChild.SetPosition(pos);

                }

            }

        }

    }

    iRect = newRect;

}

TInt CSwtComposite::CountComponentControls() const

{

    TInt result = 0;

    // Scroll-bar frame's components

    if (iSbFrame != NULL)

        result += iSbFrame->CountComponentControls();

    return result;

}

CCoeControl* CSwtComposite::ComponentControl(TInt aIndex) const

{

    // Scroll-bar frame's components

    if (iSbFrame != NULL)

    {

        const TInt count = iSbFrame->CountComponentControls();

        if (aIndex < count)

            return iSbFrame->ComponentControl(aIndex);

        aIndex -= count;

    }

    ASSERT(EFalse);

    return NULL;

}

void CSwtComposite::MakeVisible(TBool aVisible)

{

    CAknControl::MakeVisible(aVisible); // Scrollbars are taken care of here

    // Children

    const TInt childCount = iChildren.Count();

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

    {

        MSwtControl& child = *iChildren[i];

        // This prevents making visible controls invisible on their own

        if (!(child.Flags() & MSwtControl::EFlagInvisible))

            child.CoeControl().MakeVisible(aVisible);

    }

    // Take care of scroll-bars

    TRAP_IGNORE(UpdateFrameL());

    if (!IsShell())

        FocusabilityChanged();

}

void CSwtComposite::SetDimmed(TBool aDimmed)

{

    CAknControl::SetDimmed(aDimmed);

    // Children

    const TInt childCount = iChildren.Count();

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

    {

        MSwtControl& child = *iChildren[i];

        // This prevents undimming controls dimmed on their own

        if (!(child.Flags() & MSwtControl::EFlagDisabled))

            child.CoeControl().SetDimmed(aDimmed);

    }

    // Scroll-bars

    if (iSbFrame != NULL)

    {

        CEikScrollBar* vsb = iSbFrame->GetScrollBarHandle(CEikScrollBar::EVertical);

        if (vsb)

        {

            vsb->SetDimmed(aDimmed);

        }

        CEikScrollBar* hsb = iSbFrame->GetScrollBarHandle(CEikScrollBar::EHorizontal);

        if (hsb)

        {

            hsb->SetDimmed(aDimmed);

        }

    }

    if (!IsShell())

        FocusabilityChanged();

}

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

{

    return HandleKeyL(aKeyEvent, aType, ETrue);

}

#ifdef RD_SCALABLE_UI_V2

// Physics pointer handling:

// - pointer down is stored for late pointer down deliver and higilight timer is started.

// - if the timer times out before drag or up events, the pointet control is focused.

// - drag events cancel the timer and the late pointer down delivery.

// - drag events also start the physics panning if the drag exceeds the panning treshold.

// - up events start the physics flicking if physics panning ongoing.

// - up events also perform the late pointer down delivery if physics not ongoing.

void CSwtComposite::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

    CEikScrollBar* vsb = iSbFrame ?

                         iSbFrame->GetScrollBarHandle(CEikScrollBar::EVertical) : NULL;

    CEikScrollBar* hsb = iSbFrame ?

                         iSbFrame->GetScrollBarHandle(CEikScrollBar::EHorizontal) : NULL;

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    iLastPointerEventType = aPointerEvent.iType;

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    // Check if we should start scrollbar grabbing

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

    {

        if (!iVScrollBarGrabsPointerEvents)

        {

            if (vsb && vsb->Rect().Contains(aPointerEvent.iPosition))

            {

                iVScrollBarGrabsPointerEvents = ETrue;

            }

        }

        if (!iHScrollBarGrabsPointerEvents)

        {

            if (hsb && hsb->Rect().Contains(aPointerEvent.iPosition))

            {

                iHScrollBarGrabsPointerEvents = ETrue;

            }

        }

    }

    if (iVScrollBarGrabsPointerEvents || iHScrollBarGrabsPointerEvents)

    {

        ProcessCompositePointerEventL(aPointerEvent);

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

        {

            iVScrollBarGrabsPointerEvents = EFalse;

            iHScrollBarGrabsPointerEvents = EFalse;

        }

    }

    else

    {

        TBool consumed(EFalse);

        if (iPhysics)

        {

            if (iPhysics->OngoingPhysicsAction() == MSwtPhysics::ESwtPhysicsActionBouncing)

            {

                GetShell().Control()->CoeControl().IgnoreEventsUntilNextPointerUp();

                return;

            }

            switch (aPointerEvent.iType)

            {

            case TPointerEvent::EButton1Down:

            {

                consumed = ETrue;

                iPhysicsBreaking = iPhysicsAction == KSwtPhysicsFlicking;

                iPhysics->StopPhysics(); // Now iPhysicsAction should be KSwtPhysicsNoAction

                iPhysicsAction = KSwtPhysicsGrabbing;

                iPhysicsStartPos = aPointerEvent.iPosition;

                iPhysicsPointerDown = aPointerEvent;

                iPhysicsFocusedCtrl = GetShell().FocusControl();

                PhysicsResetGeometryL();

                GetShell().SetUrgentPaintControl(this);

                // If pointer down occurs while flicking, cannot forward pointer anymore to controls.

                if (!iPhysicsBreaking)

                    PhysicsStartTimer();

                iPhysicsStartTime.HomeTime();

            }

            break;

            case TPointerEvent::EDrag:

            {

                // All drag events are used to do the physics.

                consumed = ETrue;

                if (iPhysicsAction == KSwtPhysicsPanning)

                {

                    iPhysics->RegisterPanningPosition(iPhysicsLastPos - aPointerEvent.iPosition);

                }

                else

                {

                    // Drag occurs before the physics timer timout.

                    // Check if it is long enough to start the physics.

                    TPoint drag(iPhysicsStartPos - aPointerEvent.iPosition);

                    if (Abs(drag.iX) > iPhysics->DragThreshold()

                            || Abs(drag.iY) > iPhysics->DragThreshold())

                    {

                        iPhysicsTimer->Cancel();

                        iPhysics->RegisterPanningPosition(drag);

                        iPhysicsAction = KSwtPhysicsPanning;

                        // Unfocus

                        MSwtControl* ctrl = GetShell().FocusControl();

                        {

                        }

                        // Revert

                        if (iPointerGrabbingControl)

                        {

                            TPointerEvent ev(iPhysicsPointerDown);

                            ev.iType = TPointerEvent::EButton1Up;

                            // This is safe for as long as there is no parallel pointer handling.

                            iDisplay.SetRevertPointerEvent(ETrue);

                            iPointerGrabbingControl->HandlePointerEventL(ev);

                            iDisplay.SetRevertPointerEvent(EFalse);

                        }

                    }

                }

            }

            break;

            case TPointerEvent::EButton1Up:

            {

                TBool timerWasActive = iPhysicsTimer->IsActive();

                if (timerWasActive)

                {

                    iPhysicsTimer->Cancel();

                }

                if (iPhysicsAction != KSwtPhysicsNoAction

                        && iPhysicsAction != KSwtPhysicsGrabbing)

                {

                    consumed = ETrue;

                    const TTime time(iPhysicsStartTime);

                    TPoint drag(iPhysicsStartPos - aPointerEvent.iPosition);

                    if (iPhysics->StartPhysics(drag, time))

                        iPhysicsAction = KSwtPhysicsFlicking;

                    else

                        iPhysicsAction = KSwtPhysicsNoAction;

                }

                else

                {

                    iPhysicsAction = KSwtPhysicsNoAction;

                    GetShell().SetUrgentPaintControl(NULL);

                    if (!iPhysicsBreaking && timerWasActive)

                    {

                        // Pointer up occurs before the physics timer timout.

                        // Deliver the delayed pointer down, then this up pointer event.

                        DoHandlePointerEventL(iPhysicsPointerDown);

                    }

                    consumed = iPhysicsBreaking;

                    iPhysicsBreaking = EFalse;

                }

            }

            break;

            default:

                break;

            }

            iPhysicsLastPos = aPointerEvent.iPosition;

        }

        if (!consumed)

        {

            DoHandlePointerEventL(aPointerEvent);

        }

    }

}