/*

* 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:  Implementation of class CFsTextViewerControl

*

*/

//<cmail> removed __FS_ALFRED_SUPPORT flag

//#include <fsconfig.h>

//</cmail> removed __FS_ALFRED_SUPPORT flag

// <cmail> SF

#include "emailtrace.h"

#include <alf/alfevent.h>

#include <alf/alfstatic.h>

#include <alf/alfenv.h>

// </cmail>

// <cmail> Needed for pointer events. "Base class modifications for using touch"

#include <alf/alfdisplay.h>

#include <alf/alfroster.h>

#include <aknphysics.h>

// </cmail>

#include "fstextviewercontrol.h"

#include "fstextviewervisualizer.h"

#include "fstextviewervisualizerdata.h"

#include "fstextviewerobserver.h"

#include "fstextviewerkeys.h"

// Dragging treshold in pixels, so the amount of pixels that the pointer

// poisition can move without indicating it as dragging

const TInt KDraggingTresholdInPixels = 20;

// To be removed after aknphysics is working

#define FS_VIEWER_DISABLE_AKN_PHYSICS

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

// NewL

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

CFsTextViewerControl* CFsTextViewerControl::NewL( CAlfEnv& aEnv )

    {

    FUNC_LOG;

    CFsTextViewerControl* self = new ( ELeave ) CFsTextViewerControl();

    CleanupStack::PushL( self );

    self->ConstructL(aEnv);

    CleanupStack::Pop( self );

    return self;

    }

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

// CFsTextViewerControl

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

CFsTextViewerControl::CFsTextViewerControl( )

    : CAlfControl(), 

      iCursorUDScroll( EFalse ),

      iScrollEventHandlingOngoing( EFalse ),

      iIsVisible( EFalse ),

      iStartHotspotAction( EFalse )

    {

    FUNC_LOG;

    }

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

// ConstructL

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

void CFsTextViewerControl::ConstructL(CAlfEnv& aEnv)

    {

    FUNC_LOG;

    CAlfControl::ConstructL(aEnv);

#ifndef FS_VIEWER_DISABLE_AKN_PHYSICS

    if ( CAknPhysics::FeatureEnabled() )

        {

        CCoeControl* ctrl = NULL;

        //ctrl = CCoeEnv::Static()->AppUi()->TopFocusedControl();

        iPhysics = CAknPhysics::NewL( *this, ctrl );

        }

#endif //FS_VIEWER_DISABLE_AKN_PHYSICS

    }

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

// ~CFsTextViewerControl

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

CFsTextViewerControl::~CFsTextViewerControl()

    {

    FUNC_LOG;

    delete iPhysics;

    iPhysics = NULL;

    }

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

// SetVisualizer

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

void CFsTextViewerControl::SetVisualizer( CFsTextViewerVisualizer* aVis )

    {

    FUNC_LOG;

    iVisualizer = aVis;

    }

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

// SetObserver

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

void CFsTextViewerControl::SetObserver( MFsTextViewerObserver* aObserver )

    {

    FUNC_LOG;

    iObserver = aObserver;

    }

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

// EnableCursorScroll

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

void CFsTextViewerControl::EnableCursorScroll( TBool aStatus )

    {

    FUNC_LOG;

    iCursorUDScroll = aStatus;

    }

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

// CursorScroll

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

TBool CFsTextViewerControl::CursorScroll()

    {

    FUNC_LOG;

    return iCursorUDScroll;

    }

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

// SetKeys

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

void CFsTextViewerControl::SetKeys( CFsTextViewerKeys* aKeys )

    {

    FUNC_LOG;

    iKeys = aKeys;

    }

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

// Keys

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

CFsTextViewerKeys* CFsTextViewerControl::Keys()

    {

    FUNC_LOG;

    return iKeys;

    }

TBool CFsTextViewerControl::IsScrollEventHandlingOngoing()

    {

    return iScrollEventHandlingOngoing;

    }

void CFsTextViewerControl::NotifyControlVisibility( TBool  aIsVisible, CAlfDisplay& aDisplay )

    {

    iVisualizer->NotifyControlVisibilityChange(aIsVisible);

    //Add & remove extra touch events. 

    if(aIsVisible && !iIsVisible)

        {

        TInt dragTreshold_X = KDraggingTresholdInPixels;

		// If AknPhysics used, get drag treshold from there

        if( iPhysics )

            {

            dragTreshold_X = iPhysics->DragThreshold();

            }

        // Currently only panning (vertical dragging) is implemented,

		// so horizontal drag treshold should be a bit bigger

        TInt dragTreshold_Y = dragTreshold_X * 2;

        // Add observer for long tap and drag events, set treshold for drag

        // events and disable long tap events while dragging

        aDisplay.Roster().AddPointerEventObserver( EAlfPointerEventReportLongTap, *this );        

        aDisplay.Roster().AddPointerEventObserver( EAlfPointerEventReportDrag, *this );

        aDisplay.Roster().SetPointerDragThreshold(

                *this, TAlfXYMetric( TAlfMetric(dragTreshold_X), TAlfMetric(dragTreshold_Y) ) );

        aDisplay.Roster().DisableLongTapEventsWhenDragging( *this );

        iIsVisible = ETrue;

        }

    else if(!aIsVisible && iIsVisible )

        {

        if( iPhysics )

            {

            iPhysics->StopPhysics();

            iPhysics->ResetFriction();

            }

        aDisplay.Roster().RemovePointerEventObserver(EAlfPointerEventReportLongTap, *this);

        aDisplay.Roster().RemovePointerEventObserver(EAlfPointerEventReportDrag, *this);

        iIsVisible = EFalse;

        }

    }

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

