/*

* Copyright (c) 2007-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:  ESMR policy implementation

*

*/

#include "emailtrace.h"

#include <caltime.h>

#include <calentry.h>

#include <layoutmetadata.cdl.h>

#include <e32math.h>

#include <aknphysics.h>

#include "cesmrlistcomponent.h"

#include "cesmrlayoutmgr.h"

#include "nmrlayoutmanager.h"

#include "mesmrfieldstorage.h"

#include "mesmrcalentry.h"

#include "cesmrfield.h"

#include "cmrlistpane.h"

// <cmail> Removed profiling. </cmail>

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

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

// CESMRListComponent::NewL()

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

//

CESMRListComponent* CESMRListComponent::NewL( const CCoeControl* aParent,

                                             MESMRFieldStorage* aStorage,

                                             CESMRLayoutManager* aLayout )

    {

    FUNC_LOG;

    CESMRListComponent* self = new (ELeave) CESMRListComponent( aStorage,

                                                                aLayout );

    CleanupStack::PushL( self );

    self->ConstructL( aParent );

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRListComponent::CESMRListComponent()

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

//

CESMRListComponent::CESMRListComponent( MESMRFieldStorage* aFactory,

                                        CESMRLayoutManager* aLayout ) :

    iFactory( aFactory ),

    iLayout( aLayout )

    {

    FUNC_LOG;

    // Do nothing

    }

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

// CESMRListComponent::~CESMRListComponent

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

//

CESMRListComponent::~CESMRListComponent()

    {

    FUNC_LOG;

    delete iFactory;

    delete iScroll;

    delete iContainer;

    delete iPhysics;

    }

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

// CESMRListComponent::ConstructL()

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

//

void CESMRListComponent::ConstructL( const CCoeControl* aParent )

    {

    FUNC_LOG;

    CreateWindowL( aParent );

    iScroll = new (ELeave) CAknDoubleSpanScrollBar( this );

    iScroll->ConstructL( EFalse, this, this, CEikScrollBar::EVertical, 0 );

    iScroll->SetModel( &iScrollModel );

    iScroll->MakeVisible( ETrue );

    const TInt count(iFactory->Count());

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

        {

        CESMRField* field = iFactory->Field(i);

        field->SetListObserver( this );

        field->SetLayoutManager( iLayout );

        }

    iContainer = CMRListPane::NewL( *this, *iFactory, iScrollModel );

    iPrevThumbPos = iScroll->ThumbPosition();

    if ( CAknPhysics::FeatureEnabled() )

        {

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

        }

    }

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

// CESMRListComponent::InternalizeL()

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

//

void CESMRListComponent::InitializeL()

    {

    FUNC_LOG;

    const TInt count(iFactory->Count());

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

        {

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

        }

    }

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

// CESMRListComponent::InternalizeL()

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

//

void CESMRListComponent::InternalizeL( MESMRCalEntry& aEntry )

    {

    FUNC_LOG;

    iFactory->InternalizeL( aEntry );

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

    DrawDeferred();

    }

void CESMRListComponent::DisableSizeChange(TBool aDisable )

    {

    FUNC_LOG;

    iDisableSizeChanged = aDisable;

    }

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

// CESMRListComponent::ExternalizeL()

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

//

void CESMRListComponent::ExternalizeL( 

		MESMRCalEntry& aEntry, 

		TBool aForceValidation )

    {

    FUNC_LOG;

    CESMRField* currentFocus = FocusedItem();

    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 );

            User::Leave( err );

            }

        else

            {

            // fill the calendar entry with data in fields.

            iFactory->ExternalizeL( aEntry );

            }

        }

    }

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

// CESMRListComponent::CountComponentControls()

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

//

TInt CESMRListComponent::CountComponentControls() const

    {

    FUNC_LOG;

    return 2;

    }

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

// CESMRListComponent::HandleFontChange()

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

//

