diff -r 000000000000 -r 2f259fa3e83a uifw/eikctl/src/aknipfed.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uifw/eikctl/src/aknipfed.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,379 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // 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() + { + } +