// OfferEventL

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

TBool CFsTextViewerControl::OfferEventL(const TAlfEvent& aEvent)

    {

    FUNC_LOG;

    TBool retVal = EFalse;

    if ( aEvent.IsPointerEvent() )

        {

        retVal = HandlePointerEventL( aEvent );

        }

    else if( aEvent.IsKeyEvent() && aEvent.Code() == EEventKey )

        {

        retVal = HandleKeyEventL( aEvent );

        }

    return retVal;

    }

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

// CFsTextViewerControl::HandleKeyEventL

// Handle keyboard events

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

//

TBool CFsTextViewerControl::HandleKeyEventL(const TAlfEvent& aEvent)

    {

    TBool eventHandled( EFalse );

    if( iPhysics )

        {

        iPhysics->StopPhysics();

        iPhysics->ResetFriction();

        }

    if ( aEvent.KeyEvent().iCode == iKeys->GetKeyUp() )

        {

        TBool hotspotChanged = EFalse;

        if ( iCursorUDScroll )

            {

            iVisualizer->MoveUpL();

            }

        else

            {

            if ( iVisualizer->PrevVisibleHotspotL( hotspotChanged ) )

                {

                if ( iObserver && hotspotChanged )

                    {

                    iObserver->HandleTextViewerEventL(

                            MFsTextViewerObserver::EFsTextViewerHotspotChanged );

                    }

                }

            else 

                {

                ScrollL( MFsTextViewerObserver::EFsTextViewerScrollUp );

                }

            }

        eventHandled = ETrue;

        }

    else if ( aEvent.KeyEvent().iCode == iKeys->GetKeyDown() )

        {

        TBool hotspotChanged = EFalse;

        if ( iCursorUDScroll )

            {

            iVisualizer->MoveDownL();

            }

        else

            {

            if ( iVisualizer->NextVisibleHotspotL( hotspotChanged ) )

                {

                if ( iObserver && hotspotChanged )

                    {

                    iObserver->HandleTextViewerEventL(

                            MFsTextViewerObserver::EFsTextViewerHotspotChanged );

                    }

                }

            else 

                {

                ScrollL( MFsTextViewerObserver::EFsTextViewerScrollDown );

                }

            }

        eventHandled = ETrue;

        }

    else if ( aEvent.KeyEvent().iCode == iKeys->GetKeyPgUp() )

        {

        iVisualizer->PageUpL();

        }

    else if ( aEvent.KeyEvent().iCode == iKeys->GetKeyPgDown() )

        {

        iVisualizer->PageDownL();

        }

    else if ( aEvent.KeyEvent().iCode == iKeys->GetKeyRight() )

        {

        iVisualizer->MoveRightL();

        if ( iVisualizer->MarkEnabled() && iObserver )

            {

            iObserver->HandleTextViewerEventL( 

                MFsTextViewerObserver::EFsTextViewerMarkChange );

            }

        eventHandled = ETrue;

        }

    else if ( aEvent.KeyEvent().iCode == iKeys->GetKeyLeft() )

        {

        iVisualizer->MoveLeftL();

        if ( iVisualizer->MarkEnabled() && iObserver )

            {

            iObserver->HandleTextViewerEventL( 

                MFsTextViewerObserver::EFsTextViewerMarkChange );

            }

        eventHandled = ETrue;

        }

    else if ( aEvent.KeyEvent().iCode == iKeys->GetKeyMark() )

        {

        iVisualizer->SwitchMarkL();

        if ( iVisualizer->MarkEnabled() && iObserver )

            {

            iObserver->HandleTextViewerEventL(

                MFsTextViewerObserver::EFsTextViewerMarkStart );

            }

        else if ( iObserver ) 

            {

            iObserver->HandleTextViewerEventL( 

                MFsTextViewerObserver::EFsTextViewerMarkEnd );

            }

        eventHandled = ETrue;

        }

    else if ( aEvent.KeyEvent().iCode == iKeys->GetKeyClick() )

        {

        iVisualizer->ClickedL();

        if ( iVisualizer->IsHotspotHighlighted() && iObserver )

            {

            iObserver->HandleTextViewerEventL( 

                MFsTextViewerObserver::EFsTextViewerHotspotClicked );

            }

        eventHandled = ETrue;

        }

    else if ( aEvent.KeyEvent().iCode == iKeys->GetKeyScrollUp() )

        {

        ScrollL( MFsTextViewerObserver::EFsTextViewerScrollUp );

        eventHandled = ETrue;

        }

    else if ( aEvent.KeyEvent().iCode == iKeys->GetKeyScrollDown() )

        {

        ScrollL( MFsTextViewerObserver::EFsTextViewerScrollDown );

        eventHandled = ETrue;

        }

    return eventHandled;

    }

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

