/*

* 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:  Field container for UI fields

*

*/

#include "cmrfieldcontainer.h"

#include "mesmrfieldstorage.h"

#include "mmrfieldcontainerobserver.h"

#include "cesmrfield.h"

//DEBUG

#include "emailtrace.h"

namespace { // codescanner::namespace

// Off screen field x coordinate

const TInt KOffScreenPositionX =  1000;

/**

 * Vertical scroll margin

 */

const TInt KVerticalScrollMargin = 3;

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

// 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 ----

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

// CMRFieldContainer::CMRFieldContainer

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

//

CMRFieldContainer::CMRFieldContainer( MESMRFieldStorage& aFactory )

    : iFactory( aFactory )

    {

    FUNC_LOG;

    }

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

// CMRFieldContainer::~CMRFieldContainer

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

//

CMRFieldContainer::~CMRFieldContainer()

    {

    FUNC_LOG;

    // No implementation

    }

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

// CMRFieldContainer::NewL

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

//

CMRFieldContainer* CMRFieldContainer::NewL(

        MESMRFieldStorage& aFactory,

        const CCoeControl& aParent )

    {

    FUNC_LOG;

    CMRFieldContainer* self = new( ELeave )CMRFieldContainer( aFactory );

    CleanupStack::PushL( self );

    self->ConstructL( aParent );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMRFieldContainer::ConstructL

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

//

void CMRFieldContainer::ConstructL( const CCoeControl& aParent )

    {

    FUNC_LOG;

    CCoeControl::SetComponentsToInheritVisibility( ETrue );

    SetContainerWindowL( aParent );

    TBool focusSet( EFalse );

    const TInt count( iFactory.Count() );

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

        {

        iFactory.Field(i)->SetContainerWindowL( *this );

        }

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

        {

        CESMRField* field = iFactory.Field( i );

        // Initialize field

        field->InitializeL();

        if ( !focusSet

             && field->IsVisible()

             && !field->IsNonFocusing())

            {

            field->SetOutlineFocusL( ETrue );

            focusSet = ETrue;

            iFocusedFieldIndex = i;

            }

        }

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

        {

        CESMRField* field = iFactory.Field( i );

        field->SetListObserver( this );

        }

    }

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

// CMRFieldContainer::FocusedItem

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

//

CESMRField* CMRFieldContainer::FocusedField() const

    {

    FUNC_LOG;

    /*

     * Returns currently focused field

     */

    CESMRField* field = NULL;

    if ( iFactory.Count() > 0 )

        {

        field = iFactory.Field( iFocusedFieldIndex );

        }

    return field;

    }

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

// CMRFieldContainer::MoveFocusUpL

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

//

TKeyResponse CMRFieldContainer::MoveFocusUpL( TBool aHiddenFocus )

    {

    FUNC_LOG;

    /*

     * Moves focus up after key event. If aHiddenFocus, moves focus

     * to the first visible field in the bottom of the viewable area.

     */

    if( aHiddenFocus )

        {

        return MoveFocusVisibleL();

        }

    else

        {

        TInt ind( iFocusedFieldIndex );

        // search next visible focus item

        while ( ind > 0 )

            {

            CESMRField* field = iFactory.Field( --ind );

            if ( !field->IsNonFocusing() )

                {

                field = iFactory.Field( ind );

                CESMRField* focusedField = iFactory.Field( iFocusedFieldIndex );

                if ( field->IsVisible() )

                    {

                    TBool canLoseFocus(

                            focusedField->OkToLoseFocusL( field->FieldId() ) );

                    if ( canLoseFocus )

                        {

                        field->SetPreItemIndex( iFocusedFieldIndex );

                        iFocusedFieldIndex = ind;

                        field->SetCurrentItemIndex( iFocusedFieldIndex );

                        // Remove focus from previous position

                        focusedField->SetOutlineFocusL( EFalse );

                        focusedField->SetFocus( EFalse );

                        focusedField->MoveToScreen( EFalse );

                        // Set focus to new position

                        field->SetOutlineFocusL( ETrue );

                        field->SetFocus( ETrue );

                        field->MoveToScreen( ETrue );

                        // Scrollbar and physics update is done here

                        ScrollControlVisible( iFocusedFieldIndex );

                        DrawDeferred();

                        }

                    return EKeyWasConsumed;

                    }

                }

            }

        return EKeyWasNotConsumed;

        }

    }

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

// CMRFieldContainer::MoveFocusDownL

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

//

TKeyResponse CMRFieldContainer::MoveFocusDownL( TBool aHiddenFocus )

    {

    FUNC_LOG;

    /*

     * Moves focus down after key event. If aHiddenFocus, moves focus

     * to the first visible field in the top of the viewable area.

     */

    if( aHiddenFocus )

        {

        return MoveFocusVisibleL();

        }

    else

        {

        TInt ind( iFocusedFieldIndex );

        // start searching next possible focus item

        TInt maxItemIndex = iFactory.Count() - 1;

        while ( ind < maxItemIndex )

            {

            // only visible and focusable items can be focused

            CESMRField* field = iFactory.Field( ++ind );

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

                {

                CESMRField* focusedField = iFactory.Field( iFocusedFieldIndex );

                TBool canLoseFocus(

                        focusedField->OkToLoseFocusL( field->FieldId() ) );

                // check it its ok for the old focus item to lose focus

                if ( canLoseFocus )

                    {

                    field->SetPreItemIndex( iFocusedFieldIndex );

                    iFocusedFieldIndex = ind;

                    field->SetCurrentItemIndex( iFocusedFieldIndex );

                    // Remove focus from previous position

                    focusedField->SetOutlineFocusL( EFalse );

                    focusedField->SetFocus( EFalse );

                    focusedField->MoveToScreen( EFalse );

                    // Set focus to new position

                    field->SetOutlineFocusL( ETrue );

                    field->SetFocus( ETrue );

                    field->MoveToScreen( ETrue );

                    // Scrollbar and physics update is done here

                    ScrollControlVisible( iFocusedFieldIndex );

                    DrawDeferred();

                    }

                return EKeyWasConsumed;

                }

            }

        return EKeyWasNotConsumed;

        }

    }

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

// CMRFieldContainer::MoveFocusVisibleL

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

//

TKeyResponse CMRFieldContainer::MoveFocusVisibleL()

    {

    FUNC_LOG;

    /*

     * Move focus to first completely visible field in the view,

     * if focus was in a field that was not visible in the view.

     * Use case: After pointer scroll focus is hidden. User presses

     * arrow keys -> Focus appears to the first visible field on the upper

     * or bottom part of the viewable area.

     */

    TKeyResponse response( EKeyWasNotConsumed );

    CESMRField* focusedField = FocusedField();

    CESMRField* visibleField = NULL;

    TRect view( Parent()->Rect() );

    // Focus is above the visible view area

    if ( focusedField->Rect().iBr.iY <= view.iTl.iY )

        {

        // Move focus to next visible field

        TInt lastIndex = iFactory.Count() - 1;

        TInt ind( iFocusedFieldIndex );

        while ( ind < lastIndex && !visibleField )

            {

            visibleField = iFactory.Field( ++ind );

            TRect fieldRect = visibleField->Rect();

            if ( visibleField->IsVisible()

                 && !visibleField->IsNonFocusing()

                 && fieldRect.iTl.iY >= view.iTl.iY )

                {

                // Update previous and current field indexes

                visibleField->SetPreItemIndex( iFocusedFieldIndex );

                iFocusedFieldIndex = ind;

                visibleField->SetCurrentItemIndex( iFocusedFieldIndex );

                }

            else

                {

                visibleField = NULL;

                }

            }

        }

    // Focus is below the visible view area

    else

        {

        // Move focus to previous visible field

        TInt ind( iFocusedFieldIndex );

        while ( ind > 0 && !visibleField )

            {

            visibleField = iFactory.Field( --ind );

            TRect fieldRect = visibleField->Rect();

            if ( visibleField->IsVisible()

                 && !visibleField->IsNonFocusing()

                 && fieldRect.iBr.iY <= view.iBr.iY )

                {

                // Update previous and current field indexes

                visibleField->SetPreItemIndex( iFocusedFieldIndex );

                iFocusedFieldIndex = ind;

                visibleField->SetCurrentItemIndex( iFocusedFieldIndex );

                }

            else

                {

                visibleField = NULL;

                }

            }

        }

    if ( visibleField )

        {

        // Remove existing focus

        focusedField->SetOutlineFocusL( EFalse );

        focusedField->SetFocus( EFalse );

        // Set focus to new field

        visibleField->SetOutlineFocusL( ETrue );

        visibleField->SetFocus( ETrue );

        response = EKeyWasConsumed;

        DrawDeferred();

        }

    return response;

    }

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

// CMRFieldContainer::SetFieldContainerObserver

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

//

void CMRFieldContainer::SetFieldContainerObserver(

        MMRFieldContainerObserver* aObserver )

    {

    FUNC_LOG;

    iObserver = aObserver;

    }

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

// CMRFieldContainer::CountComponentControls

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

//

TInt CMRFieldContainer::CountComponentControls() const

    {

    FUNC_LOG;

    // If field container is scrolling, container will draw also children

    TInt count( 0 );

    if ( !iScrolling )

        {

        count = iFactory.Count();

        }

    return count;

    }

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

// CMRFieldContainer::ComponentControl

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

//

CCoeControl* CMRFieldContainer::ComponentControl( TInt aIndex ) const

    {

    FUNC_LOG;

    return iFactory.Field( aIndex );

    }

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

// CMRFieldContainer::MinimumSize

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

//

TSize CMRFieldContainer::MinimumSize()

    {

    FUNC_LOG;

    /*

     * Returns the minimum size required by the field container

     */

    TSize containerSize;

    // Calculate height as the sum of the heights of the visible fields

    const TInt count( iFactory.Count() );

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

        {

        CESMRField* field = iFactory.Field( i );

        if ( field->IsVisible() )

            {

            TRect rect( field->Rect() );

            containerSize.iHeight += rect.Height();

            }

        }

    containerSize.iWidth = Parent()->Rect().Width();

    return containerSize;

    }

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

// CMRFieldContainer::SizeChanged

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

//

void CMRFieldContainer::SizeChanged()

    {

    FUNC_LOG;

    // For example when orientation changes, we might need to scroll

    // the currently focused control visible again. This handles also

    // scrollbar and physics updates.

    ScrollControlVisible( KErrNotFound );

    TPoint tl( Position() );

    const TInt count( iFactory.Count() );

    // Loop all the visible fields and set size and position in the list

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

        {

        CESMRField* field = iFactory.Field( i );

        if ( field->IsVisible() )

            {

            TPoint pos( tl );

            // If field is not focused, layout it outside screen

            if ( i != iFocusedFieldIndex )

                {

                pos.iX = KOffScreenPositionX;

                }

            LayoutField( *field, pos );

            TInt height = field->Size().iHeight;

            tl.iY += height;

            }

        }

    }

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

// CMRFieldContainer::HandlePointerEventL

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

//

void CMRFieldContainer::HandlePointerEventL( const TPointerEvent &aPointerEvent )

    {

    FUNC_LOG;

    // Find out to which field this pointer event is intended to

    TInt fieldCount( iFactory.Count() );

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

        {

        CCoeControl* field = iFactory.Field( i );

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

                field->IsVisible() )

            {

            field->HandlePointerEventL( aPointerEvent );

            }

        }

    }

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

// CMRFieldContainer::ControlSizeChanged

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

//

void CMRFieldContainer::ControlSizeChanged( CESMRField* aField )

    {

    FUNC_LOG;

    /*

     * Called whenever a fields size has changed. Requires always

     * relayouting.

     */

    if ( !aField )

        {

        SizeChanged();

        }