/*

* Copyright (c) 2002 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:    LandmarksUi Content File -

*

*/

// INCLUDE FILES

#include <LmkUi.rsg>

#include <e32math.h>

#include <eikmfne.h>

#include <AknUtils.h>

#include <AknEditStateIndicator.h>

#include <eikenv.h>

#include <stringloader.h>

#include "landmarks.hrh"

#include "LmkConsts.h"

#include "CLmkMfneFloat.h"

#include "CLmkFloatEditor.h"

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

#if defined(_DEBUG)

void Panic(TInt aReason)

    {

    _LIT(KPanicCategory, "CLmkFloatEditor");

    User::Panic(KPanicCategory, aReason);

    }

#endif

}  // namespace

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

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

// CLmkFloatEditor::CLmkFloatEditor

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CLmkFloatEditor::CLmkFloatEditor()

    {

    iIsMirroredLayout = AknLayoutUtils::LayoutMirrored();

    }

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

// CLmkFloatEditor::BaseConstructL

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

//

 void CLmkFloatEditor::BaseConstructL(TInt aMaxNumFields)

	{

    __ASSERT_DEBUG(aMaxNumFields > 0, Panic(KErrArgument));

    CreateFieldArrayL(aMaxNumFields);

	}

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

// CLmkFloatEditor::ConstructValueFieldL

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

//

 void CLmkFloatEditor::ConstructValueFieldL(

    TInt aMaxNumSignificantDigits,

    TInt aMaxDecimals)

    {

    __ASSERT_DEBUG(iValueField == NULL, Panic(KErrGeneral));

	iValueField =

	    CLmkMfneFloat::NewL(

	        aMaxNumSignificantDigits,

	        aMaxDecimals);

	AddField(iValueField);

	}

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

// CLmkFloatEditor::~CLmkFloatEditor

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

//

CLmkFloatEditor::~CLmkFloatEditor()

    {

    }

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

// CLmkDistanceEditor::SetNumberL

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

//

void CLmkFloatEditor::SetNumber(TReal aNumber)

    {

    __ASSERT_DEBUG(iValueField, Panic(KErrGeneral));

    iValueField->SetValue(aNumber);

    HandleValueChanged();

    }

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

// CLmkFloatEditor::Number

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

//

TReal CLmkFloatEditor::Number() const

    {

    __ASSERT_DEBUG(iValueField, Panic(KErrGeneral));

    return iValueField->Value();

    }

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

// CLmkFloatEditor::IsModified

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

//

TBool CLmkFloatEditor::IsModified()

    {

    return iIsModified;

    }

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

// CLmkFloatEditor::IsNan

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

//

TBool CLmkFloatEditor::IsNan()

    {

    __ASSERT_DEBUG(iValueField, Panic(KErrGeneral));

    return Math::IsNaN(iValueField->Value());

    }

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

// CLmkFloatEditor::SetLimits

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

//

TBool CLmkFloatEditor::SetLimits(TReal aMinimumValue, TReal aMaximumValue)

    {

    __ASSERT_DEBUG(iValueField, Panic(KErrGeneral));

    if (iValueField->SetLimits(aMinimumValue, aMaximumValue))

        {

        HandleValueChanged();

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CLmkFloatEditor::GetLimits

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

//

void CLmkFloatEditor::GetLimits(TReal& aMinimum, TReal& aMaximum)

    {

    __ASSERT_DEBUG(iValueField, Panic(KErrGeneral));

    iValueField->GetLimits(aMinimum, aMaximum);

    }

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

// CLmkFloatEditor::HandleValueChanged

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

//

void CLmkFloatEditor::HandleValueChanged()

    {

    if (IsNan())

        {

        // switch to iValueField,

        // otherwise it won't be possible to enter value anymore

        if (Field(CurrentField()) != iValueField)

            {

            HighlightField(FindValueField());

            }

        }

    DrawDeferred();

    }

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

// CLmkFloatEditor::HandleCustomFieldChanged

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

//

void CLmkFloatEditor::HandleCustomFieldChanged(TInt /*aCustomFieldIndex*/)

    {

    DrawDeferred();

    }

void CLmkFloatEditor::HandleEnter()

    {

    DrawDeferred();

    }

void CLmkFloatEditor::HandleExit()

    {

    DrawDeferred();

    }

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

// CLmkFloatEditor::FindValueField

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

//

TInt CLmkFloatEditor::FindValueField()

    {

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

        {

        if (Field(i) == iValueField)

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

// CLmkFloatEditor::HighlightField

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

//

void CLmkFloatEditor::HighlightField(TInt aFieldPosition)

    {

    if (CurrentField() != aFieldPosition)

        {

        TBool dataAltered = EFalse;

        TBool error = EFalse;

        const CFont& font=*Font();

        CEikMfne::HandleInteraction(

            ETrue,

            aFieldPosition,

            Field(CurrentField())->MaximumWidthInPixels(font, EFalse),

            Field(CurrentField())->HighlightType(),

            dataAltered,

            error);

        }

    }

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

// CLmkFloatEditor::FocusChanged

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

//

void CLmkFloatEditor::FocusChanged(TDrawNow aDrawNow)

    {

    if (!IsReadyToDraw())

        {

        // this is workaround for MFNE's bug.

        // otherwise it will panic hiding cursor

        return;

        }

    if (IsFocused())

        {

        HandleEnter();

        // need to inform CLmkMfneFloat that it is highlighted

        // because CEikMfne does not do it

        if (iValueField &&

            iValueField == Field(CurrentField()))

            {

            iValueField->HandleHighlight();

            }

        }

    else

        {

        HandleExit();

        }

    CEikMfne::FocusChanged(aDrawNow);

    }

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

// CLmkFloatEditor::OfferKeyEventL

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

//

TKeyResponse CLmkFloatEditor::OfferKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType)

    {

    // disallow switch to other fields if value is nan,

    // because it's hard to inform CLmkMfneFloat

    // that focus has changed to it from other field.

    // If it is not done, then CEikMfne will panic when

    // hiding cursor

    if (IsNan() &&

       (aKeyEvent.iCode == EKeyLeftArrow ||

        aKeyEvent.iCode == EKeyRightArrow))

        {

        return EKeyWasConsumed;

        }

    TInt oldField = CurrentField();

    TKeyResponse response = CEikMfne::OfferKeyEventL(aKeyEvent, aType);

    if (response == EKeyWasConsumed)

        {

        // update focus state in CLmkMfneFloat

        if (oldField != CurrentField() &&

            Field(CurrentField()) == iValueField)

            {

            iValueField->HandleHighlight();

            }

        // inform about changes

        if (aKeyEvent.iCode != EKeyLeftArrow &&

            aKeyEvent.iCode != EKeyRightArrow)

            {

            iIsModified = ETrue;

            if (Field(oldField) == iValueField)

                {

                HandleValueChanged();

                }

            else

                {

                HandleCustomFieldChanged(oldField);

                }

            }

        }

    DrawNow();

    return response;

    }

//  End of File