/*

* 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 <eikmfne.h>

#include <eikenv.h>

#include <stringloader.h>

#include <e32math.h>

#include <AknUtils.h>

#include <LmkUi.rsg>

#include "landmarks.hrh"

#include "LmkConsts.h"

#include "CLmkMfneFloat.h"

#include "CLmkDistanceEditor.h"

#include <AknBidiTextUtils.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

const TInt KKeyToMatchEmptyUnits = 0;

const TInt KKeyToMatchMeters = 109;

const TInt KKeyToMatchKilometers = 75;

const TInt KKeyToMatchFeet = 87;

const TInt KKeyToMatchMiles = 77;

const TInt KNumMetricUnitSymbols = 2;

const TInt KNumImperialUnitSymbols = 2;

const TInt KMaxNumSignificantDigits = 7;  // DDDDD.DD

const TInt KMaxNumDecimalDigits = 2;

const TInt KNumFields = 2; // float, Units

}  // namespace

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

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

// CLmkDistanceEditor::CLmkDistanceEditor

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

// might leave.

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

//

CLmkDistanceEditor::CLmkDistanceEditor()

    {

    }

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

// CLmkDistanceEditor::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLmkDistanceEditor::ConstructL(

    TReal32 aMinimumValue,

    TReal32 aMaximumValue,

    TReal32 aInitialValue)

    {

    iMinimumValue = aMinimumValue;

    iMaximumValue = aMaximumValue;

    // create float field

    BaseConstructL(KNumFields);

    if (!AknLayoutUtils::LayoutMirrored())

        {

        ConstructValueFieldL(KMaxNumSignificantDigits, KMaxNumDecimalDigits);

        ConstructUnitFieldL();

        }

    else

        {

        ConstructUnitFieldL();

        ConstructValueFieldL(KMaxNumSignificantDigits, KMaxNumDecimalDigits);

        }

    // Init value

    SetUnit(DefaultUnit());

    UpdateValueLimits();

    SetNumber(aInitialValue);

    ShowUnits(!Math::IsNaN(aInitialValue));

    }

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

// CLmkDistanceEditor::ConstructUnitFieldL

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

//

void CLmkDistanceEditor::ConstructUnitFieldL()

    {

    TLocale locale;

    //create distance types

    TInt numUnitsymbols = KNumMetricUnitSymbols + 1; // +empty Units

    if (locale.UnitsGeneral() == EUnitsImperial)

        {

        numUnitsymbols += KNumImperialUnitSymbols;

        }

    iUnitsField = CEikMfneSymbol::NewL(numUnitsymbols);

    // create Units field

    HBufC* type = NULL;

    // add empty Units

    type = HBufC::NewLC(1);

    iUnitsField->AddSymbolicItem(

        CEikMfneSymbol::CItem::NewL(EUnitNone, KKeyToMatchEmptyUnits, type ),

        ETrue);

    CleanupStack::Pop(type);

    // add metric Units

    type = StringLoader::LoadLC( R_LMK_DISTANCE_EDITOR_TYPE_M, iCoeEnv );

    iUnitsField->AddSymbolicItem(

        CEikMfneSymbol::CItem::NewL( EUnitMeters, KKeyToMatchMeters, type ),

        EFalse);

    CleanupStack::Pop(type);

    type = StringLoader::LoadLC( R_LMK_DISTANCE_EDITOR_TYPE_KM, iCoeEnv );

    iUnitsField->AddSymbolicItem(

        CEikMfneSymbol::CItem::NewL( EUnitKilometers, KKeyToMatchKilometers, type ),

        EFalse);

    CleanupStack::Pop(type);

    // Add imperial Units for those who use them

    if ( locale.UnitsGeneral() == EUnitsImperial )

        {

        type = StringLoader::LoadLC( R_LMK_DISTANCE_EDITOR_TYPE_FT, iCoeEnv );

        iUnitsField->AddSymbolicItem(

            CEikMfneSymbol::CItem::NewL( EUnitFeet, KKeyToMatchFeet, type ),

            EFalse);

        CleanupStack::Pop(type);

        type = StringLoader::LoadLC( R_LMK_DISTANCE_EDITOR_TYPE_MI, iCoeEnv );

        iUnitsField->AddSymbolicItem(

            CEikMfneSymbol::CItem::NewL( EUnitMiles, KKeyToMatchMiles, type ),

            EFalse);

        CleanupStack::Pop(type);

        }

    AddField(iUnitsField);

    }

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

// CLmkDistanceEditor::~CLmkDistanceEditor

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

//

CLmkDistanceEditor::~CLmkDistanceEditor()

    {

    }

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

// CLmkDistanceEditor::Number

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

//

TReal CLmkDistanceEditor::Number() const

    {

    return UnitsToMeters(CLmkFloatEditor::Number(), Unit());

    }

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

// CLmkDistanceEditor::SetNumber

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

//

void CLmkDistanceEditor::SetNumber(TReal aNumber)

    {

    ShowUnits(!Math::IsNaN(aNumber));

    CLmkFloatEditor::SetNumber(MetersToUnits(aNumber, Unit()));

    }

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

// CLmkDistanceEditor::SetUnit

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

//

void CLmkDistanceEditor::SetUnit(TDistanceUnit aUnitId)

    {

    iUnitsField->SetCurrentSymbolicItemToId(aUnitId);

    UpdateValueLimits();

    }

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

// CLmkDistanceEditor::Unit

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

//

CLmkDistanceEditor::TDistanceUnit CLmkDistanceEditor::Unit() const

    {

    return (TDistanceUnit) iUnitsField->IdOfCurrentSymbolicItem();

    }

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

// CLmkDistanceEditor::DefaultUnit

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

//

CLmkDistanceEditor::TDistanceUnit CLmkDistanceEditor::DefaultUnit() const

    {

    return EUnitMeters;

    }

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

// CLmkDistanceEditor::UpdateValueLimits

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

//

void CLmkDistanceEditor::UpdateValueLimits()

    {

    if (Unit() != EUnitNone)

        {

        SetLimits(

            MetersToUnits(iMinimumValue, Unit()),

            MetersToUnits(iMaximumValue, Unit()));

        }

    }

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

// CLmkDistanceEditor::MetersToUnits

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

//

TReal32 CLmkDistanceEditor::MetersToUnits(

    TReal32 aMeters,

    TDistanceUnit aToUnits) const

    {

    TRealX nan;

    nan.SetNaN();

    if (Math::IsNaN(aMeters))

        {

        return nan;

        }

    switch (aToUnits)

        {

        case EUnitMeters:

            return aMeters;

        case EUnitKilometers:

            return aMeters / KKilometerToMeter;

        case EUnitMiles:

            return aMeters / KMileToMeter;

        case EUnitFeet:

            return aMeters * KMetreToFoot;

        default:

            return nan;

        }

    }

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

// CLmkDistanceEditor::UnitsToMeters

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

//

TReal32 CLmkDistanceEditor::UnitsToMeters(

    TReal32 aValue,

    TDistanceUnit aFromUnits) const

    {

    TRealX nan;

    nan.SetNaN();

    if (Math::IsNaN(aValue))

        {

        return nan;

        }

    switch (aFromUnits)

        {

        case EUnitMeters:

            return aValue;

        case EUnitKilometers:

            return aValue * KKilometerToMeter;

        case EUnitMiles:

            return aValue * KMileToMeter;

        case EUnitFeet:

            return aValue / KMetreToFoot;

        default:

            return nan;

        }

    }

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

// CLmkDistanceEditor::ShowUnits

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

//

void CLmkDistanceEditor::ShowUnits(TBool aVisible)

    {

    if (aVisible)

        {

        if (Unit() == EUnitNone)

            {

            SetUnit(DefaultUnit());

            }

        }

    else

        {

        SetUnit(EUnitNone);

        }

    }

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

// CLmkDistanceEditor::HandleEnter

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

//

void CLmkDistanceEditor::HandleEnter()

    {

    ShowUnits(ETrue);

    CLmkFloatEditor::HandleEnter();

    }

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

// CLmkDistanceEditor::HandleExit

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

//

void CLmkDistanceEditor::HandleExit()

    {

    ShowUnits(!IsNan());

    CLmkFloatEditor::HandleExit();

    }

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

// CLmkDistanceEditor::HandleCustomFieldChanged

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

//

void CLmkDistanceEditor::HandleCustomFieldChanged(TInt aFieldIndex)

    {

    if (Field(aFieldIndex) == iUnitsField)

        {

        if (Unit() == EUnitNone)

            {

            // cycle from empty unit

            SetUnit(DefaultUnit());

            }

        else

            {

            UpdateValueLimits();

            }

        }

    }

//  End of File