/*

* Copyright (c) 1999 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:

*

*/

#include <basched.h>

#include <barsread.h>

#include <eikenv.h>

#include <eikmsg.h>

#include <aknipfed.h>

#include <in_sock.h>

#include <gulfont.h>

#include <avkon.hrh>

#include <AknUtils.h>

#include <aknextendedinputcapabilities.h>

#include <AknTasHook.h> // for testability hooks

//

// CAknIpFieldEditor

//

const TInt KNumAddressFields=4;

const TInt KNumDelimiterFields=3;

const TInt KFieldA=0;

const TInt KFieldB=2;

const TInt KFieldC=4;

const TInt KFieldD=6;

// const TInt KTotalNumChars=15;// IPv4 is 4x3 numbers + 3x1 delimiter

_LIT(KDelimiter, "."); // In IPv4 the delimiter is always a dot

/**

 * Public method for constructing a CAknIpFieldEditor object.

 * Gets four parameters:

 * TInetAddr& aMinimumFieldValues - Reference to a TInetAddr struct. Defines lower limits for

 * IP editor fields.

 * TInetAddr& aMaximumFieldValues - Reference to a TInetAddr struct. Defines upper limits for

 * IP editor fields.

 * TInetAddr& aInitialAddress - Reference to a TInetAddr struct. Defines the initial address

 * the IP editor.

 * 

 */

EXPORT_C CAknIpFieldEditor* CAknIpFieldEditor::NewL(TInetAddr& aMinimumFieldValues,

                                                    TInetAddr& aMaximumFieldValues,

                                                    TInetAddr& aInitialAddress)

    {

    CAknIpFieldEditor* editor=new(ELeave)CAknIpFieldEditor;

    CleanupStack::PushL(editor);

    editor->ConstructL(aMinimumFieldValues,aMaximumFieldValues,aInitialAddress);

    CleanupStack::Pop(); // editor

    AKNTASHOOK_ADDL( editor, "CAknIpFieldEditor" );

    return editor;

    }

/**

 * Public method for constructing a CAknIpFieldEditor object. Requires a call for

 * ConstructFromResourcesL method to finish construction.

 * 

 */

EXPORT_C CAknIpFieldEditor* CAknIpFieldEditor::NewL()

    {

    CAknIpFieldEditor* editor=new(ELeave)CAknIpFieldEditor;

    AKNTASHOOK_ADDL( editor, "CAknIpFieldEditor" );

    return editor;

    }

EXPORT_C CAknIpFieldEditor::CAknIpFieldEditor()

	{

	}

void CAknIpFieldEditor::ConstructL(TInetAddr& aMinimumFieldValues,

                                   TInetAddr& aMaximumFieldValues,

                                   TInetAddr& aInitialAddress,

                                   const TInt aFlags)

	{

    TInt numFields=KNumAddressFields+KNumDelimiterFields;

	CreateFieldArrayL(numFields); // MFNE with 7 fields

    TUint8 minValueFieldA=0;

    TUint8 minValueFieldB=0;

    TUint8 minValueFieldC=0;

    TUint8 minValueFieldD=0;

    TUint8 maxValueFieldA=0;

    TUint8 maxValueFieldB=0;

    TUint8 maxValueFieldC=0;

    TUint8 maxValueFieldD=0;

    TUint8 initialValueFieldA=0;

    TUint8 initialValueFieldB=0;

    TUint8 initialValueFieldC=0;

    TUint8 initialValueFieldD=0;

    SplitAddressIntoFields(aMinimumFieldValues, minValueFieldA, minValueFieldB, minValueFieldC, minValueFieldD);

    SplitAddressIntoFields(aMaximumFieldValues, maxValueFieldA, maxValueFieldB, maxValueFieldC, maxValueFieldD);

    SplitAddressIntoFields(aInitialAddress, initialValueFieldA, initialValueFieldB, initialValueFieldC, initialValueFieldD);

    // Set each number field to the correct minimum, maximum and initial values

    CEikMfneField* field;

    field=CEikMfneNumber::NewL(*Font(),

                               minValueFieldA,

                               maxValueFieldA,

                               initialValueFieldA,

                               aFlags);

    AddField(field);

    HBufC* delimiterText=HBufC::NewLC(3);

    delimiterText->Des().Append(KDelimiter);

    AddField(CEikMfneSeparator::NewL(delimiterText));

    CleanupStack::Pop(); // delimiterText

    field=CEikMfneNumber::NewL(*Font(),

                               minValueFieldB,

                               maxValueFieldB,

                               initialValueFieldB,

                               aFlags);

    AddField(field);

    delimiterText=HBufC::NewLC(1);

    delimiterText->Des().Append(KDelimiter);

    AddField(CEikMfneSeparator::NewL(delimiterText));

    CleanupStack::Pop(); // delimiterText

    field=CEikMfneNumber::NewL(*Font(),

                               minValueFieldC,

                               maxValueFieldC,

                               initialValueFieldC,

                               aFlags);

    AddField(field);

    delimiterText=HBufC::NewLC(1);

    delimiterText->Des().Append(KDelimiter);

    AddField(CEikMfneSeparator::NewL(delimiterText));

    CleanupStack::Pop(); // delimiterText

    field=CEikMfneNumber::NewL(*Font(),

                               minValueFieldD,

                               maxValueFieldD,

                               initialValueFieldD,

                               aFlags);

    AddField(field);

	SetMinimumAndMaximum(aMinimumFieldValues, aMaximumFieldValues);

	MObjectProvider* mop = InputCapabilities().ObjectProvider();

	if ( mop )

	    {

	    CAknExtendedInputCapabilities* extendedInputCapabilities =

	        mop->MopGetObject( extendedInputCapabilities );

	    if ( extendedInputCapabilities ) 

	        {

	        extendedInputCapabilities->SetCapabilities(

	            CAknExtendedInputCapabilities::ESupportsOnlyASCIIDigits );

	        }

	    }

	}

