C#: Add GUIToggle

BansheeEngine/Include/BsGUIToggle.h

@@ -16,16 +16,16 @@ namespace BansheeEngine
 		static const CM::String& getGUITypeName();
 
 		static GUIToggle* create(GUIWidget& parent, const CM::HString& text, const GUIElementStyle* style = nullptr);
-		static GUIToggle* create(GUIWidget& parent, const GUIOptions& layoutOptions, const CM::HString& text, const GUIElementStyle* style = nullptr);
+		static GUIToggle* create(GUIWidget& parent, const CM::HString& text, const GUIOptions& layoutOptions, const GUIElementStyle* style = nullptr);
 	
 		static GUIToggle* create(GUIWidget& parent, const CM::HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIElementStyle* style = nullptr);
-		static GUIToggle* create(GUIWidget& parent, const GUIOptions& layoutOptions, const CM::HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIElementStyle* style = nullptr);
+		static GUIToggle* create(GUIWidget& parent, const CM::HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIOptions& layoutOptions, const GUIElementStyle* style = nullptr);
 
 		static GUIToggle* create(GUIWidget& parent, const GUIContent& content, const GUIElementStyle* style = nullptr);
-		static GUIToggle* create(GUIWidget& parent, const GUIOptions& layoutOptions, const GUIContent& content, const GUIElementStyle* style = nullptr);
+		static GUIToggle* create(GUIWidget& parent, const GUIContent& content, const GUIOptions& layoutOptions, const GUIElementStyle* style = nullptr);
 
 		static GUIToggle* create(GUIWidget& parent, const GUIContent& content, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIElementStyle* style = nullptr);
-		static GUIToggle* create(GUIWidget& parent, const GUIOptions& layoutOptions, const GUIContent& content, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIElementStyle* style = nullptr);
+		static GUIToggle* create(GUIWidget& parent, const GUIContent& content, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIOptions& layoutOptions, const GUIElementStyle* style = nullptr);
 
 		static std::shared_ptr<GUIToggleGroup> createToggleGroup();
 

BansheeEngine/Source/BsGUIToggle.cpp

@@ -40,9 +40,9 @@ namespace BansheeEngine
 		return create(parent, GUIContent(text), style);
 	}
 
-	GUIToggle* GUIToggle::create(GUIWidget& parent, const GUIOptions& layoutOptions, const HString& text, const GUIElementStyle* style)
+	GUIToggle* GUIToggle::create(GUIWidget& parent, const HString& text, const GUIOptions& layoutOptions, const GUIElementStyle* style)
 	{
-		return create(parent, layoutOptions, GUIContent(text), style);
+		return create(parent, GUIContent(text), layoutOptions, style);
 	}
 
 	GUIToggle* GUIToggle::create(GUIWidget& parent, const HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIElementStyle* style)
@@ -50,9 +50,9 @@ namespace BansheeEngine
 		return create(parent, GUIContent(text), toggleGroup, style);
 	}
 
-	GUIToggle* GUIToggle::create(GUIWidget& parent, const GUIOptions& layoutOptions, const HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIElementStyle* style)
+	GUIToggle* GUIToggle::create(GUIWidget& parent, const HString& text, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIOptions& layoutOptions, const GUIElementStyle* style)
 	{
-		return create(parent, layoutOptions, GUIContent(text), toggleGroup, style);
+		return create(parent, GUIContent(text), toggleGroup, layoutOptions, style);
 	}
 
 	GUIToggle* GUIToggle::create(GUIWidget& parent, const GUIContent& content, const GUIElementStyle* style)
@@ -66,7 +66,7 @@ namespace BansheeEngine
 		return new (cm_alloc<GUIToggle, PoolAlloc>()) GUIToggle(parent, style, content, nullptr, GUILayoutOptions::create(style));
 	}
 