void CESMRListComponent::HandleFontChange()

    {

    FUNC_LOG;

    // Disable SizeChanged handling until all fonts are updated

    iDisableSizeChanged = ETrue;

    const TInt count(iFactory->Count());

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

        {

        // Updates Font depending on the type of a field

        TRAP_IGNORE( iFactory->Field(i)->FontChangedL() );

        }

    // Enable and call SizeChanged

    iDisableSizeChanged = EFalse;

    SizeChanged();

    }

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

// CESMRListComponent::ComponentControl()

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

//

CCoeControl* CESMRListComponent::ComponentControl( TInt aInd ) const

    {

    FUNC_LOG;

    CCoeControl* control = NULL;

    switch ( aInd )

        {

        case 0:

            control = iContainer;

            break;

        case 1:

            control = iScroll;

            break;

        default:

            break;

        }

    return control;

    }

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

// CESMRListComponent::SizeChanged

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

//

void CESMRListComponent::SizeChanged()

    {

    FUNC_LOG;

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

        {

        return;

        }

    TRect containerRect( Rect() );

    TAknLayoutRect listareaLayoutRect =

        NMRLayoutManager::GetLayoutRect( containerRect, NMRLayoutManager::EMRLayoutListArea );

    TRect listareaRect( listareaLayoutRect.Rect() );

    iContainer->SetRect( listareaRect );

    TAknWindowComponentLayout scrollLayout =

        NMRLayoutManager::GetWindowComponentLayout( NMRLayoutManager::EMRLayoutScrollBar );

    AknLayoutUtils::LayoutControl( iScroll, containerRect, scrollLayout );

    ScrollItemVisible( KErrNotFound ); // Update scroll position

    // physics needs to be initialized before screensaver gets activated    

    TRAP_IGNORE( UpdatePhysicsL() );

    }

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

// CESMRListComponent::OfferKeyEventL

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

//

TKeyResponse CESMRListComponent::OfferKeyEventL(

		const TKeyEvent &aEvent, 

		TEventCode aType )

    {

    FUNC_LOG;

    TKeyResponse response = iContainer->OfferKeyEventL( aEvent, aType );

    if ( EKeyWasConsumed == response )

        {

        iScroll->SetModel( &iScrollModel );

        }

    TInt thumbPos = iScroll->ThumbPosition();

    iPrevThumbPos = thumbPos;

    if( iPhysics )

        {

        iPhysics->StopPhysics();

        iPhysics->ResetFriction();

        }

    return response;

    }

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

// CESMRListComponent::HandleScrollEventL

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

//

void CESMRListComponent::HandleScrollEventL(

    CEikScrollBar* aScrollBar,

    TEikScrollEvent /*aEventType*/ )

    {

    FUNC_LOG;

    if ( aScrollBar == iScroll )

        {

        TInt thumbPos = aScrollBar->ThumbPosition();

        TInt delta = thumbPos - iPrevThumbPos;

        if ( delta != 0 )

            {

            iPrevThumbPos = thumbPos;

            iContainer->ScrollView( delta );

            }

        }

    if( iPhysics )

        {

        iPhysics->StopPhysics();

        iPhysics->ResetFriction();

        }

    }

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

// CESMRListComponent::UpdatePhysicsL

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

//

void CESMRListComponent::UpdatePhysicsL()

    {

    FUNC_LOG;

    if ( iPhysics )

        {

        const TSize viewSize( Size() );

        TInt wSize = iScrollModel.ScrollSpan();

        const TSize worldSize( viewSize.iWidth, wSize );

        iPhysics->StopPhysics();

        iPhysics->ResetFriction();

        iPhysics->InitPhysicsL( worldSize, viewSize, EFalse );

        }

    }

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

// CESMRListComponent::ViewPositionChanged

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

//

void CESMRListComponent::ViewPositionChanged(

        const TPoint& aNewPosition,

        TBool /*aDrawNow*/,

        TUint /*aFlags*/ )

    {

    // Sometimes ViewPositionChanged events come after view is already changed,

    // so adding a safety check here

    if( IsVisible() )

        {

        TPoint centerPos = iContainer->GetViewCenterPosition();

        TInt scrollOffset = aNewPosition.iY - centerPos.iY;

        iContainer->ScrollView( scrollOffset );

        iPrevThumbPos = iScroll->ThumbPosition();

        // updates scrollbar thumb position and does redrawing

        iScroll->SetModel( &iScrollModel );

        }

    }

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

