Implemented stepping logic on GUIFloatField and GUIIntField

Source/BansheeEditor/Include/BsGUIFloatField.h

@@ -31,14 +31,20 @@ namespace BansheeEngine
 		float getValue() const { return mValue; }
 
 		/**	Sets a new value in the input field. */
-		void setValue(float value);
+		float setValue(float value);
 
 		/**
-		 * Sets a minimum and maximum allow values in the input field. Set to large negative/positive values if you don't
+		 * Sets a minimum and maximum allowed values in the input field. Set to large negative/positive values if you don't
 		 * require clamping.
 		 */
 		void setRange(float min, float max);
 
+		/**	Sets the minimum change allowed for the input field. */
+		void setStep(float step);
+
+		/** Returns the minimum change allowed for the input field. */
+		float getStep() const{ return mStep; }
+
 		/**	Checks is the input field currently active. */
 		bool hasInputFocus() const { return mHasInputFocus; }
 
@@ -96,6 +102,7 @@ namespace BansheeEngine
 		INT32 mLastDragPos;
 		float mMinValue;
 		float mMaxValue;
+		float mStep;
 		bool mIsDragging;
 		bool mHasInputFocus;
 	};

Source/BansheeEditor/Include/BsGUIIntField.h

@@ -31,7 +31,7 @@ namespace BansheeEngine
 		INT32 getValue() const { return mValue; }
 
 		/**	Sets a new value in the input field. */
-		void setValue(INT32 value);
+		INT32 setValue(INT32 value);
 
 		/**
 		 * Sets a minimum and maximum allow values in the input field. Set to large negative/positive values if you don't
@@ -39,6 +39,12 @@ namespace BansheeEngine
 		 */
 		void setRange(INT32 min, INT32 max);
 
+		/**	Sets the minimum change allowed for the input field. */
+		void setStep(INT32 step);
+
+		/** Returns the minimum change allowed for the input field. */
+		INT32 getStep() const { return mStep; }
+
 		/**	Checks is the input field currently active. */
 		bool hasInputFocus() const { return mHasInputFocus; }
 
@@ -96,6 +102,7 @@ namespace BansheeEngine
 		INT32 mLastDragPos;
 		INT32 mMinValue;
 		INT32 mMaxValue;
+		INT32 mStep;
 		bool mIsDragging;
 		bool mIsDragCursorSet;
 		bool mHasInputFocus;

Source/BansheeEditor/Source/BsGUIFloatField.cpp

@@ -21,7 +21,7 @@ namespace BansheeEngine
 		const String& style, const GUIDimensions& dimensions, bool withLabel)
 		: TGUIField(dummy, labelContent, labelWidth, style, dimensions, withLabel), mInputBox(nullptr), mValue(0.0f)
 		, mLastDragPos(0), mMinValue(std::numeric_limits<float>::lowest()), mMaxValue(std::numeric_limits<float>::max())
-		, mIsDragging(false), mHasInputFocus(false)
+		, mIsDragging(false), mHasInputFocus(false), mStep(0.0f)
 	{
 		mInputBox = GUIInputBox::create(false, GUIOptions(GUIOption::flexibleWidth()), getSubStyleName(getInputStyleType()));
 		mInputBox->setFilter(&GUIFloatField::floatFilter);
@@ -134,16 +134,18 @@ namespace BansheeEngine
 		return false;
 	}
 
-	void GUIFloatField::setValue(float value)
+	float GUIFloatField::setValue(float value)
 	{
 		mValue = Math::clamp(value, mMinValue, mMaxValue);
-
+		if (mStep != 0.0f)
+			mValue = mValue - fmod(mValue, mStep);
 		// Only update with new value if it actually changed, otherwise
 		// problems can occur when user types in "0." and the field
 		// updates back to "0" effectively making "." unusable
 		float curValue = parseFloat(mInputBox->getText());
 		if (mValue != curValue)
 			mInputBox->setText(toWString(mValue));
+		return mValue;
 	}
 
 	void GUIFloatField::setRange(float min, float max)
@@ -152,6 +154,11 @@ namespace BansheeEngine
 		mMaxValue = max;
 	}
 