/**

 * Method for getting editor fields' minimum and maximum values.

 * Gets two parameters:

 * TInetAddr& aMinimumFieldValues - Reference to a TInetAddr struct in which the lower limits

 * are wanted to be returned.

 * IP editor fields.

 * TInetAddr& aMaximumFieldValues - Reference to a TInetAddr struct in which the upper limits

 * are wanted to be returned.

 * 

 */

EXPORT_C void CAknIpFieldEditor::GetMinimumAndMaximum(TInetAddr& aMinimumFieldValues,

                                                      TInetAddr& aMaximumFieldValues) const

	{

    TInt firstFieldMin;

    TInt firstFieldMax;

    (STATIC_CAST(CEikMfneNumber*,Field(KFieldA)))->GetMinimumAndMaximum(firstFieldMin,firstFieldMax);

    TInt secondFieldMin;

    TInt secondFieldMax;

    (STATIC_CAST(CEikMfneNumber*,Field(KFieldB)))->GetMinimumAndMaximum(secondFieldMin,secondFieldMax);

    TInt thirdFieldMin;

    TInt thirdFieldMax;

    (STATIC_CAST(CEikMfneNumber*,Field(KFieldC)))->GetMinimumAndMaximum(thirdFieldMin,thirdFieldMax);

    TInt fourthFieldMin;

    TInt fourthFieldMax;

    (STATIC_CAST(CEikMfneNumber*,Field(KFieldD)))->GetMinimumAndMaximum(fourthFieldMin,fourthFieldMax);

	aMinimumFieldValues=TInetAddr(INET_ADDR((TUint32)firstFieldMin,

                                            (TUint32)secondFieldMin,

                                            (TUint32)thirdFieldMin,

                                            (TUint32)fourthFieldMin),

                                  0);

	aMaximumFieldValues=TInetAddr(INET_ADDR((TUint32)firstFieldMax,

                                            (TUint32)secondFieldMax,

                                            (TUint32)thirdFieldMax,

                                            (TUint32)fourthFieldMax),

                                  0);

	}

/**

 * Method for setting editor fields' minimum and maximum values.

 * Gets two parameters:

 * TInetAddr& aMinimumFieldValues - Reference to a TInetAddr struct defining the lower limits

 * of the editor fields.

 * IP editor fields.

 * TInetAddr& aMaximumFieldValues - Reference to a TInetAddr struct defining the upper limits

 * of the editor fields.

 * 

 */

EXPORT_C void CAknIpFieldEditor::SetMinimumAndMaximum(const TInetAddr& aMinimumFieldValues,

                                                      const TInetAddr& aMaximumFieldValues)

	{

    TUint8 minValueFieldA=0;

    TUint8 minValueFieldB=0;

    TUint8 minValueFieldC=0;

    TUint8 minValueFieldD=0;

    TUint8 maxValueFieldA=0;

    TUint8 maxValueFieldB=0;

    TUint8 maxValueFieldC=0;

    TUint8 maxValueFieldD=0;

    SplitAddressIntoFields(aMinimumFieldValues, minValueFieldA, minValueFieldB, minValueFieldC, minValueFieldD);

    SplitAddressIntoFields(aMaximumFieldValues, maxValueFieldA, maxValueFieldB, maxValueFieldC, maxValueFieldD);

    (STATIC_CAST(CEikMfneNumber*,Field(KFieldA)))->SetMinimumAndMaximum(minValueFieldA,maxValueFieldA,*Font());

    (STATIC_CAST(CEikMfneNumber*,Field(KFieldB)))->SetMinimumAndMaximum(minValueFieldB,maxValueFieldB,*Font());

    (STATIC_CAST(CEikMfneNumber*,Field(KFieldC)))->SetMinimumAndMaximum(minValueFieldC,maxValueFieldC,*Font());

    (STATIC_CAST(CEikMfneNumber*,Field(KFieldD)))->SetMinimumAndMaximum(minValueFieldD,maxValueFieldD,*Font());

    DrawNow();

	}

/**

 * Method takes a TInetAddr and returns 4 separate 8-bit unsigned fields

 * const TInetAddr& aAddress - Reference to a TInetAddr struct

 * 

 */