-	GUIToggle* GUIToggle::create(GUIWidget& parent, const GUIOptions& layoutOptions, const GUIContent& content, const GUIElementStyle* style)
+	GUIToggle* GUIToggle::create(GUIWidget& parent, const GUIContent& content, const GUIOptions& layoutOptions, const GUIElementStyle* style)
 	{
 		if(style == nullptr)
 		{
@@ -88,7 +88,7 @@ namespace BansheeEngine
 		return new (cm_alloc<GUIToggle, PoolAlloc>()) GUIToggle(parent, style, content, toggleGroup, GUILayoutOptions::create(style));
 	}
 
-	GUIToggle* GUIToggle::create(GUIWidget& parent, const GUIOptions& layoutOptions, const GUIContent& content, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIElementStyle* style)
+	GUIToggle* GUIToggle::create(GUIWidget& parent, const GUIContent& content, std::shared_ptr<GUIToggleGroup> toggleGroup, const GUIOptions& layoutOptions, const GUIElementStyle* style)
 	{
 		if(style == nullptr)
 		{

CSharpWrap.txt

@@ -92,13 +92,6 @@ Eventually make all math classes templates that work on both doubles and floats.
 ----------------------------
 
 Implement:
- - GUIToggle
-  - onToggled
-  - ToggleGroup (?)
-
-  - ScrollArea is broken. Vertical scrollbar is not positioned properly.
-  - Clicking a holding a scroll bar then dragging the mouse out of window leaves the bar selected (sometimes)
-
 ScrollArea will likely need:
  C++/C#: always/never show horz/vert scroll bar
  C++/C#: optional styles for scroll bars
@@ -106,12 +99,11 @@ ScrollArea will likely need:
 
  Are GUI element instances kept anywhere? After GUI.Add* is called I think they're lost and destructed?
  I should create a handle in C++ code and only release it once Destroy is called?
-   - Then when GUIBase is destroyed all its child elements will remain.
-     - Not if in destructor I call Destroy
-   - Instead, register each GUI element with parent GUIBase? Then in managed Destroy also unregister it
-      - This means I need to iterate recursively over all elements and their children
-      - Means I probably also need "GetNumChildren", and "GetChild" methods.
- - TODO - Think about this
+   - Creating a child hierarchy of GUIElements (where each GUIElement holds references to all its children) can work
+    - Destroy() is then called recursively from parent element
+    - Each element will then also have "GetNumChildren", and "GetChild" methods
+    - Also consider adding GUIElement.Move(GUILayout), GUIElement.Move(GUILayout, int position),
+      GUIElement.Move(int offset)
 
  - GUISkin
    - List of properties with all common styles, like .button, .label

MBansheeEngine/GUILayout.cs

@@ -30,6 +30,36 @@ namespace BansheeEngine
             return new GUIButton(this, content, null, options);
         }
 
+        public GUIToggle AddToggle(GUIContent content, GUIElementStyle style, params GUIOption[] options)
+        {
+            return new GUIToggle(this, content, null, style, options);
+        }
+
+        public GUIToggle AddToggle(GUIContent content, GUIElementStyle style)
+        {
+            return new GUIToggle(this, content, null, style, new GUIOption[0]);
+        }
+
+        public GUIToggle AddToggle(GUIContent content, params GUIOption[] options)
+        {
+            return new GUIToggle(this, content, null, null, options);
+        }
+
+        public GUIToggle AddToggle(GUIContent content, GUIToggleGroup toggleGroup, GUIElementStyle style, params GUIOption[] options)
+        {
+            return new GUIToggle(this, content, toggleGroup, style, options);
+        }
+
+        public GUIToggle AddToggle(GUIContent content, GUIToggleGroup toggleGroup, GUIElementStyle style)
+        {
+            return new GUIToggle(this, content, toggleGroup, style, new GUIOption[0]);
+        }
+
+        public GUIToggle AddToggle(GUIContent content, GUIToggleGroup toggleGroup, params GUIOption[] options)
+        {
+            return new GUIToggle(this, content, toggleGroup, null, options);
+        }
+
         public GUITexture AddTexture(SpriteTexture texture, GUIImageScaleMode scale, GUIElementStyle style, params GUIOption[] options)
         {
             return new GUITexture(this, texture, scale, style, options);

MBansheeEngine/GUIToggle.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace BansheeEngine
+{
+    public sealed class GUIToggle : GUIElement
+    {
+        public delegate void OnClickDelegate();
+        public delegate void OnHoverDelegate();
+        public delegate void OnOutDelegate();
+        public delegate void OnToggleDelegate(bool toggled);
+
+        public event OnClickDelegate OnClick;
+        public event OnHoverDelegate OnHover;
+        public event OnOutDelegate OnOut;
+        public event OnToggleDelegate OnToggled;
+
+        internal GUIToggle(GUILayout parentLayout, GUIContent content, GUIToggleGroup toggleGroup, GUIElementStyle style, params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, parentLayout, content, toggleGroup, style, options);
+        }
+
+        public void SetContent(GUIContent content)
+        {
+            Internal_SetContent(mCachedPtr, content);
+        }
+
+        public void ToggleOn()
+        {
+            Internal_ToggleOn();
+        }
+
+        public void ToggleOff()
+        {
+            Internal_ToggleOff();
+        }
+
+        private void DoOnClick()
+        {
+            if (OnClick != null)
+                OnClick();
+        }
+
+        private void DoOnHover()
+        {
+            if (OnHover != null)
+                OnHover();
+        }
+
+        private void DoOnOut()
+        {
+            if (OnOut != null)
+                OnOut();
+        }
+
+        private void DoOnToggled(bool toggled)
+        {
+            if (OnToggled != null)
+                OnToggled(toggled);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(GUIToggle instance, GUILayout layout, GUIContent content, 
+            GUIToggleGroup toggleGroup, GUIElementStyle style, GUIOption[] options);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetContent(IntPtr nativeInstance, GUIContent content);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_ToggleOn();
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_ToggleOff();
+    }
+}

MBansheeEngine/GUIToggleGroup.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace BansheeEngine
+{
+    public sealed class GUIToggleGroup : ScriptObject
+    {
+        public GUIToggleGroup()
+        {
+            Internal_CreateInstance(this);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(GUIToggleGroup instance);
+    }
+}

MBansheeEngine/MBansheeEngine.csproj

@@ -64,6 +64,8 @@
     <Compile Include="GUISkin.cs" />
     <Compile Include="GUISpace.cs" />
     <Compile Include="GUITexture.cs" />
+    <Compile Include="GUIToggle.cs" />
+    <Compile Include="GUIToggleGroup.cs" />
     <Compile Include="LocString.cs" />
     <Compile Include="MathEx.cs" />
     <Compile Include="Matrix3.cs" />

SBansheeEngine/Include/BsScriptGUIToggle.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ScriptGUIToggle : public ScriptObject<ScriptGUIToggle>
+	{
+	public:
+		static void initMetaData();
+
+		GUIToggle* getInternalValue() const { return mToggle; }
+		void* getNativeRaw() const { return mToggle; }
+
+	private:
+		static void internal_createInstance(MonoObject* instance, MonoObject* parentLayout, MonoObject* content, 
+			MonoObject* toggleGroup, MonoObject* style, MonoArray* guiOptions);
+		static void internal_destroyInstance(ScriptGUIToggle* nativeInstance);
+		static void internal_setContent(ScriptGUIToggle* nativeInstance, MonoObject* content);
+		static void internal_toggleOn(ScriptGUIToggle* nativeInstance);
+		static void internal_toggleOff(ScriptGUIToggle* nativeInstance);
+
+		static void internal_destroy(ScriptGUIToggle* nativeInstance);
+		static void internal_disable(ScriptGUIToggle* nativeInstance);
+		static void internal_enable(ScriptGUIToggle* nativeInstance);
+
+		static void initRuntimeData();
+
+		static void onClick(MonoObject* instance);
+		static void onHover(MonoObject* instance);
+		static void onOut(MonoObject* instance);
+		static void onToggled(MonoObject* instance, bool toggled);
+
+		ScriptGUIToggle(GUIToggle* toggle);
+
+		GUIToggle* mToggle;
+
+		typedef void (__stdcall *OnClickThunkDef) (MonoObject*, MonoException**);
+		typedef void (__stdcall *OnHoverThunkDef) (MonoObject*, MonoException**);
+		typedef void (__stdcall *OnOutThunkDef) (MonoObject*, MonoException**);
+		typedef void (__stdcall *OnToggledThunkDef) (MonoObject*, bool toggled, MonoException**);
+
+		static OnClickThunkDef onClickThunk;
+		static OnHoverThunkDef onHoverThunk;
+		static OnOutThunkDef onOutThunk;
+		static OnToggledThunkDef onToggledThunk;
+	};
+}

SBansheeEngine/Include/BsScriptGUIToggleGroup.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ScriptGUIToggleGroup : public ScriptObject<ScriptGUIToggleGroup>
+	{
+	public:
+		static void initMetaData();
+
+		std::shared_ptr<GUIToggleGroup> getInternalValue() const { return mToggleGroup; }
+		void* getNativeRaw() const { return mToggleGroup.get(); }
+
+	private:
+		static void internal_createInstance(MonoObject* instance);
+		static void internal_destroyInstance(ScriptGUIToggleGroup* nativeInstance);
+
+		static void initRuntimeData();
+
+		ScriptGUIToggleGroup(const std::shared_ptr<GUIToggleGroup>& toggleGroup);
+
+		std::shared_ptr<GUIToggleGroup> mToggleGroup;
+	};
+}

SBansheeEngine/SBansheeEngine.vcxproj

@@ -241,6 +241,8 @@
     <ClInclude Include="Include\BsScriptGUIListBox.h" />
     <ClInclude Include="Include\BsScriptGUIScrollArea.h" />
     <ClInclude Include="Include\BsScriptGUITexture.h" />
+    <ClInclude Include="Include\BsScriptGUIToggle.h" />
+    <ClInclude Include="Include\BsScriptGUIToggleGroup.h" />
     <ClInclude Include="Include\BsScriptHString.h" />
     <ClInclude Include="Include\BsScriptMacros.h" />
     <ClInclude Include="Include\BsScriptObject.h" />
@@ -264,6 +266,8 @@
     <ClCompile Include="Source\BsScriptGUIListBox.cpp" />
     <ClCompile Include="Source\BsScriptGUIScrollArea.cpp" />
     <ClCompile Include="Source\BsScriptGUITexture.cpp" />
+    <ClCompile Include="Source\BsScriptGUIToggle.cpp" />
+    <ClCompile Include="Source\BsScriptGUIToggleGroup.cpp" />
     <ClCompile Include="Source\BsScriptHString.cpp" />
     <ClCompile Include="Source\BsScriptGUIInputBox.cpp" />
     <ClCompile Include="Source\BsScriptSpriteTexture.cpp" />

SBansheeEngine/SBansheeEngine.vcxproj.filters

@@ -81,6 +81,12 @@
     <ClInclude Include="Include\BsScriptGUIListBox.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BsScriptGUIToggleGroup.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptGUIToggle.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsScriptTexture2D.cpp">
@@ -143,5 +149,11 @@
     <ClCompile Include="Source\BsScriptGUIListBox.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\BsScriptGUIToggleGroup.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptGUIToggle.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

SBansheeEngine/Source/BsScriptGUIToggle.cpp

@@ -0,0 +1,163 @@
+#include "BsScriptGUIToggle.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoMethod.h"
+#include "BsSpriteTexture.h"
+#include "BsMonoUtil.h"
+#include "BsGUILayout.h"
+#include "BsGUIToggle.h"
+#include "BsGUIToggleGroup.h"
+#include "BsGUIOptions.h"
+#include "BsScriptGUIToggleGroup.h"
+#include "BsScriptGUIElementStyle.h"
+#include "BsScriptGUILayout.h"
+#include "BsScriptGUIArea.h"
+#include "BsScriptHString.h"
+#include "BsScriptGUIContent.h"
+
+using namespace CamelotFramework;
+
+namespace BansheeEngine
+{
+	ScriptGUIToggle::OnClickThunkDef ScriptGUIToggle::onClickThunk;
+	ScriptGUIToggle::OnHoverThunkDef ScriptGUIToggle::onHoverThunk;
+	ScriptGUIToggle::OnOutThunkDef ScriptGUIToggle::onOutThunk;
+	ScriptGUIToggle::OnToggledThunkDef ScriptGUIToggle::onToggledThunk;
+
+	ScriptGUIToggle::ScriptGUIToggle(GUIToggle* toggle)
+		:mToggle(toggle)
+	{
+
+	}
+
+	void ScriptGUIToggle::initMetaData()
+	{
+		metaData = ScriptMeta("MBansheeEngine", "BansheeEngine", "GUIToggle", &ScriptGUIToggle::initRuntimeData);
+
+		MonoManager::registerScriptType(&metaData);
+	}
+
+	void ScriptGUIToggle::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGUIToggle::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_DestroyInstance", &ScriptGUIToggle::internal_destroyInstance);
+		metaData.scriptClass->addInternalCall("Internal_SetContent", &ScriptGUIToggle::internal_setContent);
+		metaData.scriptClass->addInternalCall("Internal_ToggleOn", &ScriptGUIToggle::internal_toggleOn);
+		metaData.scriptClass->addInternalCall("Internal_ToggleOff", &ScriptGUIToggle::internal_toggleOff);
+
+		metaData.scriptClass->addInternalCall("Internal_Destroy", &ScriptGUIToggle::internal_destroy);
+		metaData.scriptClass->addInternalCall("Internal_Enable", &ScriptGUIToggle::internal_enable);
+		metaData.scriptClass->addInternalCall("Internal_Disable", &ScriptGUIToggle::internal_disable);
+
+		onClickThunk = (OnClickThunkDef)metaData.scriptClass->getMethod("DoOnClick").getThunk();
+		onHoverThunk = (OnHoverThunkDef)metaData.scriptClass->getMethod("DoOnHover").getThunk();
+		onOutThunk = (OnOutThunkDef)metaData.scriptClass->getMethod("DoOnOut").getThunk();
+		onToggledThunk = (OnToggledThunkDef)metaData.scriptClass->getMethod("DoOnToggled", 1).getThunk();
+	}
+
+	void ScriptGUIToggle::internal_createInstance(MonoObject* instance, MonoObject* parentLayout, MonoObject* content, 
+		MonoObject* toggleGroup, MonoObject* style, MonoArray* guiOptions)
+	{
+		ScriptGUILayout* scriptLayout = ScriptGUILayout::toNative(parentLayout);
+		GUIOptions options;
+
+		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		for(UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+
+		GUIElementStyle* elemStyle = nullptr;
+		if(style != nullptr)
+			elemStyle = ScriptGUIElementStyle::toNative(style)->getInternalValue();
+
+		ScriptGUIToggleGroup* scriptToggleGroup = nullptr;
+		if(scriptToggleGroup != nullptr)
+			scriptToggleGroup = ScriptGUIToggleGroup::toNative(toggleGroup);
+
+		GUIContent nativeContent(ScriptGUIContent::getText(content), ScriptGUIContent::getImage(content), ScriptGUIContent::getTooltip(content));
+		GUIToggle* guiToggle = GUIToggle::create(scriptLayout->getParentWidget(), nativeContent, scriptToggleGroup->getInternalValue(), options, elemStyle);
+
+		guiToggle->onClick.connect(std::bind(&ScriptGUIToggle::onClick, instance));
+		guiToggle->onHover.connect(std::bind(&ScriptGUIToggle::onHover, instance));
+		guiToggle->onOut.connect(std::bind(&ScriptGUIToggle::onOut, instance));
+		guiToggle->onToggled.connect(std::bind(&ScriptGUIToggle::onToggled, instance, std::placeholders::_1));
+
+		GUILayout* nativeLayout = scriptLayout->getInternalValue();
+		nativeLayout->addElement(guiToggle);
+
+		ScriptGUIToggle* nativeInstance = new (cm_alloc<ScriptGUIToggle>()) ScriptGUIToggle(guiToggle);
+		nativeInstance->createInstance(instance);
+
+		metaData.thisPtrField->setValue(instance, nativeInstance);
+	}
+
+	void ScriptGUIToggle::internal_destroyInstance(ScriptGUIToggle* nativeInstance)
+	{
+		nativeInstance->destroyInstance();
+		cm_delete(nativeInstance);
+	}
+
+	void ScriptGUIToggle::internal_setContent(ScriptGUIToggle* nativeInstance, MonoObject* content)
+	{
+		GUIContent nativeContent(ScriptGUIContent::getText(content), ScriptGUIContent::getImage(content), ScriptGUIContent::getTooltip(content));
+		nativeInstance->getInternalValue()->setContent(nativeContent);
+	}
+
+	void ScriptGUIToggle::internal_toggleOn(ScriptGUIToggle* nativeInstance)
+	{
+		nativeInstance->getInternalValue()->toggleOn();
+	}
+
+	void ScriptGUIToggle::internal_toggleOff(ScriptGUIToggle* nativeInstance)
+	{
+		nativeInstance->getInternalValue()->toggleOff();
+	}
+
+	void ScriptGUIToggle::internal_destroy(ScriptGUIToggle* nativeInstance)
+	{
+		GUIElement::destroy(nativeInstance->getInternalValue());
+	}
+
+	void ScriptGUIToggle::internal_disable(ScriptGUIToggle* nativeInstance)
+	{
+		nativeInstance->getInternalValue()->disableRecursively();
+	}
+
+	void ScriptGUIToggle::internal_enable(ScriptGUIToggle* nativeInstance)
+	{
+		nativeInstance->getInternalValue()->enableRecursively();
+	}
+
+	void ScriptGUIToggle::onClick(MonoObject* instance)
+	{
+		MonoException* exception = nullptr;
+		onClickThunk(instance, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+
+	void ScriptGUIToggle::onHover(MonoObject* instance)
+	{
+		MonoException* exception = nullptr;
+		onHoverThunk(instance, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+
+	void ScriptGUIToggle::onOut(MonoObject* instance)
+	{
+		MonoException* exception = nullptr;
+		onOutThunk(instance, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+
+	void ScriptGUIToggle::onToggled(MonoObject* instance, bool toggled)
+	{
+		MonoException* exception = nullptr;
+		onToggledThunk(instance, toggled, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+}

SBansheeEngine/Source/BsScriptGUIToggleGroup.cpp

@@ -0,0 +1,48 @@
+#include "BsScriptGUIToggleGroup.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsSpriteTexture.h"
+#include "BsMonoUtil.h"
+#include "BsGUIToggle.h"
+
+using namespace CamelotFramework;
+
+namespace BansheeEngine
+{
+	ScriptGUIToggleGroup::ScriptGUIToggleGroup(const std::shared_ptr<GUIToggleGroup>& toggleGroup)
+		:mToggleGroup(toggleGroup)
+	{
+
+	}
+
+	void ScriptGUIToggleGroup::initMetaData()
+	{
+		metaData = ScriptMeta("MBansheeEngine", "BansheeEngine", "GUIToggleGroup", &ScriptGUIToggleGroup::initRuntimeData);
+
+		MonoManager::registerScriptType(&metaData);
+	}
+
+	void ScriptGUIToggleGroup::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGUIToggleGroup::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_DestroyInstance", &ScriptGUIToggleGroup::internal_destroyInstance);
+	}
+
+	void ScriptGUIToggleGroup::internal_createInstance(MonoObject* instance)
+	{
+		std::shared_ptr<GUIToggleGroup> toggleGroup = GUIToggle::createToggleGroup();
+
+		ScriptGUIToggleGroup* nativeInstance = new (cm_alloc<ScriptGUIToggleGroup>()) ScriptGUIToggleGroup(toggleGroup);
+		nativeInstance->createInstance(instance);
+
+		metaData.thisPtrField->setValue(instance, nativeInstance);
+	}
+
+	void ScriptGUIToggleGroup::internal_destroyInstance(ScriptGUIToggleGroup* nativeInstance)
+	{
+		nativeInstance->destroyInstance();
+		cm_delete(nativeInstance);
+	}
+}