+	void GUIFloatField::setStep(float step) 
+	{
+		mStep = step;
+	}
+
 	void GUIFloatField::setTint(const Color& color)
 	{
 		if (mLabel != nullptr)
@@ -165,7 +172,7 @@ namespace BansheeEngine
 		setValue(value);
 
 		if(triggerEvent)
-			onValueChanged(value);
+			onValueChanged(mValue);
 	}
 
 	const String& GUIFloatField::getGUITypeName()

Source/BansheeEditor/Source/BsGUIIntField.cpp

@@ -22,7 +22,7 @@ namespace BansheeEngine
 		const String& style, const GUIDimensions& dimensions, bool withLabel)
 		: TGUIField(dummy, labelContent, labelWidth, style, dimensions, withLabel), mInputBox(nullptr), mValue(0)
 		, mLastDragPos(0), mMinValue(std::numeric_limits<INT32>::lowest())
-		, mMaxValue(std::numeric_limits<INT32>::max()), mIsDragging(false), mIsDragCursorSet(false), mHasInputFocus(false)
+		, mMaxValue(std::numeric_limits<INT32>::max()), mIsDragging(false), mIsDragCursorSet(false), mHasInputFocus(false), mStep(1)
 	{
 		mInputBox = GUIInputBox::create(false, GUIOptions(GUIOption::flexibleWidth()), getSubStyleName(getInputStyleType()));
 		mInputBox->setFilter(&GUIIntField::intFilter);
@@ -160,16 +160,18 @@ namespace BansheeEngine
 		mInputBox->setStyle(getSubStyleName(getInputStyleType()));
 	}
 
-	void GUIIntField::setValue(INT32 value)
+	INT32 GUIIntField::setValue(INT32 value)
 	{
 		mValue = Math::clamp(value, mMinValue, mMaxValue);
-
+		if (mStep != 0)
+			mValue = mValue - fmod(mValue, mStep);
 		// Only update with new value if it actually changed, otherwise
 		// problems can occur when user types in "0." and the field
 		// updates back to "0" effectively making "." unusable
 		float curValue = parseFloat(mInputBox->getText());
 		if (mValue != curValue)
 			mInputBox->setText(toWString(mValue));
+		return mValue;
 	}
 
 	void GUIIntField::setRange(INT32 min, INT32 max)
@@ -178,6 +180,11 @@ namespace BansheeEngine
 		mMaxValue = max;
 	}
 
+	void GUIIntField::setStep(INT32 step)
+	{
+		mStep = step;
+	}
+
 	void GUIIntField::setTint(const Color& color)
 	{
 		if (mLabel != nullptr)
@@ -191,7 +198,7 @@ namespace BansheeEngine
 		setValue(value);
 
 		if (triggerEvent)
-			onValueChanged(value);
+			onValueChanged(mValue);
 	}
 
 	const String& GUIIntField::getGUITypeName()

Source/MBansheeEditor/GUI/GUIFloatField.cs

@@ -40,6 +40,19 @@ namespace BansheeEditor
             set { Internal_SetValue(mCachedPtr, value); }
         }
 
+        /// <summary>
+        /// Minimum change of the field
+        /// </summary>
+        public float Step
+        {
+            get
+            {
+                return Internal_GetStep(mCachedPtr);
+            }
+
+            set { Internal_SetStep(mCachedPtr, value); }
+        }
+
         /// <summary>
         /// Checks does the element currently has input focus. Input focus means the element has an input caret displayed
         /// and will accept input from the keyboard.
@@ -139,6 +152,12 @@ namespace BansheeEditor
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_SetRange(IntPtr nativeInstance, float min, float max);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetStep(IntPtr nativeInstance, float step);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern float Internal_GetStep(IntPtr nativeInstance);
     }
 
     /** @} */

Source/MBansheeEditor/GUI/GUIIntField.cs

@@ -40,6 +40,19 @@ namespace BansheeEditor
             set { Internal_SetValue(mCachedPtr, value); }
         }
 
