/*

* Copyright (c) 2009 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:  List pane component for UI fields

*

*/

#include "cmrlistpane.h"

#include "mesmrfieldstorage.h"

#include "mmrscrollbarobserver.h"

#include "esmrdef.h"

#include "cesmrfield.h"

#include "cmrfieldcontainer.h"

#include "cmrlistpanephysics.h"

#include "nmrlayoutmanager.h"

#include <eikscrlb.h>

#include <AknUtils.h>

#include <touchfeedback.h>

//DEBUG

#include "emailtrace.h"

namespace { // codescanner::namespace

const TInt KLongTapDelay( 700000 ); // 0,7 sec

const TInt KLongTapAnimationDelay( 300000 ); // 0,3 sec

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

// IndexByFieldId

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

//

TInt IndexByFieldId( const MESMRFieldStorage& aFactory,

                     TESMREntryFieldId aFieldId )

    {

    TInt index( KErrNotFound );

    TInt count( aFactory.Count() );

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

        {

        if ( aFactory.Field( i )->FieldId() == aFieldId )

            {

            index = i;

            break;

            }

        }

    return index;

    }

}

//----- MEMBER FUNCTIONS ----

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

// CMRListPane::CMRListPane

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

//

CMRListPane::CMRListPane( MESMRFieldStorage& aFactory,

                          TAknDoubleSpanScrollBarModel& aScrollModel,

                          CAknDoubleSpanScrollBar& aScroll,

                          MMRScrollBarObserver& aScrollBarObserver )

    : iFactory( aFactory ),

      iScrollModel( aScrollModel ),

      iScroll( aScroll ),

      iScrollBarObserver( aScrollBarObserver )

    {

    FUNC_LOG;

    }

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

// CMRListPane::~CMRListPane

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

//

CMRListPane::~CMRListPane()

    {

    FUNC_LOG;

    delete iLongtapDetector;

    delete iPhysics;

    delete iFieldContainer;

    }

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

// CMRListPane::NewL

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

//

CMRListPane* CMRListPane::NewL( const CCoeControl& aParent,

                                MESMRFieldStorage& aFactory,

                                TAknDoubleSpanScrollBarModel& aScrollModel,

                                CAknDoubleSpanScrollBar& aScroll,

                                MMRScrollBarObserver& aScrollBarObserver )

    {

    FUNC_LOG;

    CMRListPane* self = new( ELeave )CMRListPane(

            aFactory,

            aScrollModel,

            aScroll,

            aScrollBarObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aParent );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMRListPane::ConstructL

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

//

void CMRListPane::ConstructL( const CCoeControl& aParent )

    {

    FUNC_LOG;

    CCoeControl::SetComponentsToInheritVisibility( ETrue );

    SetContainerWindowL( aParent );

    iLongtapDetector = CAknLongTapDetector::NewL( this );

    iLongtapDetector->SetLongTapDelay( KLongTapDelay );

    iLongtapDetector->SetTimeDelayBeforeAnimation( KLongTapAnimationDelay );

    iFieldContainer = CMRFieldContainer::NewL( iFactory, *this );

    iFieldContainer->SetFieldContainerObserver( this );

    // Physics: Create physics

    // Give pointer to control that should be able to flick/drag

    iPhysics = CMRListPanePhysics::NewL( *this, *iFieldContainer, *this );

    }

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

// CMRListPane::InitializeL()

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

//

void CMRListPane::InitializeL()

    {

    FUNC_LOG;

    const TInt count( iFactory.Count() );

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

        {

        iFactory.Field(i)->InitializeL();

        }

    iClickedField = NULL;

    }

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

// CMRListPane::InternalizeL()

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

//

void CMRListPane::InternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    iFactory.InternalizeL( aEntry );

    // Record visible fields

    RecordFields();

    // This is called to make sure everything is drawn correctly

    DrawDeferred();

    }

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

// CMRListPane::ExternalizeL()

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

//