void CAknIpFieldEditor::SplitAddressIntoFields(

                                                const TInetAddr& aAddress,

                                                TUint8 &aFieldA,

                                                TUint8 &aFieldB,

                                                TUint8 &aFieldC,

                                                TUint8 &aFieldD) const

    {

    TUint32 temp=0;

    temp=((aAddress.Address())&KInetAddrNetMaskA)>>KInetAddrShiftA;

    aFieldA=(TUint8)temp;

    temp=((aAddress.Address())&KInetAddrNetMaskB&~KInetAddrNetMaskA)>>KInetAddrShiftB;

    aFieldB=(TUint8)temp;

    temp=((aAddress.Address())&KInetAddrNetMaskC&~KInetAddrNetMaskB)>>KInetAddrShiftC;

    aFieldC=(TUint8)temp;

    temp=(aAddress.Address())&~KInetAddrNetMaskC;

    aFieldD=(TUint8)temp;

    }

/**

 * Method for setting the editor fields dynamically.

 * Gets one parameter:

 * const TInetAddr& aAddress - Reference to a TInetAddr struct including the new address.

 * 

 */

EXPORT_C void CAknIpFieldEditor::SetAddress(const TInetAddr& aAddress)

	{

    TUint8 fieldA=0;

    TUint8 fieldB=0;

    TUint8 fieldC=0;

    TUint8 fieldD=0;

    SplitAddressIntoFields(aAddress, fieldA, fieldB, fieldC, fieldD);

    (STATIC_CAST(CEikMfneNumber*,Field(KFieldA)))->SetValue(fieldA,*Font());

	(STATIC_CAST(CEikMfneNumber*,Field(KFieldB)))->SetValue(fieldB,*Font());

    (STATIC_CAST(CEikMfneNumber*,Field(KFieldC)))->SetValue(fieldC,*Font());

    (STATIC_CAST(CEikMfneNumber*,Field(KFieldD)))->SetValue(fieldD,*Font());

    DrawNow();

	}

/**

 * Method for reading the editor value.

 * 

 */

EXPORT_C TInetAddr CAknIpFieldEditor::Address() const

	{

    // TE: The return value can not be a const reference because the

    // TInetAddress that is to be returned exists only withing this function.

    return TInetAddr(INET_ADDR((TUint8)(STATIC_CAST(CEikMfneNumber*,Field(KFieldA)))->Value(),

                               (TUint8)(STATIC_CAST(CEikMfneNumber*,Field(KFieldB)))->Value(),

                               (TUint8)(STATIC_CAST(CEikMfneNumber*,Field(KFieldC)))->Value(),

                               (TUint8)(STATIC_CAST(CEikMfneNumber*,Field(KFieldD)))->Value()),

                     0);

	}

/**

 * Method for constructing the control from resources.

 * Gets one parameter:

 * TResourceReader& aResourceReader - Reference to a resource reader associated to a

 * IP Field Editor control resource.

 * 

 */

EXPORT_C void CAknIpFieldEditor::ConstructFromResourceL(TResourceReader& aResourceReader)

	{

    TInetAddr minFieldValues=ReadIPAddress(aResourceReader);

	TInetAddr maxFieldValues=ReadIPAddress(aResourceReader);

    TUint32 flags=aResourceReader.ReadUint8();

	ConstructL(minFieldValues, maxFieldValues, minFieldValues, flags);

	}

/**

 * Method for reading an IP address from resources.

 * Gets one parameter:

 * TResourceReader& aResourceReader - Reference to a resource reader associated to the

 * IP address resource.

 * 

 */

EXPORT_C TInetAddr CAknIpFieldEditor::ReadIPAddress(TResourceReader& aResourceReader)

	{

	TUint8 firstField=(TUint8)aResourceReader.ReadUint8();

	TUint8 secondField=(TUint8)aResourceReader.ReadUint8();

	TUint8 thirdField=(TUint8)aResourceReader.ReadUint8();

    TUint8 fourthField=(TUint8)aResourceReader.ReadUint8();

	return TInetAddr(INET_ADDR((TUint8)firstField,

                               (TUint8)secondField,

                               (TUint8)thirdField,

                               (TUint8)fourthField),

                     0);

	}

/**

 * Method for handling key events.

 * 

 */

EXPORT_C TKeyResponse CAknIpFieldEditor::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

	{

    TKeyResponse response=EKeyWasNotConsumed;

    TKeyEvent event(aKeyEvent);

    if(aType==EEventKey && event.iCode=='.') // If delimiter key has been pressed. In IPv4 delimiter is always a dot.

        event.iCode=EKeyRightArrow;

    response=CEikMfne::OfferKeyEventL(event, aType);

    return response;

	}

EXPORT_C void CAknIpFieldEditor::HandlePointerEventL(const TPointerEvent& aPointerEvent) 

    { 

    CEikMfne::HandlePointerEventL(aPointerEvent); 

    }	

EXPORT_C void* CAknIpFieldEditor::ExtensionInterface( TUid /*aInterface*/ )

    {

    return NULL;

    }

EXPORT_C void CAknIpFieldEditor::CEikMfne_Reserved()

	{

	}