// CESMRListComponent::PhysicEmulationEnded

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

//

void CESMRListComponent::PhysicEmulationEnded()

    {

    }

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

// CESMRListComponent::ViewPosition

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

//

TPoint CESMRListComponent::ViewPosition() const

    {

    TPoint viewPos = iContainer->GetViewCenterPosition();

    return viewPos;

    }

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

// CESMRListComponent::ScrollItemVisible()

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

//

void CESMRListComponent::ScrollItemVisible( TInt aInd/*, TBool*/ /*aSizeChanged*/ )

    {

    FUNC_LOG;

    iContainer->ScrollItemVisible( aInd );

    UpdateScrollBar();

    DrawDeferred();

    }

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

// CESMRListComponent::UpdateScrollBar()

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

//

void CESMRListComponent::UpdateScrollBar()

    {

    FUNC_LOG;

    iContainer->UpdateFocusPosition();

    iScroll->SetModel( &iScrollModel );

    }

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

// CESMRListComponent::ListObserver

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

//

MESMRListObserver& CESMRListComponent::ListObserver()

    {

    FUNC_LOG;

    return *this;

    }

CESMRField* CESMRListComponent::FocusedItem() const

    {

    FUNC_LOG;

    return iContainer->FocusedItem();

    }

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

// CESMRListComponent::IsControlVisible()

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

//

TBool CESMRListComponent::IsControlVisible( TESMREntryFieldId aField )

    {

    FUNC_LOG;

    TBool ret( EFalse );

    CESMRField* field = iFactory->FieldById( aField );

    if ( field && field->IsVisible() )

        {

        ret = ETrue;

        }

    return ret;

    }

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

// CESMRListComponent::ControlSizeChanged()

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

//

void CESMRListComponent::ControlSizeChanged( CESMRField* aField )

    {

    FUNC_LOG;

    /* Called whenever one of the controls size changed

     * E.G. when a eik edwin expands */

    iContainer->ControlSizeChanged( aField );

    }

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

// CESMRListComponent::InsertControl()

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

//

void CESMRListComponent::InsertControl( TESMREntryFieldId aField )

    {

    FUNC_LOG;

    iContainer->InsertControl( aField );

    }

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

// CESMRListComponent::RemoveControl()

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

//

void CESMRListComponent::RemoveControl( TESMREntryFieldId aField )

    {

    FUNC_LOG;

    iContainer->RemoveControl( aField );

    }

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

// CESMRListComponent::SetControlFocused()

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

//

void CESMRListComponent::SetControlFocusedL( TESMREntryFieldId aField )

    {

    FUNC_LOG;

    iContainer->SetControlFocusedL( aField );

    UpdateScrollBar();

    }

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

// CESMRListComponent::MoveListAreaDownL

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

//

void CESMRListComponent::MoveListAreaDownL( TInt aAmount )

    {

    FUNC_LOG;

    iContainer->MoveListAreaDownL( aAmount );

    // Do the view scrolling if needed:

    if ( aAmount )

        {

        UpdateScrollBar();

        DrawDeferred();

        }

    }

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

// CESMRListComponent::MoveListAreaUpL

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

//

void CESMRListComponent::MoveListAreaUpL( TInt aAmount )

    {

    FUNC_LOG;

    iContainer->MoveListAreaUpL( aAmount );

    // do the scrolling if needed:

    if ( aAmount > 0 )

        {

        UpdateScrollBar();

        DrawDeferred();

        }

    }

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

// CESMRListComponent::ListHeight()

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

//

TInt CESMRListComponent::ListHeight()

    {

    FUNC_LOG;

    return iContainer->Size().iHeight;

    }

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

// CESMRListComponent::IsFieldBottomVisible()

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

//

 TBool CESMRListComponent::IsFieldBottomVisible()

    {

    FUNC_LOG;

    return iContainer->IsFieldBottomVisible();

    }