// CFsTextViewerControl::HandlePointerEventL

// Handle pointer (touch) events

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

//

TBool CFsTextViewerControl::HandlePointerEventL(const TAlfEvent& aEvent)

    {

    TBool eventHandled( EFalse );

    // Check if this event is bound to some of our visuals

    CAlfVisual* selectedVis = aEvent.Visual();

    TFsRangedVisual* rangedVis = NULL;

    if( selectedVis )

        {

        rangedVis = iVisualizer->Navigator()->GetRangedVisual( selectedVis );

        }

    switch ( aEvent.PointerEvent().iType )

        {

        case TPointerEvent::EButton1Down:

            {

            // Save current and original position so that those can be used in

            // drag/scrolling calculations

            iPreviousPosition = iOriginalPosition = aEvent.PointerEvent().iParentPosition;

            iIsDragging = EFalse;

            iIsFlicking = EFalse;

            if( iPhysics )

                {

                iPhysics->StopPhysics();

                iPhysics->ResetFriction();

                iStartTime.HomeTime();

                UpdatePhysicsL();

                }

            // On button down event, move focus to highlighted hotspot

            if( rangedVis && rangedVis->iHotspot )

                {

                // Allow future hotspot actions

                iStartHotspotAction = ETrue;

                // Move focus to currently pointed hotspot and report event

                // to observers

                iVisualizer->SetCurrentHotspotByCharL( rangedVis->iStart );

                if ( iObserver )

                    {

                    iObserver->HandleTextViewerEventL( MFsTextViewerObserver::EFsTextViewerHotspotChanged );

                    }

                eventHandled = ETrue;

                }

            }

            break;

        case TPointerEvent::EButton1Up:

            {

            if( iIsDragging && iPhysics )

                {

                TPoint drag(iOriginalPosition - aEvent.PointerEvent().iParentPosition);

                iPhysics->StartPhysics(drag, iStartTime);

                iIsFlicking = ETrue;

                }

            // On button up event start action for focused hotspot, if hotspot

            // action allowed

            else if( iStartHotspotAction && rangedVis && rangedVis->iHotspot )

                {

                // Hotspot action started, so disable all future actions

                iStartHotspotAction = EFalse;

                // Move focus to currently pointed hotspot and report event

                // to observers

                iVisualizer->SetCurrentHotspotByCharL( rangedVis->iStart );

                if ( iObserver )

                    {

                    iObserver->HandleTextViewerEventL( MFsTextViewerObserver::EFsTextViewerHotspotClicked );

                    }

                eventHandled = ETrue;

                }

            }

            break;

        case TPointerEvent::EButtonRepeat:

            {

            // On repeat event report long tap event to observers, if hotspot

            // actions are allowed

            if( iStartHotspotAction )

                {

                // Hotspot action started, so disable all future actions

                iStartHotspotAction = EFalse;

                // Report long tap event to observers

                if ( iObserver )

                    {

                    iObserver->HandleTextViewerEventL( MFsTextViewerObserver::EFsTextViewerHotspotLongTap );

                    }

                eventHandled = ETrue;

                }

            break;

            }

        case TPointerEvent::EDrag:

            {

            // Get current pointer position

            TPoint position = aEvent.PointerEvent().iParentPosition;

            // If user started dragging, cancel hotspot actions

            iStartHotspotAction = EFalse;

            iIsDragging = ETrue;

            if( iPhysics )

                {

                TPoint delta( 0, iPreviousPosition.iY - position.iY );

                iPhysics->RegisterPanningPosition( delta );

                }

            else

                {

                // Calculate new scroll offset based on current and previous Y-positions

                TInt scrollOffset = iVisualizer->GetViewTopPosition() + ( iPreviousPosition.iY - position.iY );

                // Ensure that thumb position is in correct range

                scrollOffset = Max( scrollOffset, 0 );

                scrollOffset = Min( scrollOffset, iVisualizer->GetTotalHeight() - iVisualizer->iContentSize.iHeight );

                ScrollL( scrollOffset );

                }

            // Save current position as previous pos for future calculations

            iPreviousPosition = position;

            eventHandled = ETrue;

            }

            break;

        default:

            {

            // Unknown event, ignore.

            }

            break;

        }

    return eventHandled;

    }

// <cmail> Change scrollbar to avkon (to support skinning & touch)

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

//  Handle scrollbar events

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

//

void CFsTextViewerControl::HandleScrollEventL(CEikScrollBar* aScrollBar, TEikScrollEvent aEventType)

    {

    iScrollEventHandlingOngoing = ETrue;

    if( iPhysics )

        {

        iPhysics->StopPhysics();

        iPhysics->ResetFriction();

        }

    if ( aScrollBar == iVisualizer->GetScrollBar() )

        {

        TInt thumbPos = -1;

        switch( aEventType )

            {

            case EEikScrollHome :

                {

                //Jump to beginning

                thumbPos = 0;

                }

                break;

            case EEikScrollEnd :

                {