void CMRListPane::ExternalizeL(

        MESMRCalEntry& aEntry,

        TBool aForceValidation )

    {

    FUNC_LOG;

    CESMRField* currentFocus = FocusedField();

    ASSERT( currentFocus );

    TESMREntryFieldId id = currentFocus->FieldId();

    if ( aForceValidation )

        {

        // force validate the values:

        TInt err = iFactory.Validate( id, aForceValidation );

        // fill the calendar entry with data in fields.

        iFactory.ExternalizeL( aEntry );

        }

    else

        {

        TInt err = iFactory.Validate( id );

        if ( err )

            {

            //SetControlFocusedL( id ); Why would we set this focused here?

            User::Leave( err );

            }

        else

            {

            // fill the calendar entry with data in fields.

            iFactory.ExternalizeL( aEntry );

            }

        }

    }

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

// CMRListPane::DisableSizeChange()

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

//

void CMRListPane::DisableSizeChange(TBool aDisable )

    {

    FUNC_LOG;

    iDisableSizeChanged = aDisable;

    }

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

// CMRListPane::InitialScroll

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

//

void CMRListPane::InitialScrollL()

    {

    FUNC_LOG;

    // Check if the ResponseArea exist

    TESMREntryFieldId id = GetResponseFieldsFieldId();

    if( id == EESMRFieldResponseArea )

        {

        // Set the focus on the ResponseArea

        iFieldContainer->SetControlFocusedL( id );

        //iFactory.FieldById(id)->SetFocus( ETrue );

        // Scroll the list to put the ResponseArea on the top

        CESMRField* focusField = FocusedField();

        TPoint pos( focusField->Position() );

        ScrollFieldsUp(pos.iY);

        }

    }

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

// CMRListPane::FocusedItem

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

//

CESMRField* CMRListPane::FocusedField() const

    {

    FUNC_LOG;

    return iFieldContainer->FocusedField();

    }

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

// CMRListPane::SetControlFocusedL

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

//

void CMRListPane::SetControlFocusedL( TESMREntryFieldId aFieldId )

    {

    FUNC_LOG;

    iFieldContainer->SetControlFocusedL( aFieldId );

    }

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

// CMRListPane::ClickedItem

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

//

CESMRField* CMRListPane::ClickedField() const

    {

    return iClickedField;

    }

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

// CMRListPane::CountComponentControls

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

//

TInt CMRListPane::CountComponentControls() const

    {

    FUNC_LOG;

    return 1; // iFieldContainer

    }

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

// CMRListPane::ComponentControl

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

//

CCoeControl* CMRListPane::ComponentControl( TInt /*aIndex*/ ) const

    {

    FUNC_LOG;

    return iFieldContainer;

    }

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

// CMRListPane::SizeChanged

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

//

void CMRListPane::SizeChanged()

    {

    FUNC_LOG;

    if ( iDisableSizeChanged || Rect() == TRect( 0, 0, 0, 0 ) )

        {

        return;

        }

    TSize containerSize( iFieldContainer->MinimumSize() );

    iFieldContainer->SetSize( containerSize );

    // Physics:

    iPhysics->InitPhysics();

    DoUpdateScrollBar();

    }

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

// CMRListPane::OfferKeyEventL

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

//

TKeyResponse CMRListPane::OfferKeyEventL( const TKeyEvent &aKeyEvent,

                                          TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response( EKeyWasNotConsumed );

    // First check if the focused item needs the key event

    response = FocusedField()->OfferKeyEventL( aKeyEvent, aType );

    if ( aType == EEventKey

         && response == EKeyWasNotConsumed )

        {

        // Check if the focus should be changed

        switch ( aKeyEvent.iScanCode )

            {

            case EStdKeyUpArrow:

                {

                response = iFieldContainer->MoveFocusUpL( HiddenFocus() );

                // Focus changed via keyboard, iClickedItem is no

                // longer valid

                iClickedField = NULL;

                break;

                }

            case EStdKeyDownArrow:

                {

                response = iFieldContainer->MoveFocusDownL( HiddenFocus() );

                // Focus changed via keyboard, iClickedItem is no

                // longer valid

                iClickedField = NULL;

                break;

                }

            case EStdKeyEnter:

                {

                FocusedField()->ExecuteGenericCommandL( EAknCmdOpen );

                break;

                }

            default:

                {

                break;

                }

            }

        }

    return response;

    }

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

// CMRListPane::HandleLongTapEventL

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

//