+        /// <summary>
+        /// Minimum change of the field
+        /// </summary>
+        public int Step
+        {
+            get
+            {
+                return Internal_GetStep(mCachedPtr);
+            }
+
+            set { Internal_SetStep(mCachedPtr, value);}
+        }
+
         /// <summary>
         /// Checks does the element currently has input focus. Input focus means the element has an input caret displayed
         /// and will accept input from the keyboard.
@@ -129,7 +142,7 @@ namespace BansheeEditor
         private static extern void Internal_GetValue(IntPtr nativeInstance, out int value);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetValue(IntPtr nativeInstance, int value);
+        private static extern int Internal_SetValue(IntPtr nativeInstance, int value);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_HasInputFocus(IntPtr nativeInstance, out bool value);
@@ -139,6 +152,12 @@ namespace BansheeEditor
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_SetTint(IntPtr nativeInstance, ref Color color);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetStep(IntPtr nativeInstance, int step);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int Internal_GetStep(IntPtr nativeInstance);
     }
 
     /** @} */

Source/SBansheeEditor/Include/BsScriptGUIFloatField.h

@@ -42,10 +42,12 @@ namespace BansheeEngine
 			MonoString* style, MonoArray* guiOptions, bool withTitle);
 
 		static void internal_getValue(ScriptGUIFloatField* nativeInstance, float* output);
-		static void internal_setValue(ScriptGUIFloatField* nativeInstance, float value);
+		static float internal_setValue(ScriptGUIFloatField* nativeInstance, float value);
 		static void internal_hasInputFocus(ScriptGUIFloatField* nativeInstance, bool* output);
 		static void internal_setTint(ScriptGUIFloatField* nativeInstance, Color* color);
 		static void internal_setRange(ScriptGUIFloatField* nativeInstance, float min, float max);
+		static void internal_setStep(ScriptGUIFloatField* nativeInstance, float step);
+		static INT32 internal_getStep(ScriptGUIFloatField* nativeInstance);
 
 		typedef void(__stdcall *OnChangedThunkDef) (MonoObject*, float, MonoException**);
 		typedef void(__stdcall *OnConfirmedThunkDef) (MonoObject*, MonoException**);

Source/SBansheeEditor/Include/BsScriptGUIIntField.h

@@ -42,10 +42,12 @@ namespace BansheeEngine
 			MonoString* style, MonoArray* guiOptions, bool withTitle);
 
 		static void internal_getValue(ScriptGUIIntField* nativeInstance, INT32* output);
-		static void internal_setValue(ScriptGUIIntField* nativeInstance, INT32 value);
+		static INT32 internal_setValue(ScriptGUIIntField* nativeInstance, INT32 value);
 		static void internal_hasInputFocus(ScriptGUIIntField* nativeInstance, bool* output);
 		static void internal_setRange(ScriptGUIIntField* nativeInstance, INT32 min, INT32 max);
 		static void internal_setTint(ScriptGUIIntField* nativeInstance, Color* color);
+		static void internal_setStep(ScriptGUIIntField* nativeInstance, INT32 step);
+		static INT32 internal_getStep(ScriptGUIIntField* nativeInstance);
 
 		typedef void (__stdcall *OnChangedThunkDef) (MonoObject*, INT32, MonoException**);
 		typedef void(__stdcall *OnConfirmedThunkDef) (MonoObject*, MonoException**);

Source/SBansheeEditor/Source/BsScriptGUIFloatField.cpp

@@ -32,6 +32,8 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_HasInputFocus", &ScriptGUIFloatField::internal_hasInputFocus);
 		metaData.scriptClass->addInternalCall("Internal_SetTint", &ScriptGUIFloatField::internal_setTint);
 		metaData.scriptClass->addInternalCall("Internal_SetRange", &ScriptGUIFloatField::internal_setRange);
