--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/AvKon/src/AknNumEdwin.cpp	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,302 @@
+/*
+* 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:   Numeric Editor derived from Uikon's CEikEdwin
+*
+*
+*/
+
+
+// INCLUDES
+
+#include <barsread.h>  // Resource reading
+
+#include <eikon.hrh>
+#include <eikctl.rsg>
+#include <eikenv.h>
+
+#include "AknNumEdwin.h"
+#include "avkon.hrh"
+#include "AknDef.h"
+
+#include <aknenv.h>
+#include <AknSettingCache.h>
+#include <numberconversion.h>
+#include <AknUtils.h>
+
+	_LIT(KEmptyText, "" );
+
+// INTERNAL CLASS DEFINITIONS
+
+
+// CLASS IMPLEMENTATIONS
+
+
+EXPORT_C CAknIntegerEdwin* CAknIntegerEdwin::NewL( TInt aMin, TInt aMax, TInt aTextLimit )
+    {
+    CAknIntegerEdwin* self = new ( ELeave ) CAknIntegerEdwin;
+    CleanupStack::PushL( self );
+    self->ConstructL( aMin, aMax, aTextLimit);
+    CleanupStack::Pop();
+    return self;
+    }
+
+EXPORT_C void CAknIntegerEdwin::ConstructFromResourceL(TResourceReader& aReader)
+	{
+	const TInt edwinFlags=0; 
+
+	CalculateWidth(20);  // overridden by later layout code
+
+	TInt textLimit = aReader.ReadInt16();
+	TInt minValue = aReader.ReadInt32();
+	TInt maxValue = aReader.ReadInt32();
+	iUnsetValue = aReader.ReadInt32();
+
+// possible extensions
+	TInt dummy =  aReader.ReadInt32();
+	dummy = aReader.ReadInt32();
+
+	CommonConstructL(minValue, maxValue, textLimit, edwinFlags, iUnsetValue);
+	}
+
+EXPORT_C void CAknIntegerEdwin::ConstructL(TInt aMin, TInt aMax, TInt aTextLimit)
+	{
+	const TInt edwinFlags=0; 
+
+	CommonConstructL(aMin, aMax, aTextLimit, edwinFlags, KMaxTInt);
+	}
+
+void CAknIntegerEdwin::CommonConstructL(TInt aMin, TInt aMax, TInt aMaxChars, TInt aFlags, TInt aUnset)
+	{
+	iDigitType = EDigitTypeWestern;
+
+	const TInt numberOfLines=1;
+
+	// Enforce maximum number of digits for numeric Edwin - Otherwise CEikEdwin treats maxlimit of 0 as no limit.
+	TInt maxLimit(aMaxChars);
+	if( (maxLimit==0) || (maxLimit>EAknMaxIntegerDigits) )
+		maxLimit = EAknMaxIntegerDigits;
+
+	CEikEdwin::ConstructL(aFlags, aMaxChars, maxLimit, numberOfLines);
+	SetMinimumIntegerValue(aMin);
+	SetMaximumIntegerValue(aMax);
+
+	SetAknEditorCase(EAknEditorUpperCase);
+	SetAknEditorAllowedInputModes(EAknEditorNumericInputMode);
+	SetAknEditorInputMode(EAknEditorNumericInputMode);
+	SetAknEditorSpecialCharacterTable(0);
+	SetAknEditorFlags(EAknEditorFlagFixedCase | EAknEditorFlagNoT9);
+	// Only plain numbers
+	// The EAknEditorPlainNumberModeKeymap does not support - -sign so
+	// we have to use the converter mapping
+	SetAknEditorNumericKeymap(EAknEditorConverterNumberModeKeymap);
+
+	iUnsetValue = aUnset;
+	SetValueL(iUnsetValue);
+	RefreshFromLocale();
+	}
+
+EXPORT_C void CAknIntegerEdwin::SetValueL( TInt aValue )
+	{
+	if ( aValue != iUnsetValue )
+		{
+		HBufC* formatBuffer = HBufC::NewMaxLC( EAknMaxIntegerDigits );
+		TPtr formatPtr = formatBuffer->Des();
+		formatPtr.Format(KAknIntegerFormat, aValue);
+		
+        // Latin only editor doesn't need conversion
+        if ( !( AknEdwinFlags() & EAknEditorFlagLatinInputModesOnly ) )
+            {
+            NumberConversion::ConvertDigits(formatPtr, iDigitType);
+            }
+
+		SetTextL( &formatPtr );
+		CleanupStack::Pop(); // formatBuffer
+		delete formatBuffer;
+		}
+	else
+		{
+		SetTextL( &KEmptyText );
+		}
+	}
+
+EXPORT_C TKeyResponse CAknIntegerEdwin::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
+	{
+	TKeyEvent modifiedKeyEvent(aKeyEvent);
+	TEventCode modifiedEventCode(aType);
+    
+    // FEP already should input converted numbers, so there's no need for this.
+	//MapKeyEvent(modifiedKeyEvent, modifiedEventCode, iDigitType);
+	return CAknNumericEdwin::OfferKeyEventL(modifiedKeyEvent, modifiedEventCode);
+	}
+
+
+EXPORT_C CAknIntegerEdwin::TValidationStatus CAknIntegerEdwin::GetTextAsInteger( TInt& aValue )
+	{
+
+	TValidationStatus state = EValueNotParsed;
+
+	// Create a normalised western version of the string.
+	TBuf<EAknMaxIntegerDigits> normalisedText;
+	GetText(normalisedText);
+	NumberConversion::ConvertDigits(normalisedText, EDigitTypeWestern);
+
+	// Use TextLength() for this test, because stray paragraph marks may lurk in the TPtrC buffer
+	if ( TextLength() == 0 )
+		{
+		state = EEmpty;
+		aValue = iUnsetValue;
+		}
+	else 
+		{
+		TLex lex( normalisedText );
+
+		if ( lex.Val(aValue) == KErrNone && lex.Remainder().Length() == 0 )
+			{
+			state = EValueValid;
+
+			// Test the range:
+			if ( aValue < iMinimumValue )
+				state = EValueTooSmall;
+			else if ( aValue > iMaximumValue )
+				state = EValueTooLarge;
+			}
+		else
+			{
+			state = EValueNotParsed;
+			aValue = iUnsetValue;
+			}
+
+		}
+
+	return state;
+
+	}
+
+
+
+EXPORT_C void CAknIntegerEdwin::SetMinimumIntegerValue( TInt aMinimum )
+	{
+	iMinimumValue = aMinimum;
+	}
+
+EXPORT_C void CAknIntegerEdwin::SetMaximumIntegerValue( TInt aMaximum )
+	{
+	iMaximumValue = aMaximum;
+	}
+
+EXPORT_C void CAknIntegerEdwin::SetUnsetValue( TInt aUnsetValue )
+	{
+	iUnsetValue = aUnsetValue;
+	}
+
+
+EXPORT_C void CAknIntegerEdwin::PrepareForFocusLossL()
+	{
+	// TInt resId = 0;
+	TInt value;
+	TValidationStatus state = GetTextAsInteger( value );
+
+	switch (state )
+		{
+		case EValueValid:
+		break;
+
+		case EEmpty:
+		break;
+
+		case EValueTooSmall:
+		// resId=R_EIK_TBUF_FNUMBER_BELOW_MIN;
+		value = iMinimumValue;
+		break;
+
+		case EValueTooLarge:
+		// resId=R_EIK_TBUF_FNUMBER_ABOVE_MAX;
+		value = iMaximumValue;
+		break;
+
+		case EValueNotParsed:
+
+		break;
+
+		default:
+		break;
+		}
+
+	}
+
+EXPORT_C void CAknIntegerEdwin::HandleResourceChange(TInt aType)
+	{
+	if(aType==KEikInputLanguageChange)
+		{
+		RefreshFromLocale();
+		return;
+		}
+	CAknNumericEdwin::HandleResourceChange(aType);
+	}
+
+void CAknIntegerEdwin::RefreshFromLocale()
+	{
+	iDigitType = AknTextUtils::NumericEditorDigitType();
+
+	TInt value;
+	if( GetTextAsInteger(value) != EValueValid)
+		return;
+
+	TRAP_IGNORE(SetValueL(value) ); // shouldn't leave with OOM because text string is the same size as previous.
+	}
+	
+EXPORT_C void CAknIntegerEdwin::HandlePointerEventL(const TPointerEvent& aPointerEvent) 
+    { 
+    CAknNumericEdwin::HandlePointerEventL(aPointerEvent); 
+    }	
+
+EXPORT_C void* CAknIntegerEdwin::ExtensionInterface( TUid /*aInterface*/ ) 
+    { 
+    return NULL;
+    }
+
+EXPORT_C void CAknIntegerEdwin::Reserved_3()
+	{
+	}
+    
+EXPORT_C TBool CAknIntegerEdwin::CheckNumber()
+    {
+    
+    TInt value;
+	TValidationStatus state = GetTextAsInteger( value );
+
+	switch (state )
+		{
+		case EValueTooSmall:
+		    {
+		    TRAP_IGNORE( SetValueL( iMinimumValue ) );
+		    TRAP_IGNORE( SelectAllL() );
+		    DrawDeferred();
+		    return EFalse;
+		    }
+		case EValueTooLarge:
+            {
+		    TRAP_IGNORE( SetValueL( iMaximumValue ) );
+        	TRAP_IGNORE( SelectAllL() );
+		    DrawDeferred();
+		    return EFalse;
+            }	
+		default:
+		break;
+		}
+		
+    return ETrue;
+    }
+    
+// End of File