void CMRListPane::HandleLongTapEventL(

        const TPoint& aPenEventLocation,

        const TPoint& /* aPenEventScreenLocation */ )

    {

    FUNC_LOG;

    iLongTapEventInProgess = EFalse;

    // Long tap functionality may vary between fields

    // ==> Command field to execute action related to long tap

    TInt count( iFactory.Count() );

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

        {

        CESMRField* field = iFactory.Field( i );

        if ( field->IsVisible()

             && field->Rect().Contains( aPenEventLocation ) )

            {

            field->LongtapDetectedL( aPenEventLocation );

            iLongTapEventInProgess = ETrue;

            break;

            }

        }

    }

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

// CMRListPane::DoUpdateScrollBar

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

//

void CMRListPane::DoUpdateScrollBar( TInt aFocusPosition )

    {

    FUNC_LOG;

    // Set this lispane's size as scroll bar's window size

    iScrollModel.SetWindowSize( iSize.iHeight );

    // Set fieldcontainer's height as scrolbar's scroll span

    iScrollModel.SetScrollSpan( iFieldContainer->MinimumSize().iHeight );

    // Update scrollbar focus position.

    if( aFocusPosition == KErrNotFound )

        {

        iScrollModel.SetFocusPosition( iPhysics->VerticalScrollIndex() );

        }

    else

        {

        iScrollModel.SetFocusPosition( aFocusPosition );

        }

    iScroll.SetModel( &iScrollModel );

    // finally update the new thumb position to view's

    // iScrollBarThumbPosition member.

    iScrollBarObserver.ScrollBarPositionChanged(

            iScroll.ThumbPosition() );

    }

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

// CMRListPane::UpdatedFocusPosition

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

//

TInt CMRListPane::UpdatedFocusPosition()

    {

    FUNC_LOG;

    TInt focusPos = 0;

    TInt count = iFactory.Count();

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

        {

        CESMRField* field = iFactory.Field( i );

        if ( field->IsVisible() )

            {

            TRect rect( field->Rect() );

            // Check if the field's top is above scroll area origo.

            if ( rect.iTl.iY  < 0 )

                {

                // Whole field is above origo

                if ( rect.iBr.iY < 0 )

                    {

                    focusPos += rect.Height();

                    }

                // Part of the field is above origo

                else

                    {

                    focusPos += Abs( rect.iTl.iY );

                    }

                }

            else

                {

                // Rest of the fields are below scroll area origo

                break;

                }

            }

        }

    return focusPos;

    }

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

// CMRListPane::ScrollFieldsUp

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

//

void CMRListPane::ScrollFieldsUp( TInt aPx )

    {

    FUNC_LOG;

    iPositionChanged = ETrue;

    iUpdatedPanePoint = iFieldContainer->Position();

    iUpdatedPanePoint.iY -= aPx;

    if ( !iPointerEventInProgress )

        {

        // We can updace view only if pointer event processing

        // is not ongoing.

        // If pointer event processing is ongoing, view is updated

        // in CMRListPane::HandlePointerEventL method.

        UpdatePosition();

        }

    }

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

// CMRListPane::ScrollFieldsDown

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

//

void CMRListPane::ScrollFieldsDown( TInt aPx )

    {

    FUNC_LOG;

    iPositionChanged = ETrue;

    iUpdatedPanePoint = iFieldContainer->Position();

    iUpdatedPanePoint.iY += aPx;

    if ( !iPointerEventInProgress )

        {

        // We can updace view only if pointer event processing

        // is not ongoing.

        // If pointer event processing is ongoing, view is updated

        // in CMRListPane::HandlePointerEventL method.

        UpdatePosition();

        }

    }

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

// CMRListPane::UpdateScrollBarAndPhysics

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

//

void CMRListPane::UpdateScrollBarAndPhysics()

    {

    FUNC_LOG;

    // Update physics world size

    iPhysics->InitPhysics();

    // Update scrollbar

    DoUpdateScrollBar();

    }

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

// CMRListPane::ShowControl

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

//

void CMRListPane::ShowControl( TESMREntryFieldId aFieldId )

    {

    FUNC_LOG;

    iFieldContainer->ShowControl( aFieldId );

    }