+		metaData.scriptClass->addInternalCall("Internal_SetStep", &ScriptGUIFloatField::internal_setStep);
+		metaData.scriptClass->addInternalCall("Internal_GetStep", &ScriptGUIFloatField::internal_getStep);
 
 		onChangedThunk = (OnChangedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnChanged", 1)->getThunk();
 		onConfirmedThunk = (OnConfirmedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnConfirmed", 0)->getThunk();
@@ -72,7 +74,7 @@ namespace BansheeEngine
 		*output = floatField->getValue();
 	}
 
-	void ScriptGUIFloatField::internal_setValue(ScriptGUIFloatField* nativeInstance, float value)
+	float ScriptGUIFloatField::internal_setValue(ScriptGUIFloatField* nativeInstance, float value)
 	{
 		GUIFloatField* floatField = static_cast<GUIFloatField*>(nativeInstance->getGUIElement());
 		return floatField->setValue(value);
@@ -84,16 +86,28 @@ namespace BansheeEngine
 		*output = floatField->hasInputFocus();
 	}
 
+	void ScriptGUIFloatField::internal_setRange(ScriptGUIFloatField* nativeInstance, float min, float max)
+	{
+		GUIFloatField* intField = static_cast<GUIFloatField*>(nativeInstance->getGUIElement());
+		intField->setRange(min, max);
+	}
+
 	void ScriptGUIFloatField::internal_setTint(ScriptGUIFloatField* nativeInstance, Color* color)
 	{
 		GUIFloatField* floatField = (GUIFloatField*)nativeInstance->getGUIElement();
 		floatField->setTint(*color);
 	}
 
-	void ScriptGUIFloatField::internal_setRange(ScriptGUIFloatField* nativeInstance, float min, float max)
+	void ScriptGUIFloatField::internal_setStep(ScriptGUIFloatField* nativeInstance, float step)
 	{
-		GUIFloatField* intField = static_cast<GUIFloatField*>(nativeInstance->getGUIElement());
-		intField->setRange(min, max);
+		GUIFloatField* floatField = (GUIFloatField*)nativeInstance->getGUIElement();
+		floatField->setStep(step);
+	}
+
+	INT32 ScriptGUIFloatField::internal_getStep(ScriptGUIFloatField* nativeInstance)
+	{
+		GUIFloatField* floatField = (GUIFloatField*)nativeInstance->getGUIElement();
+		return floatField->getStep();
 	}
 
 	void ScriptGUIFloatField::onChanged(MonoObject* instance, float newValue)

Source/SBansheeEditor/Source/BsScriptGUIIntField.cpp

@@ -32,6 +32,8 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_HasInputFocus", &ScriptGUIIntField::internal_hasInputFocus);
 		metaData.scriptClass->addInternalCall("Internal_SetRange", &ScriptGUIIntField::internal_setRange);
 		metaData.scriptClass->addInternalCall("Internal_SetTint", &ScriptGUIIntField::internal_setTint);
+		metaData.scriptClass->addInternalCall("Internal_SetStep", &ScriptGUIIntField::internal_setStep);
+		metaData.scriptClass->addInternalCall("Internal_GetStep", &ScriptGUIIntField::internal_getStep);
 
 		onChangedThunk = (OnChangedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnChanged", 1)->getThunk();
 		onConfirmedThunk = (OnConfirmedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnConfirmed", 0)->getThunk();
@@ -72,7 +74,7 @@ namespace BansheeEngine
 		*output = intField->getValue();
 	}
 
-	void ScriptGUIIntField::internal_setValue(ScriptGUIIntField* nativeInstance, INT32 value)
+	INT32 ScriptGUIIntField::internal_setValue(ScriptGUIIntField* nativeInstance, INT32 value)
 	{
 		GUIIntField* intField = static_cast<GUIIntField*>(nativeInstance->getGUIElement());
 		return intField->setValue(value);
@@ -96,6 +98,18 @@ namespace BansheeEngine
 		intField->setTint(*color);
 	}
 
+	void ScriptGUIIntField::internal_setStep(ScriptGUIIntField* nativeInstance, INT32 step)
+	{
+		GUIIntField* intField = (GUIIntField*)nativeInstance->getGUIElement();
+		intField->setStep(step);
+	}
+
+	INT32 ScriptGUIIntField::internal_getStep(ScriptGUIIntField* nativeInstance)
+	{
+		GUIIntField* intField = (GUIIntField*)nativeInstance->getGUIElement();
+		return intField->getStep();
+	}
+
 	void ScriptGUIIntField::onChanged(MonoObject* instance, INT32 newValue)
 	{
 		MonoUtil::invokeThunk(onChangedThunk, instance, newValue);