GUI refactor - Editor compiles

BansheeEditor/Include/BsDockManager.h

@@ -115,10 +115,13 @@ namespace BansheeEditor
 		CM::Vector2* mBotDropPolygon;
 		CM::Vector2* mLeftDropPolygon;
 		CM::Vector2* mRightDropPolygon;
+		bool mAddedRenderCallback;
 
 		void updateDropOverlay(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height);
 
 		bool mouseEvent(const BS::GUIMouseEvent& event);
 		bool insidePolygon(CM::Vector2* polyPoints, CM::UINT32 numPoints, CM::Vector2 point) const;
+
+		void _changeParentWidget(BS::GUIWidget* widget);
 	};
 }

BansheeEditor/Include/BsGUIColor.h

@@ -12,8 +12,8 @@ namespace BansheeEditor
 	public:
 		static const CM::String& getGUITypeName();
 
-		static GUIColor* create(const BS::GUIElementStyle* style = nullptr);
-		static GUIColor* create(const BS::GUIOptions& layoutOptions, const BS::GUIElementStyle* style = nullptr);
+		static GUIColor* create(const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUIColor* create(const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
 
 		virtual CM::Vector2I _getOptimalSize() const;
 
@@ -21,7 +21,7 @@ namespace BansheeEditor
 		CM::Color getColor() const { return mColor; }
 
 	protected:
-		GUIColor(const BS::GUIElementStyle* style, const BS::GUILayoutOptions& layoutOptions);
+		GUIColor(const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
 		virtual ~GUIColor();
 
 		/**

BansheeEditor/Include/BsGUIColorField.h

@@ -13,26 +13,26 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		static GUIColorField* create(const BS::GUIContent& labelContent, 
-			const BS::GUIOptions& layoutOptions, BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* toggleStyle = nullptr);
+			const BS::GUIOptions& layoutOptions, const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& toggleStyle = CM::StringUtil::BLANK);
 
 		static GUIColorField* create(const CM::HString& labelText, 
-			const BS::GUIOptions& layoutOptions, BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* toggleStyle = nullptr);
+			const BS::GUIOptions& layoutOptions, const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& toggleStyle = CM::StringUtil::BLANK);
 
-		static GUIColorField* create(const BS::GUIOptions& layoutOptions, BS::GUIElementStyle* labelStyle = nullptr, 
-			BS::GUIElementStyle* toggleStyle = nullptr);
+		static GUIColorField* create(const BS::GUIOptions& layoutOptions, const CM::String& labelStyle = CM::StringUtil::BLANK, 
+			const CM::String& toggleStyle = CM::StringUtil::BLANK);
 
-		static GUIColorField* create(const BS::GUIContent& labelContent, BS::GUIElementStyle* labelStyle = nullptr, 
-			BS::GUIElementStyle* toggleStyle = nullptr);
+		static GUIColorField* create(const BS::GUIContent& labelContent, const CM::String& labelStyle = CM::StringUtil::BLANK, 
+			const CM::String& toggleStyle = CM::StringUtil::BLANK);
 
-		static GUIColorField* create(const CM::HString& labelText, BS::GUIElementStyle* labelStyle = nullptr,
-			BS::GUIElementStyle* toggleStyle = nullptr);
+		static GUIColorField* create(const CM::HString& labelText, const CM::String& labelStyle = CM::StringUtil::BLANK,
+			const CM::String& toggleStyle = CM::StringUtil::BLANK);
 
-		static GUIColorField* create(BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* toggleStyle = nullptr);
+		static GUIColorField* create(const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& toggleStyle = CM::StringUtil::BLANK);
 
 		GUIColorField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, 
-			BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* toggleStyle, const BS::GUILayoutOptions& layoutOptions);
+			const CM::String& labelStyle, const CM::String& toggleStyle, const BS::GUILayoutOptions& layoutOptions);
 
-		GUIColorField(const PrivatelyConstruct& dummy, BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* toggleStyle, 
+		GUIColorField(const PrivatelyConstruct& dummy, const CM::String& labelStyle, const CM::String& toggleStyle, 
 			const BS::GUILayoutOptions& layoutOptions);
 
 		CM::Color getValue() const;

BansheeEditor/Include/BsGUIDockSlider.h

@@ -12,8 +12,8 @@ namespace BansheeEditor
 	public:
 		static const CM::String& getGUITypeName();
 
-		static GUIDockSlider* create(bool horizontal, const BS::GUIElementStyle* style = nullptr);
-		static GUIDockSlider* create(bool horizontal, const BS::GUIOptions& layoutOptions, const BS::GUIElementStyle* style = nullptr);
+		static GUIDockSlider* create(bool horizontal, const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUIDockSlider* create(bool horizontal, const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
 
 		boost::signal<void(const CM::Vector2I&)> onDragged;
 	protected:
@@ -26,6 +26,6 @@ namespace BansheeEditor
 		bool mIsCursorSet;
 		bool mDragInProgress;
 
-		GUIDockSlider(bool horizontal, const BS::GUIElementStyle* style, const BS::GUILayoutOptions& layoutOptions);
+		GUIDockSlider(bool horizontal, const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
 	};
 }

BansheeEditor/Include/BsGUIDropButton.h

@@ -15,15 +15,16 @@ namespace BansheeEditor
 	public:
 		static const CM::String& getGUITypeName();
 
-		static GUIDropButton* create(CM::UINT32 dragType, const BS::GUIElementStyle* style = nullptr);
-		static GUIDropButton* create(CM::UINT32 dragType, const BS::GUIOptions& layoutOptions, const BS::GUIElementStyle* style = nullptr);
+		static GUIDropButton* create(CM::UINT32 dragType, const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUIDropButton* create(CM::UINT32 dragType, const BS::GUIOptions& layoutOptions, 
+			const CM::String& styleName = CM::StringUtil::BLANK);
 
 		boost::signal<void(void*)> onDataDropped;
 	protected:
 		virtual ~GUIDropButton();
 
 	protected:
-		GUIDropButton(CM::UINT32 dragType, const BS::GUIElementStyle* style, const BS::GUILayoutOptions& layoutOptions);
+		GUIDropButton(CM::UINT32 dragType, const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
 
 		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
 

BansheeEditor/Include/BsGUIFieldBase.h

@@ -12,7 +12,7 @@ namespace BansheeEditor
 
 	public:
 		GUIFieldBase(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			BS::GUIElementStyle* labelStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+			const CM::String& labelStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
 
 		void _updateLayoutInternal(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height,
 			CM::RectI clipRect, CM::UINT8 widgetDepth, CM::UINT16 areaDepth);
@@ -33,75 +33,75 @@ namespace BansheeEditor
 	{
 	public:
 		static T* create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* entryElementStyle = nullptr)
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), labelContent, labelWidth, labelStyle, entryElementStyle, 
-				GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle), true);
+				GUILayoutOptions::create(layoutOptions), true);
 		}
 
 		static T* create(const BS::GUIContent& labelContent, const BS::GUIOptions& layoutOptions, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* entryElementStyle = nullptr)
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), labelContent, DEFAULT_LABEL_WIDTH, labelStyle, entryElementStyle, 
-				GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle), true);
+				GUILayoutOptions::create(layoutOptions), true);
 		}
 
 		static T* create(const CM::HString& labelText, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* entryElementStyle = nullptr)
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(labelText), labelWidth, labelStyle, entryElementStyle, 
-				GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle), true);
+				GUILayoutOptions::create(layoutOptions), true);
 		}
 
 		static T* create(const CM::HString& labelText, const BS::GUIOptions& layoutOptions, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* entryElementStyle = nullptr)
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, entryElementStyle, 
-				GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle), true);
+				GUILayoutOptions::create(layoutOptions), true);
 		}
 
-		static T* create(const BS::GUIOptions& layoutOptions, BS::GUIElementStyle* entryElementStyle = nullptr)
+		static T* create(const BS::GUIOptions& layoutOptions, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(), 0, nullptr, entryElementStyle, 
-				GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle), false);
+				GUILayoutOptions::create(layoutOptions), false);
 		}
 
 		static T* create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* entryElementStyle = nullptr)
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), labelContent, labelWidth, labelStyle, entryElementStyle, 
-				GUILayoutOptions::create(&GUISkin::DefaultStyle), true);
+				GUILayoutOptions::create(), true);
 		}
 
 		static T* create(const BS::GUIContent& labelContent, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* entryElementStyle = nullptr)
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), labelContent, DEFAULT_LABEL_WIDTH, labelStyle, entryElementStyle, 
-				GUILayoutOptions::create(&GUISkin::DefaultStyle), true);
+				GUILayoutOptions::create(), true);
 		}
 
 		static T* create(const CM::HString& labelText, CM::UINT32 labelWidth, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* entryElementStyle = nullptr)
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(labelText), labelWidth, labelStyle, entryElementStyle, 
-				GUILayoutOptions::create(&GUISkin::DefaultStyle), true);
+				GUILayoutOptions::create(), true);
 		}
 
 		static T* create(const CM::HString& labelText, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* entryElementStyle = nullptr)
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, entryElementStyle, 
-				GUILayoutOptions::create(&GUISkin::DefaultStyle), true);
+				GUILayoutOptions::create(), true);
 		}
 
-		static T* create(BS::GUIElementStyle* entryElementStyle = nullptr)
+		static T* create(const CM::String& entryElementStyle = CM::StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(), 0, nullptr, entryElementStyle, 
-				GUILayoutOptions::create(&GUISkin::DefaultStyle), false);
+				GUILayoutOptions::create(), false);
 		}
 
 		TGUIField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			BS::GUIElementStyle* labelStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel)
+			const CM::String& labelStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel)
 			:GUIFieldBase(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel)
 		{ }
 	};

BansheeEditor/Include/BsGUIFloatField.h

@@ -11,7 +11,7 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		GUIFloatField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
 
 		float getValue() const;
 		void setValue(float value);

BansheeEditor/Include/BsGUIFoldout.h

@@ -13,13 +13,13 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		static GUIFoldout* create(const BS::GUIOptions& layoutOptions, 
-			BS::GUIElementStyle* buttonStyle = nullptr, BS::GUIElementStyle* backgroundStyle = nullptr);
+			const CM::String& toggleStyle = CM::StringUtil::BLANK, const CM::String& backgroundStyle = CM::StringUtil::BLANK);
 
-		static GUIFoldout* create(BS::GUIElementStyle* labelStyle = nullptr,
-			BS::GUIElementStyle* backgroundStyle = nullptr);
+		static GUIFoldout* create(const CM::String& toggleStyle = CM::StringUtil::BLANK,
+			const CM::String& backgroundStyle = CM::StringUtil::BLANK);
 
-		GUIFoldout(const PrivatelyConstruct& dummy, BS::GUIElementStyle* buttonStyle, 
-			BS::GUIElementStyle* backgroundStyle, const BS::GUILayoutOptions& layoutOptions);
+		GUIFoldout(const PrivatelyConstruct& dummy, const CM::String& toggleStyle, 
+			const CM::String& backgroundStyle, const BS::GUILayoutOptions& layoutOptions);
 
 		bool isExpanded() const { return mIsExpanded; }
 		void setExpanded(bool expanded);
@@ -34,6 +34,9 @@ namespace BansheeEditor
 		virtual ~GUIFoldout();
 
 	protected:
+		static const CM::String FOLDOUT_BUTTON_STYLE;
+		static const CM::String FOLDOUT_BG_STYLE;
+
 		BS::GUIToggle* mToggle;
 		BS::GUITexture* mBackground;
 

BansheeEditor/Include/BsGUIGameObjectField.h

@@ -13,46 +13,46 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		static GUIGameObjectField* create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* dropButtonStyle = nullptr,
-			BS::GUIElementStyle* clearButtonStyle = nullptr);
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
+			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
 
 		static GUIGameObjectField* create(const BS::GUIContent& labelContent, const BS::GUIOptions& layoutOptions, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* dropButtonStyle = nullptr,
-			BS::GUIElementStyle* clearButtonStyle = nullptr);
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
+			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
 
 		static GUIGameObjectField* create(const CM::HString& labelText, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* dropButtonStyle = nullptr,
-			BS::GUIElementStyle* clearButtonStyle = nullptr);
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
+			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
 
 		static GUIGameObjectField* create(const CM::HString& labelText, const BS::GUIOptions& layoutOptions, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* dropButtonStyle = nullptr,
-			BS::GUIElementStyle* clearButtonStyle = nullptr);
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
+			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
 
-		static GUIGameObjectField* create(const BS::GUIOptions& layoutOptions, BS::GUIElementStyle* dropButtonStyle = nullptr,
-			BS::GUIElementStyle* clearButtonStyle = nullptr);
+		static GUIGameObjectField* create(const BS::GUIOptions& layoutOptions, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
+			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
 
 		static GUIGameObjectField* create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* dropButtonStyle = nullptr,
-			BS::GUIElementStyle* clearButtonStyle = nullptr);
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
+			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
 
 		static GUIGameObjectField* create(const BS::GUIContent& labelContent, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* dropButtonStyle = nullptr,
-			BS::GUIElementStyle* clearButtonStyle = nullptr);
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
+			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
 
 		static GUIGameObjectField* create(const CM::HString& labelText, CM::UINT32 labelWidth, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* dropButtonStyle = nullptr,
-			BS::GUIElementStyle* clearButtonStyle = nullptr);
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
+			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
 
 		static GUIGameObjectField* create(const CM::HString& labelText, 
-			BS::GUIElementStyle* labelStyle = nullptr, BS::GUIElementStyle* dropButtonStyle = nullptr,
-			BS::GUIElementStyle* clearButtonStyle = nullptr);
+			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
+			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
 
-		static GUIGameObjectField* create(BS::GUIElementStyle* dropButtonStyle = nullptr,
-			BS::GUIElementStyle* clearButtonStyle = nullptr);
+		static GUIGameObjectField* create(const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
+			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
 
 		GUIGameObjectField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, 
-			CM::UINT32 labelWidth, BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* dropButtonStyle,
-			BS::GUIElementStyle* clearButtonStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+			CM::UINT32 labelWidth, const CM::String& labelStyle, const CM::String& dropButtonStyle,
+			const CM::String& clearButtonStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
 
 		CM::HGameObject getValue() const;
 		void setValue(const CM::HGameObject& value);
@@ -68,6 +68,8 @@ namespace BansheeEditor
 
 	private:
 		static const CM::UINT32 DEFAULT_LABEL_WIDTH;
+		static const CM::String DROP_BUTTON_STYLE;
+		static const CM::String CLEAR_BUTTON_STYLE;
 
 		BS::GUILayout* mLayout;
 		BS::GUILabel* mLabel;

BansheeEditor/Include/BsGUIIntField.h

@@ -11,7 +11,7 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		GUIIntField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
 
 		CM::INT32 getValue() const;
 		void setValue(CM::INT32 value);

BansheeEditor/Include/BsGUIResourceTreeView.h

@@ -33,16 +33,16 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		static GUIResourceTreeView* create(
-			BS::GUIElementStyle* backgroundStyle = nullptr, BS::GUIElementStyle* elementBtnStyle = nullptr, 
-			BS::GUIElementStyle* foldoutBtnStyle = nullptr, BS::GUIElementStyle* selectionBackgroundStyle = nullptr,
-			BS::GUIElementStyle* editBoxStyle = nullptr, BS::GUIElementStyle* dragHighlightStyle = nullptr, 
-			BS::GUIElementStyle* dragSepHighlightStyle = nullptr);
+			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& elementBtnStyle = CM::StringUtil::BLANK, 
+			const CM::String& foldoutBtnStyle = CM::StringUtil::BLANK, const CM::String& selectionBackgroundStyle = CM::StringUtil::BLANK,
+			const CM::String& editBoxStyle = CM::StringUtil::BLANK, const CM::String& dragHighlightStyle = CM::StringUtil::BLANK, 
+			const CM::String& dragSepHighlightStyle = CM::StringUtil::BLANK);
 
 		static GUIResourceTreeView* create(const BS::GUIOptions& options, 
-			BS::GUIElementStyle* backgroundStyle = nullptr, BS::GUIElementStyle* elementBtnStyle = nullptr, 
-			BS::GUIElementStyle* foldoutBtnStyle = nullptr, BS::GUIElementStyle* selectionBackgroundStyle = nullptr,
-			BS::GUIElementStyle* editBoxStyle = nullptr, BS::GUIElementStyle* dragHighlightStyle = nullptr, 
-			BS::GUIElementStyle* dragSepHighlightStyle = nullptr);
+			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& elementBtnStyle = CM::StringUtil::BLANK, 
+			const CM::String& foldoutBtnStyle = CM::StringUtil::BLANK, const CM::String& selectionBackgroundStyle = CM::StringUtil::BLANK,
+			const CM::String& editBoxStyle = CM::StringUtil::BLANK, const CM::String& dragHighlightStyle = CM::StringUtil::BLANK, 
+			const CM::String& dragSepHighlightStyle = CM::StringUtil::BLANK);
 
 
 	protected:
@@ -60,9 +60,9 @@ namespace BansheeEditor
 		boost::signals::connection mDropTargetLeaveConn;
 		boost::signals::connection mDropTargetDroppedConn;
 
-		GUIResourceTreeView(BS::GUIElementStyle* backgroundStyle, BS::GUIElementStyle* elementBtnStyle, 
-			BS::GUIElementStyle* foldoutBtnStyle, BS::GUIElementStyle* selectionBackgroundStyle, BS::GUIElementStyle* editBoxStyle, 
-			BS::GUIElementStyle* dragHighlightStyle, BS::GUIElementStyle* dragSepHighlightStyle, const BS::GUILayoutOptions& layoutOptions);
+		GUIResourceTreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
+			const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
+			const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const BS::GUILayoutOptions& layoutOptions);
 
 		virtual void _updateLayoutInternal(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height,
 			CM::RectI clipRect, CM::UINT8 widgetDepth, CM::UINT16 areaDepth);

BansheeEditor/Include/BsGUISceneTreeView.h

@@ -31,16 +31,16 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		static GUISceneTreeView* create(
-			BS::GUIElementStyle* backgroundStyle = nullptr, BS::GUIElementStyle* elementBtnStyle = nullptr, 
-			BS::GUIElementStyle* foldoutBtnStyle = nullptr, BS::GUIElementStyle* selectionBackgroundStyle = nullptr,
-			BS::GUIElementStyle* editBoxStyle = nullptr, BS::GUIElementStyle* dragHighlightStyle = nullptr, 
-			BS::GUIElementStyle* dragSepHighlightStyle = nullptr);
+			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& elementBtnStyle = CM::StringUtil::BLANK, 
+			const CM::String& foldoutBtnStyle = CM::StringUtil::BLANK, const CM::String& selectionBackgroundStyle = CM::StringUtil::BLANK,
+			const CM::String& editBoxStyle = CM::StringUtil::BLANK, const CM::String& dragHighlightStyle = CM::StringUtil::BLANK, 
+			const CM::String& dragSepHighlightStyle = CM::StringUtil::BLANK);
 
 		static GUISceneTreeView* create(const BS::GUIOptions& options, 
-			BS::GUIElementStyle* backgroundStyle = nullptr, BS::GUIElementStyle* elementBtnStyle = nullptr, 
-			BS::GUIElementStyle* foldoutBtnStyle = nullptr, BS::GUIElementStyle* selectionBackgroundStyle = nullptr,
-			BS::GUIElementStyle* editBoxStyle = nullptr, BS::GUIElementStyle* dragHighlightStyle = nullptr, 
-			BS::GUIElementStyle* dragSepHighlightStyle = nullptr);
+			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& elementBtnStyle = CM::StringUtil::BLANK, 
+			const CM::String& foldoutBtnStyle = CM::StringUtil::BLANK, const CM::String& selectionBackgroundStyle = CM::StringUtil::BLANK,
+			const CM::String& editBoxStyle = CM::StringUtil::BLANK, const CM::String& dragHighlightStyle = CM::StringUtil::BLANK, 
+			const CM::String& dragSepHighlightStyle = CM::StringUtil::BLANK);
 
 
 	protected:
@@ -49,9 +49,9 @@ namespace BansheeEditor
 	protected:
 		SceneTreeElement mRootElement;
 
-		GUISceneTreeView(BS::GUIElementStyle* backgroundStyle, BS::GUIElementStyle* elementBtnStyle, 
-			BS::GUIElementStyle* foldoutBtnStyle, BS::GUIElementStyle* selectionBackgroundStyle, BS::GUIElementStyle* editBoxStyle, 
-			BS::GUIElementStyle* dragHighlightStyle, BS::GUIElementStyle* dragSepHighlightStyle, const BS::GUILayoutOptions& layoutOptions);
+		GUISceneTreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
+			const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
+			const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const BS::GUILayoutOptions& layoutOptions);
 
 		void updateTreeElement(SceneTreeElement* element);
 

BansheeEditor/Include/BsGUITabButton.h

@@ -13,11 +13,15 @@ namespace BansheeEditor
 	public:
 		static const CM::String& getGUITypeName();
 
-		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const CM::HString& text, const BS::GUIElementStyle* style = nullptr);
-		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const CM::HString& text, const BS::GUIOptions& layoutOptions, const BS::GUIElementStyle* style = nullptr);
+		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const CM::HString& text, 
+			const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const CM::HString& text, 
+			const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
 	
-		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const BS::GUIContent& content, const BS::GUIElementStyle* style = nullptr);
-		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const BS::GUIContent& content, const BS::GUIOptions& layoutOptions, const BS::GUIElementStyle* style = nullptr);
+		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const BS::GUIContent& content, 
+			const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const BS::GUIContent& content, 
+			const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
 
 		CM::UINT32 getIndex() const { return mIndex; }
 		void _setDraggedState(bool active);
@@ -35,6 +39,6 @@ namespace BansheeEditor
 
 		static const CM::UINT32 DRAG_MIN_DISTANCE;
 
-		GUITabButton(const BS::GUIElementStyle* style, const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const BS::GUIContent& content, const BS::GUILayoutOptions& layoutOptions);
+		GUITabButton(const CM::String& styleName, const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const BS::GUIContent& content, const BS::GUILayoutOptions& layoutOptions);
 	};
 }

BansheeEditor/Include/BsGUITabbedTitleBar.h

@@ -13,13 +13,12 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		static GUITabbedTitleBar* create(CM::RenderWindow* parentWindow,
-			BS::GUIElementStyle* backgroundStyle = nullptr, BS::GUIElementStyle* tabBtnStyle = nullptr, 
-			BS::GUIElementStyle* minBtnStyle = nullptr, BS::GUIElementStyle* closeBtnStyle = nullptr);
+			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& tabBtnStyle = CM::StringUtil::BLANK, 
+			const CM::String& minBtnStyle = CM::StringUtil::BLANK, const CM::String& closeBtnStyle = CM::StringUtil::BLANK);
 
-		static GUITabbedTitleBar* create(CM::RenderWindow* parentWindow, const BS::GUILayoutOptions& layoutOptions);
 		static GUITabbedTitleBar* create(CM::RenderWindow* parentWindow, const BS::GUILayoutOptions& layoutOptions, 
-			BS::GUIElementStyle* backgroundStyle = nullptr, BS::GUIElementStyle* tabBtnStyle = nullptr, 
-			BS::GUIElementStyle* minBtnStyle = nullptr, BS::GUIElementStyle* closeBtnStyle = nullptr);
+			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& tabBtnStyle = CM::StringUtil::BLANK, 
+			const CM::String& minBtnStyle = CM::StringUtil::BLANK, const CM::String& closeBtnStyle = CM::StringUtil::BLANK);
 
 		void addTab(const CM::HString& name);
 		CM::UINT32 insertTab(CM::UINT32 position, const CM::HString& name);
@@ -64,13 +63,13 @@ namespace BansheeEditor
 		CM::INT32 mDragBtnOffset;
 		CM::INT32 mInitialDragOffset;
 
-		const BS::GUIElementStyle* mBackgroundStyle;
-		const BS::GUIElementStyle* mCloseBtnStyle;
-		const BS::GUIElementStyle* mMinimizeBtnStyle;
-		const BS::GUIElementStyle* mTabBtnStyle;
+		CM::String mBackgroundStyle;
+		CM::String mCloseBtnStyle;
+		CM::String mMinimizeBtnStyle;
+		CM::String mTabBtnStyle;
 
-		GUITabbedTitleBar(CM::RenderWindow* parentWindow, BS::GUIElementStyle* backgroundStyle, BS::GUIElementStyle* tabBtnStyle, 
-			BS::GUIElementStyle* minBtnStyle, BS::GUIElementStyle* closeBtnStyle, const BS::GUILayoutOptions& layoutOptions);
+		GUITabbedTitleBar(CM::RenderWindow* parentWindow, const CM::String& backgroundStyle, const CM::String& tabBtnStyle, 
+			const CM::String& minBtnStyle, const CM::String& closeBtnStyle, const BS::GUILayoutOptions& layoutOptions);
 
 		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
 

BansheeEditor/Include/BsGUITextField.h

@@ -11,7 +11,7 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		GUITextField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
 
 		CM::WString getValue() const;
 		void setValue(const CM::WString& value);

BansheeEditor/Include/BsGUIToggleField.h

@@ -11,7 +11,7 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		GUIToggleField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* toggleStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+			const CM::String& labelStyle, const CM::String& toggleStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
 
 		bool getValue() const;
 		void setValue(bool value);

BansheeEditor/Include/BsGUITreeView.h

@@ -86,13 +86,13 @@ namespace BansheeEditor
 		static const float SCROLL_AREA_HEIGHT_PCT;
 		static const CM::UINT32 SCROLL_SPEED_PX_PER_SEC;
 
-		const BS::GUIElementStyle* mBackgroundStyle;
-		const BS::GUIElementStyle* mElementBtnStyle;
-		const BS::GUIElementStyle* mFoldoutBtnStyle;
-		const BS::GUIElementStyle* mSelectionBackgroundStyle;
-		const BS::GUIElementStyle* mEditBoxStyle;
-		const BS::GUIElementStyle* mDragHighlightStyle;
-		const BS::GUIElementStyle* mDragSepHighlightStyle;
+		CM::String mBackgroundStyle;
+		CM::String mElementBtnStyle;
+		CM::String mFoldoutBtnStyle;
+		CM::String mSelectionBackgroundStyle;
+		CM::String mEditBoxStyle;
+		CM::String mDragHighlightStyle;
+		CM::String mDragSepHighlightStyle;
 
 		BS::GUITexture* mBackgroundImage;
 
@@ -122,9 +122,9 @@ namespace BansheeEditor
 		static BS::VirtualButton mRenameVB;
 		static BS::VirtualButton mDeleteVB;
 
-		GUITreeView(BS::GUIElementStyle* backgroundStyle, BS::GUIElementStyle* elementBtnStyle, 
-			BS::GUIElementStyle* foldoutBtnStyle, BS::GUIElementStyle* selectionBackgroundStyle, BS::GUIElementStyle* editBoxStyle, 
-			BS::GUIElementStyle* dragHighlightStyle, BS::GUIElementStyle* dragSepHighlightStyle, const BS::GUILayoutOptions& layoutOptions);
+		GUITreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
+			const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
+			const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const BS::GUILayoutOptions& layoutOptions);
 
 		const GUITreeView::InteractableElement* findElementUnderCoord(const CM::Vector2I& coord) const;
 		TreeElement* getTopMostSelectedElement() const;

BansheeEditor/Include/BsGUITreeViewEditBox.h

@@ -10,14 +10,14 @@ namespace BansheeEditor
 	public:
 		static const CM::String& getGUITypeName();
 
-		static GUITreeViewEditBox* create(const BS::GUIElementStyle* style = nullptr);
-		static GUITreeViewEditBox* create(const BS::GUIOptions& layoutOptions, const BS::GUIElementStyle* style = nullptr);
+		static GUITreeViewEditBox* create(const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUITreeViewEditBox* create(const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
 
 		boost::signal<void()> onInputConfirmed;
 		boost::signal<void()> onInputCanceled;
 
 	private:
-		GUITreeViewEditBox(const BS::GUIElementStyle* style, const BS::GUILayoutOptions& layoutOptions);
+		GUITreeViewEditBox(const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
 
 		virtual bool commandEvent(const BS::GUICommandEvent& ev);
 	};

BansheeEditor/Include/BsGUIVector2Field.h

@@ -12,7 +12,7 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		GUIVector2Field(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
 
 		CM::Vector2 getValue() const;
 		void setValue(const CM::Vector2& value);

BansheeEditor/Include/BsGUIVector3Field.h

@@ -12,7 +12,7 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		GUIVector3Field(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
 
 		CM::Vector3 getValue() const;
 		void setValue(const CM::Vector3& value);

BansheeEditor/Include/BsGUIVector4Field.h

@@ -12,7 +12,7 @@ namespace BansheeEditor
 		static const CM::String& getGUITypeName();
 
 		GUIVector4Field(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
 
 		CM::Vector4 getValue() const;
 		void setValue(const CM::Vector4& value);

BansheeEditor/Include/BsGUIWindowDropArea.h

@@ -11,15 +11,15 @@ namespace BansheeEditor
 	public:
 		static const CM::String& getGUITypeName();
 
-		static GUIWindowDropArea* create(const BS::GUIElementStyle* style = nullptr);
-		static GUIWindowDropArea* create(const BS::GUIOptions& layoutOptions, const BS::GUIElementStyle* style = nullptr);
+		static GUIWindowDropArea* create(const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUIWindowDropArea* create(const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
 
 		void setFocused(bool focused);
 
 		boost::signal<void()> onDraggedItemDropped;
 	protected:
 		~GUIWindowDropArea();
-		GUIWindowDropArea(const BS::GUIElementStyle* style, const BS::GUILayoutOptions& layoutOptions);
+		GUIWindowDropArea(const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
 
 		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
 	};

BansheeEditor/Include/BsGUIWindowFrame.h

@@ -11,12 +11,12 @@ namespace BansheeEditor
 	public:
 		static const CM::String& getGUITypeName();
 
-		static GUIWindowFrame* create(const BS::GUIElementStyle* style = nullptr);
-		static GUIWindowFrame* create(const BS::GUIOptions& layoutOptions, const BS::GUIElementStyle* style = nullptr);
+		static GUIWindowFrame* create(const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUIWindowFrame* create(const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
 
 		void setFocused(bool focused);
 	protected:
 		~GUIWindowFrame();
-		GUIWindowFrame(const BS::GUIElementStyle* style, const BS::GUILayoutOptions& layoutOptions);
+		GUIWindowFrame(const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
 	};
 }

BansheeEditor/Source/BsDockManager.cpp

@@ -220,12 +220,12 @@ namespace BansheeEditor
 
 		if(horizontal)
 		{
-			mSlider = GUIDockSlider::create(true, widgetParent->getSkin().getStyle("DockSliderBtn"));
+			mSlider = GUIDockSlider::create(true, "DockSliderBtn");
 			mSlider->_setWidgetDepth(widgetParent->getDepth());
 		}
 		else
 		{
-			mSlider = GUIDockSlider::create(false, widgetParent->getSkin().getStyle("DockSliderBtn"));
+			mSlider = GUIDockSlider::create(false, "DockSliderBtn");
 			mSlider->_setWidgetDepth(widgetParent->getDepth());
 		}
 
@@ -357,7 +357,7 @@ namespace BansheeEditor
 
 	DockManager::DockManager(CM::RenderWindow* parentWindow, const GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mParentWindow(parentWindow), mMouseOverContainer(nullptr), mHighlightedDropLoc(DockLocation::None),
-		mShowOverlay(false)
+		mShowOverlay(false), mAddedRenderCallback(false)
 	{
 		mTopDropPolygon = cm_newN<Vector2>(4);
 		mBotDropPolygon = cm_newN<Vector2>(4);
@@ -365,8 +365,6 @@ namespace BansheeEditor
 		mRightDropPolygon = cm_newN<Vector2>(4);
 
 		mDropOverlayMat = BuiltinMaterialManager::instance().createDockDropOverlayMaterial();
-
-		RendererManager::instance().getActive()->addRenderCallback(mParent->getTarget(), std::bind(&DockManager::render, this, _1, _2));
 	}
 
 	DockManager::~DockManager()
@@ -379,7 +377,7 @@ namespace BansheeEditor
 
 	DockManager* DockManager::create(RenderWindow* parentWindow)
 	{
-		return new (cm_alloc<DockManager, PoolAlloc>()) DockManager(parentWindow, GUILayoutOptions::create(&GUISkin::DefaultStyle));
+		return new (cm_alloc<DockManager, PoolAlloc>()) DockManager(parentWindow, GUILayoutOptions::create());
 	}
 
 	void DockManager::update()
@@ -949,6 +947,24 @@ namespace BansheeEditor
 
 		return false;
 	}
+	
+	void DockManager::_changeParentWidget(GUIWidget* widget)
+	{
+		GUIElement::_changeParentWidget(widget);
+
+		if(widget != nullptr)
+		{
+			if(mAddedRenderCallback)
+			{
+				// Note: Adding support for this should be fairly simple though, I just didn't bother with it. You could
+				// remove the current render callback and register a new one. Will likely need to make other minor fixes.
+				CM_EXCEPT(InvalidStateException, "Attempting to change parent widget of a DockManager. This is not supported");
+			}
+
+			RendererManager::instance().getActive()->addRenderCallback(widget->getTarget(), std::bind(&DockManager::render, this, _1, _2));
+			mAddedRenderCallback = true;
+		}
+	}
 
 	// TODO - Move to a separate Polygon class?
 	bool DockManager::insidePolygon(CM::Vector2* polyPoints, CM::UINT32 numPoints, CM::Vector2 point) const

BansheeEditor/Source/BsGUIColor.cpp

@@ -16,8 +16,8 @@ namespace BansheeEditor
 {
 	const float GUIColor::ALPHA_SPLIT_POSITION = 0.75f;
 
-	GUIColor::GUIColor(const GUIElementStyle* style, const GUILayoutOptions& layoutOptions)
-		:GUIElement(style, layoutOptions), mColorSprite(nullptr), mAlphaSprite(nullptr)
+	GUIColor::GUIColor(const CM::String& styleName, const GUILayoutOptions& layoutOptions)
+		:GUIElement(styleName, layoutOptions), mColorSprite(nullptr), mAlphaSprite(nullptr)
 	{
 		mColorSprite = cm_new<ImageSprite, PoolAlloc>();
 		mAlphaSprite = cm_new<ImageSprite, PoolAlloc>();
@@ -38,14 +38,14 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUIColor* GUIColor::create(const GUIElementStyle* style)
+	GUIColor* GUIColor::create(const CM::String& styleName)
 	{
-		return new (cm_alloc<GUIColor, PoolAlloc>()) GUIColor(style, GUILayoutOptions::create(style));
+		return new (cm_alloc<GUIColor, PoolAlloc>()) GUIColor(getStyleName<GUIColor>(styleName), GUILayoutOptions::create());
 	}
 
-	GUIColor* GUIColor::create(const GUIOptions& layoutOptions, const GUIElementStyle* style)
+	GUIColor* GUIColor::create(const GUIOptions& layoutOptions, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUIColor, PoolAlloc>()) GUIColor(style, GUILayoutOptions::create(layoutOptions, style));
+		return new (cm_alloc<GUIColor, PoolAlloc>()) GUIColor(getStyleName<GUIColor>(styleName), GUILayoutOptions::create(layoutOptions));
 	}
 
 	void GUIColor::setColor(const Color& color)

BansheeEditor/Source/BsGUIColorField.cpp

@@ -14,7 +14,7 @@ using namespace BansheeEngine;
 namespace BansheeEditor
 {
 	GUIColorField::GUIColorField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-		GUIElementStyle* labelStyle, GUIElementStyle* colorStyle, const GUILayoutOptions& layoutOptions)
+		const CM::String& labelStyle, const CM::String& colorStyle, const GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mLabel(nullptr), mColor(nullptr), mLabelWidth(100)
 	{
 		mLabel = GUILabel::create(labelContent, labelStyle);
@@ -25,7 +25,7 @@ namespace BansheeEditor
 	}
 
 	GUIColorField::GUIColorField(const PrivatelyConstruct& dummy, 
-		GUIElementStyle* labelStyle, GUIElementStyle* colorStyle, const GUILayoutOptions& layoutOptions)
+		const CM::String& labelStyle, const CM::String& colorStyle, const GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mLabel(nullptr), mColor(nullptr), mLabelWidth(100)
 	{
 		mColor = GUIColor::create(colorStyle);
@@ -39,43 +39,43 @@ namespace BansheeEditor
 	}
 
 	GUIColorField* GUIColorField::create(const GUIContent& labelContent, const GUIOptions& layoutOptions, 
-		GUIElementStyle* labelStyle, GUIElementStyle* toggleStyle)
+		const CM::String& labelStyle, const CM::String& toggleStyle)
 	{
 		return cm_new<GUIColorField>(PrivatelyConstruct(), labelContent, labelStyle, toggleStyle, 
-			GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle));
+			GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUIColorField* GUIColorField::create(const GUIContent& labelContent, GUIElementStyle* labelStyle, 
-		GUIElementStyle* toggleStyle)
+	GUIColorField* GUIColorField::create(const GUIContent& labelContent, const CM::String& labelStyle, 
+		const CM::String& toggleStyle)
 	{
 		return cm_new<GUIColorField>(PrivatelyConstruct(), labelContent, labelStyle, toggleStyle, 
-			GUILayoutOptions::create(&GUISkin::DefaultStyle));
+			GUILayoutOptions::create());
 	}
 
 	GUIColorField* GUIColorField::create(const HString& labelContent, const GUIOptions& layoutOptions, 
-		GUIElementStyle* labelStyle, GUIElementStyle* toggleStyle)
+		const CM::String& labelStyle, const CM::String& toggleStyle)
 	{
 		return cm_new<GUIColorField>(PrivatelyConstruct(), GUIContent(labelContent), labelStyle, 
-			toggleStyle, GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle));
+			toggleStyle, GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUIColorField* GUIColorField::create( const HString& labelContent, GUIElementStyle* labelStyle, 
-		GUIElementStyle* toggleStyle)
+	GUIColorField* GUIColorField::create( const HString& labelContent, const CM::String& labelStyle, 
+		const CM::String& toggleStyle)
 	{
 		return cm_new<GUIColorField>(PrivatelyConstruct(), GUIContent(labelContent), labelStyle, toggleStyle, 
-			GUILayoutOptions::create(&GUISkin::DefaultStyle));
+			GUILayoutOptions::create());
 	}
 
-	GUIColorField* GUIColorField::create(const GUIOptions& layoutOptions, GUIElementStyle* labelStyle, 
-		GUIElementStyle* toggleStyle)
+	GUIColorField* GUIColorField::create(const GUIOptions& layoutOptions, const CM::String& labelStyle, 
+		const CM::String& toggleStyle)
 	{
 		return cm_new<GUIColorField>(PrivatelyConstruct(), labelStyle, toggleStyle, 
-			GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle));
+			GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUIColorField* GUIColorField::create(GUIElementStyle* labelStyle, GUIElementStyle* toggleStyle)
+	GUIColorField* GUIColorField::create(const CM::String& labelStyle, const CM::String& toggleStyle)
 	{
-		return cm_new<GUIColorField>(PrivatelyConstruct(), labelStyle, toggleStyle, GUILayoutOptions::create(&GUISkin::DefaultStyle));
+		return cm_new<GUIColorField>(PrivatelyConstruct(), labelStyle, toggleStyle, GUILayoutOptions::create());
 	}
 
 	Color GUIColorField::getValue() const

BansheeEditor/Source/BsGUIDockSlider.cpp

@@ -18,21 +18,23 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUIDockSlider::GUIDockSlider(bool horizontal, const BS::GUIElementStyle* style, const BS::GUILayoutOptions& layoutOptions)
-		:GUIButtonBase(style, GUIContent(HString(L"")), layoutOptions),
+	GUIDockSlider::GUIDockSlider(bool horizontal, const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions)
+		:GUIButtonBase(styleName, GUIContent(HString(L"")), layoutOptions),
 		mDragInProgress(false), mHorizontal(horizontal), mIsCursorSet(false)
 	{
 
 	}
 
-	GUIDockSlider* GUIDockSlider::create(bool horizontal, const GUIElementStyle* style)
+	GUIDockSlider* GUIDockSlider::create(bool horizontal, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUIDockSlider, PoolAlloc>()) GUIDockSlider(horizontal, style, GUILayoutOptions::create(style));
+		return new (cm_alloc<GUIDockSlider, PoolAlloc>()) GUIDockSlider(horizontal, 
+			getStyleName<GUIDockSlider>(styleName), GUILayoutOptions::create());
 	}
 
-	GUIDockSlider* GUIDockSlider::create(bool horizontal, const GUIOptions& layoutOptions, const BS::GUIElementStyle* style)
+	GUIDockSlider* GUIDockSlider::create(bool horizontal, const GUIOptions& layoutOptions, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUIDockSlider, PoolAlloc>()) GUIDockSlider(horizontal, style, GUILayoutOptions::create(layoutOptions, style));
+		return new (cm_alloc<GUIDockSlider, PoolAlloc>()) GUIDockSlider(horizontal, 
+			getStyleName<GUIDockSlider>(styleName), GUILayoutOptions::create(layoutOptions));
 	}
 
 	bool GUIDockSlider::_hasCustomCursor(const CM::Vector2I position, CursorType& type) const

BansheeEditor/Source/BsGUIDropButton.cpp

@@ -21,8 +21,8 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUIDropButton::GUIDropButton(CM::UINT32 dragType, const GUIElementStyle* style, const GUILayoutOptions& layoutOptions)
-		:GUIButtonBase(style, GUIContent(HString(L"None")), layoutOptions)
+	GUIDropButton::GUIDropButton(CM::UINT32 dragType, const CM::String& styleName, const GUILayoutOptions& layoutOptions)
+		:GUIButtonBase(styleName, GUIContent(HString(L"None")), layoutOptions)
 	{
 
 	}
@@ -30,14 +30,16 @@ namespace BansheeEditor
 	GUIDropButton::~GUIDropButton()
 	{ }
 
-	GUIDropButton* GUIDropButton::create(CM::UINT32 dragType, const GUIElementStyle* style)
+	GUIDropButton* GUIDropButton::create(CM::UINT32 dragType, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUIDropButton, PoolAlloc>()) GUIDropButton(dragType, style, GUILayoutOptions::create(style));
+		return new (cm_alloc<GUIDropButton, PoolAlloc>()) GUIDropButton(dragType, 
+			getStyleName<GUIDropButton>(styleName), GUILayoutOptions::create());
 	}
 
-	GUIDropButton* GUIDropButton::create(CM::UINT32 dragType, const GUIOptions& layoutOptions, const GUIElementStyle* style)
+	GUIDropButton* GUIDropButton::create(CM::UINT32 dragType, const GUIOptions& layoutOptions, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUIDropButton, PoolAlloc>()) GUIDropButton(dragType, style, GUILayoutOptions::create(layoutOptions, style));
+		return new (cm_alloc<GUIDropButton, PoolAlloc>()) GUIDropButton(dragType, 
+			getStyleName<GUIDropButton>(styleName), GUILayoutOptions::create(layoutOptions));
 	}
 
 	bool GUIDropButton::mouseEvent(const GUIMouseEvent& ev)

BansheeEditor/Source/BsGUIFieldBase.cpp

@@ -12,7 +12,7 @@ namespace BansheeEditor
 	const UINT32 GUIFieldBase::DEFAULT_LABEL_WIDTH = 100;
 
 	GUIFieldBase::GUIFieldBase(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
-		GUIElementStyle* labelStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		const CM::String& labelStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:GUIElementContainer(layoutOptions)
 	{
 		mLayout = &addLayoutXInternal(this);

BansheeEditor/Source/BsGUIFloatField.cpp

@@ -20,7 +20,7 @@ namespace BansheeEditor
 	const float GUIFloatField::DRAG_SPEED = 0.05f;
 
 	GUIFloatField::GUIFloatField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, CM::UINT32 labelWidth, 
-		GUIElementStyle* labelStyle, GUIElementStyle* inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mInputBox(nullptr), mIsDragging(false),
 		mLastDragPos(0)
 	{

BansheeEditor/Source/BsGUIFoldout.cpp

@@ -13,21 +13,15 @@ using namespace BansheeEngine;
 
 namespace BansheeEditor
 {
-	GUIFoldout::GUIFoldout(const PrivatelyConstruct& dummy, BS::GUIElementStyle* buttonStyle, 
-		BS::GUIElementStyle* backgroundStyle, const BS::GUILayoutOptions& layoutOptions)
+	const String GUIFoldout::FOLDOUT_BUTTON_STYLE = "FoldoutButton";
+	const String GUIFoldout::FOLDOUT_BG_STYLE = "FoldoutBackground";
+
+	GUIFoldout::GUIFoldout(const PrivatelyConstruct& dummy, const CM::String& toggleStyle, 
+		const CM::String& backgroundStyle, const BS::GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mToggle(nullptr), mBackground(nullptr), mIsExpanded(false)
 	{
-		const GUIElementStyle* curButtonStyle = buttonStyle;
-		const GUIElementStyle* curBackgroundStyle = backgroundStyle;
-
-		if(curButtonStyle == nullptr)
-			curButtonStyle = parent.getSkin().getStyle("FoldoutButton");
-
-		if(curBackgroundStyle == nullptr)
-			curBackgroundStyle = parent.getSkin().getStyle("FoldoutBackground");
-
-		mToggle = GUIToggle::create(parent, HString(L""), curButtonStyle);
-		mBackground = GUITexture::create(parent, curBackgroundStyle);
+		mToggle = GUIToggle::create(HString(L""), toggleStyle);
+		mBackground = GUITexture::create(backgroundStyle);
 
 		_registerChildElement(mToggle);
 		_registerChildElement(mBackground);
@@ -39,17 +33,33 @@ namespace BansheeEditor
 	}
 
 	GUIFoldout* GUIFoldout::create(const GUIOptions& layoutOptions, 
-		GUIElementStyle* buttonStyle, GUIElementStyle* backgroundStyle)
+		const CM::String& toggleStyle, const CM::String& backgroundStyle)
 	{
-		return cm_new<GUIFoldout>(PrivatelyConstruct(), buttonStyle, backgroundStyle, 
-			GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle));
+		const String* curToggleStyle = &toggleStyle;
+		if(*curToggleStyle == StringUtil::BLANK)
+			curToggleStyle = &FOLDOUT_BUTTON_STYLE;
+
+		const String* curBackgroundStyle = &backgroundStyle;
+		if(*curBackgroundStyle == StringUtil::BLANK)
+			curBackgroundStyle = &FOLDOUT_BG_STYLE;
+
+		return cm_new<GUIFoldout>(PrivatelyConstruct(), *curToggleStyle, *curBackgroundStyle, 
+			GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUIFoldout* GUIFoldout::create(GUIElementStyle* buttonStyle, 
-		GUIElementStyle* backgroundStyle)
+	GUIFoldout* GUIFoldout::create(const CM::String& toggleStyle, 
+		const CM::String& backgroundStyle)
 	{
-		return cm_new<GUIFoldout>(PrivatelyConstruct(), buttonStyle, backgroundStyle, 
-			GUILayoutOptions::create(&GUISkin::DefaultStyle));
+		const String* curToggleStyle = &toggleStyle;
+		if(*curToggleStyle == StringUtil::BLANK)
+			curToggleStyle = &FOLDOUT_BUTTON_STYLE;
+
+		const String* curBackgroundStyle = &backgroundStyle;
+		if(*curBackgroundStyle == StringUtil::BLANK)
+			curBackgroundStyle = &FOLDOUT_BG_STYLE;
+
+		return cm_new<GUIFoldout>(PrivatelyConstruct(), *curToggleStyle, *curBackgroundStyle, 
+			GUILayoutOptions::create());
 	}
 
 	void GUIFoldout::setExpanded(bool expanded)

BansheeEditor/Source/BsGUIGameObjectField.cpp

@@ -18,35 +18,32 @@ using namespace std::placeholders;
 namespace BansheeEditor
 {
 	const UINT32 GUIGameObjectField::DEFAULT_LABEL_WIDTH = 100;
+	const String GUIGameObjectField::DROP_BUTTON_STYLE = "DropButton";
+	const String GUIGameObjectField::CLEAR_BUTTON_STYLE = "ObjectClearButton";
 
 	GUIGameObjectField::GUIGameObjectField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, CM::UINT32 labelWidth,
-		GUIElementStyle* labelStyle, GUIElementStyle* dropButtonStyle, GUIElementStyle* clearButtonStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:GUIElementContainer(layoutOptions), mLabel(nullptr), mClearButton(nullptr), mDropButton(nullptr), mInstanceId(0)
 	{
 		mLayout = &addLayoutXInternal(this);
 
 		if(withLabel)
 		{
-			const GUIElementStyle* curLabelStyle = labelStyle;
-
-			if(curLabelStyle == nullptr)
-				curLabelStyle = parent.getSkin().getStyle("Label");
-
-			mLabel = GUILabel::create(labelContent, GUIOptions(GUIOption::fixedWidth(labelWidth)), curLabelStyle);
+			mLabel = GUILabel::create(labelContent, GUIOptions(GUIOption::fixedWidth(labelWidth)), labelStyle);
 			mLayout->addElement(mLabel);
 		}
 
-		const GUIElementStyle* curDropButtonStyle = dropButtonStyle;
-		const GUIElementStyle* curClearButtonStyle = clearButtonStyle;
+		const String* curDropButtonStyle = &dropButtonStyle;
+		const String* curClearButtonStyle = &clearButtonStyle;
 
-		if(curDropButtonStyle == nullptr)
-			curDropButtonStyle = parent.getSkin().getStyle("DropButton");
+		if(*curDropButtonStyle == StringUtil::BLANK)
+			curDropButtonStyle = &DROP_BUTTON_STYLE;
 
-		if(curClearButtonStyle == nullptr)
-			curClearButtonStyle = parent.getSkin().getStyle("ObjectClearButton");
+		if(*curClearButtonStyle == StringUtil::BLANK)
+			curClearButtonStyle = &CLEAR_BUTTON_STYLE;
 
-		mDropButton = GUIDropButton::create((UINT32)DragAndDropType::SceneObject, GUIOptions(GUIOption::flexibleWidth()), curDropButtonStyle);
-		mClearButton = GUIButton::create(HString(L""), curClearButtonStyle);
+		mDropButton = GUIDropButton::create((UINT32)DragAndDropType::SceneObject, GUIOptions(GUIOption::flexibleWidth()), *curDropButtonStyle);
+		mClearButton = GUIButton::create(HString(L""), *curClearButtonStyle);
 
 		mLayout->addElement(mDropButton);
 		mLayout->addElement(mClearButton);
@@ -60,72 +57,72 @@ namespace BansheeEditor
 	}
 
 	GUIGameObjectField* GUIGameObjectField::create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-		BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* dropButtonStyle, BS::GUIElementStyle* clearButtonStyle)
+		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), labelContent, labelWidth, labelStyle, dropButtonStyle, clearButtonStyle,
-			GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle), true);
+			GUILayoutOptions::create(layoutOptions), true);
 	}
 
 	GUIGameObjectField* GUIGameObjectField::create(const BS::GUIContent& labelContent, const BS::GUIOptions& layoutOptions, 
-		BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* dropButtonStyle, BS::GUIElementStyle* clearButtonStyle)
+		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), labelContent, DEFAULT_LABEL_WIDTH, labelStyle, dropButtonStyle, clearButtonStyle,
-			GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle), true);
+			GUILayoutOptions::create(layoutOptions), true);
 	}
 
 	GUIGameObjectField* GUIGameObjectField::create(const CM::HString& labelText, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-		BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* dropButtonStyle, BS::GUIElementStyle* clearButtonStyle)
+		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(labelText), labelWidth, labelStyle, dropButtonStyle, clearButtonStyle,
-			GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle), true);
+			GUILayoutOptions::create(layoutOptions), true);
 	}
 
 	GUIGameObjectField* GUIGameObjectField::create(const CM::HString& labelText, const BS::GUIOptions& layoutOptions, 
-		BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* dropButtonStyle, BS::GUIElementStyle* clearButtonStyle)
+		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, dropButtonStyle, clearButtonStyle, 
-			GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle), true);
+			GUILayoutOptions::create(layoutOptions), true);
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(const BS::GUIOptions& layoutOptions, BS::GUIElementStyle* dropButtonStyle,
-		BS::GUIElementStyle* clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const BS::GUIOptions& layoutOptions, const CM::String& dropButtonStyle,
+		const CM::String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(), 0, nullptr, dropButtonStyle, clearButtonStyle,
-			GUILayoutOptions::create(layoutOptions, &GUISkin::DefaultStyle), false);
+			GUILayoutOptions::create(layoutOptions), false);
 	}
 
 	GUIGameObjectField* GUIGameObjectField::create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, 
-		BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* dropButtonStyle, BS::GUIElementStyle* clearButtonStyle)
+		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), labelContent, labelWidth, labelStyle, dropButtonStyle, clearButtonStyle,
-			GUILayoutOptions::create(&GUISkin::DefaultStyle), true);
+			GUILayoutOptions::create(), true);
 	}
 
 	GUIGameObjectField* GUIGameObjectField::create(const BS::GUIContent& labelContent, 
-		BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* dropButtonStyle, BS::GUIElementStyle* clearButtonStyle)
+		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), labelContent, DEFAULT_LABEL_WIDTH, labelStyle, dropButtonStyle, clearButtonStyle,
-			GUILayoutOptions::create(&GUISkin::DefaultStyle), true);
+			GUILayoutOptions::create(), true);
 	}
 
 	GUIGameObjectField* GUIGameObjectField::create(const CM::HString& labelText, CM::UINT32 labelWidth, 
-		BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* dropButtonStyle, BS::GUIElementStyle* clearButtonStyle)
+		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(labelText), labelWidth, labelStyle, dropButtonStyle, clearButtonStyle,
-			GUILayoutOptions::create(&GUISkin::DefaultStyle), true);
+			GUILayoutOptions::create(), true);
 	}
 
 	GUIGameObjectField* GUIGameObjectField::create(const CM::HString& labelText, 
-		BS::GUIElementStyle* labelStyle, BS::GUIElementStyle* dropButtonStyle, BS::GUIElementStyle* clearButtonStyle)
+		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, dropButtonStyle, clearButtonStyle, 
-			GUILayoutOptions::create(&GUISkin::DefaultStyle), true);
+			GUILayoutOptions::create(), true);
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(BS::GUIElementStyle* dropButtonStyle, BS::GUIElementStyle* clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(), 0, nullptr, dropButtonStyle, clearButtonStyle,
-			GUILayoutOptions::create(&GUISkin::DefaultStyle), false);
+			GUILayoutOptions::create(), false);
 	}
 
 	CM::HGameObject GUIGameObjectField::getValue() const

BansheeEditor/Source/BsGUIIntField.cpp

@@ -20,7 +20,7 @@ namespace BansheeEditor
 	const INT32 GUIIntField::DRAG_SPEED = 5;
 
 	GUIIntField::GUIIntField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
-		GUIElementStyle* labelStyle, GUIElementStyle* inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mInputBox(nullptr), mIsDragging(false),
 		mLastDragPos(0), mIsDragCursorSet(false)
 	{

BansheeEditor/Source/BsGUIMenuBar.cpp

@@ -26,20 +26,19 @@ namespace BansheeEditor
 		mBackgroundArea = GUIArea::create(*parent, 0, 0, 1, 13, 9900);
 		mMainArea = GUIArea::create(*parent, 0, 0, 1, 13, 9899);
 
-		mBgTexture = GUITexture::create(GUIImageScaleMode::StretchToFit, GUIOptions(GUIOption::flexibleWidth(), GUIOption::flexibleHeight()),
-			parent->getSkin().getStyle("MenuBarBg"));
+		mBgTexture = GUITexture::create(GUIImageScaleMode::StretchToFit, GUIOptions(GUIOption::flexibleWidth(), GUIOption::flexibleHeight()), "MenuBarBg");
 		mBackgroundArea->getLayout().addElement(mBgTexture);
 
-		mLogoTexture = GUITexture::create(GUIImageScaleMode::StretchToFit, parent->getSkin().getStyle("MenuBarBansheeLogo"));
+		mLogoTexture = GUITexture::create(GUIImageScaleMode::StretchToFit, "MenuBarBansheeLogo");
 		GUILayout& mainLayout = mMainArea->getLayout();
 
 		mainLayout.addElement(mLogoTexture);
 		mainLayout.addSpace(5);
 		mainLayout.addFlexibleSpace();
 
-		mMinBtn = GUIButton::create(HString(L""), parent->getSkin().getStyle("WinMinimizeBtn"));
-		mMaxBtn = GUIButton::create(HString(L""), parent->getSkin().getStyle("WinMaximizeBtn"));
-		mCloseBtn = GUIButton::create(HString(L""), parent->getSkin().getStyle("WinCloseBtn"));
+		mMinBtn = GUIButton::create(HString(L""), "WinMinimizeBtn");
+		mMaxBtn = GUIButton::create(HString(L""), "WinMaximizeBtn");
+		mCloseBtn = GUIButton::create(HString(L""), "WinCloseBtn");
 
 		mainLayout.addSpace(3);
 		mainLayout.addElement(mMinBtn);
@@ -134,7 +133,7 @@ namespace BansheeEditor
 		newSubMenu.name = name;
 		newSubMenu.menu = cm_new<GUIMenu>();
 
-		GUIButton* newButton = GUIButton::create(HString(name), mParentWidget->getSkin().getStyle("MenuBarBtn"));
+		GUIButton* newButton = GUIButton::create(HString(name), "MenuBarBtn");
 		newButton->onClick.connect(std::bind(&GUIMenuBar::openSubMenu, this, name));
 		newButton->onHover.connect(std::bind(&GUIMenuBar::onSubMenuHover, this, name));
 		mMainArea->getLayout().insertElement(mMainArea->getLayout().getNumChildren() - NUM_ELEMENTS_AFTER_CONTENT, newButton);

BansheeEditor/Source/BsGUIResourceTreeView.cpp

@@ -30,9 +30,9 @@ namespace BansheeEditor
 		resourcePaths = nullptr;
 	}
 
-	GUIResourceTreeView::GUIResourceTreeView(GUIElementStyle* backgroundStyle, GUIElementStyle* elementBtnStyle, 
-		GUIElementStyle* foldoutBtnStyle, GUIElementStyle* selectionBackgroundStyle, GUIElementStyle* editBoxStyle, 
-		BS::GUIElementStyle* dragHighlightStyle, BS::GUIElementStyle* dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
+	GUIResourceTreeView::GUIResourceTreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
+		const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
+		const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
 		:GUITreeView(backgroundStyle, elementBtnStyle, foldoutBtnStyle, selectionBackgroundStyle, editBoxStyle, dragHighlightStyle,
 		dragSepHighlightStyle, layoutOptions), mDraggedResources(nullptr), mCurrentWindow(nullptr), mDropTarget(nullptr), mDropTargetDragActive(false)
 	{
@@ -53,20 +53,20 @@ namespace BansheeEditor
 		clearDropTarget();
 	}
 
-	GUIResourceTreeView* GUIResourceTreeView::create(GUIElementStyle* backgroundStyle, GUIElementStyle* elementBtnStyle, 
-		GUIElementStyle* foldoutBtnStyle, GUIElementStyle* selectionBackgroundStyle, GUIElementStyle* editBoxStyle, GUIElementStyle* dragHighlightStyle, 
-		GUIElementStyle* dragSepHighlightStyle)
+	GUIResourceTreeView* GUIResourceTreeView::create(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
+		const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, const CM::String& dragHighlightStyle, 
+		const CM::String& dragSepHighlightStyle)
 	{
 		return new (cm_alloc<GUIResourceTreeView, PoolAlloc>()) GUIResourceTreeView(backgroundStyle, elementBtnStyle, foldoutBtnStyle, 
-			selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create(&GUISkin::DefaultStyle));
+			selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create());
 	}
 
-	GUIResourceTreeView* GUIResourceTreeView::create(const GUIOptions& options, GUIElementStyle* backgroundStyle,
-		GUIElementStyle* elementBtnStyle, GUIElementStyle* foldoutBtnStyle, GUIElementStyle* selectionBackgroundStyle, 
-		GUIElementStyle* editBoxStyle, GUIElementStyle* dragHighlightStyle, GUIElementStyle* dragSepHighlightStyle)
+	GUIResourceTreeView* GUIResourceTreeView::create(const GUIOptions& options, const CM::String& backgroundStyle,
+		const CM::String& elementBtnStyle, const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, 
+		const CM::String& editBoxStyle, const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle)
 	{
 		return new (cm_alloc<GUIResourceTreeView, PoolAlloc>()) GUIResourceTreeView(backgroundStyle, elementBtnStyle, 
-			foldoutBtnStyle, selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create(options, &GUISkin::DefaultStyle));
+			foldoutBtnStyle, selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create(options));
 	}
 
 	void GUIResourceTreeView::_updateLayoutInternal(INT32 x, INT32 y, UINT32 width, UINT32 height, RectI clipRect, UINT8 widgetDepth, UINT16 areaDepth)

BansheeEditor/Source/BsGUISceneTreeView.cpp

@@ -23,9 +23,9 @@ namespace BansheeEditor
 		objects = nullptr;
 	}
 
-	GUISceneTreeView::GUISceneTreeView(GUIElementStyle* backgroundStyle, GUIElementStyle* elementBtnStyle, 
-		GUIElementStyle* foldoutBtnStyle, GUIElementStyle* selectionBackgroundStyle, GUIElementStyle* editBoxStyle, 
-		BS::GUIElementStyle* dragHighlightStyle, BS::GUIElementStyle* dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
+	GUISceneTreeView::GUISceneTreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
+		const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
+		const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
 		:GUITreeView(backgroundStyle, elementBtnStyle, foldoutBtnStyle, selectionBackgroundStyle, editBoxStyle, dragHighlightStyle,
 		dragSepHighlightStyle, layoutOptions)
 	{
@@ -37,20 +37,20 @@ namespace BansheeEditor
 		
 	}
 
-	GUISceneTreeView* GUISceneTreeView::create(GUIElementStyle* backgroundStyle, GUIElementStyle* elementBtnStyle, 
-		GUIElementStyle* foldoutBtnStyle, GUIElementStyle* selectionBackgroundStyle, GUIElementStyle* editBoxStyle, GUIElementStyle* dragHighlightStyle, 
-		GUIElementStyle* dragSepHighlightStyle)
+	GUISceneTreeView* GUISceneTreeView::create(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
+		const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, const CM::String& dragHighlightStyle, 
+		const CM::String& dragSepHighlightStyle)
 	{
 		return new (cm_alloc<GUISceneTreeView, PoolAlloc>()) GUISceneTreeView(backgroundStyle, elementBtnStyle, foldoutBtnStyle, 
-			selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create(&GUISkin::DefaultStyle));
+			selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create());
 	}
 
-	GUISceneTreeView* GUISceneTreeView::create(const GUIOptions& options, GUIElementStyle* backgroundStyle,
-		GUIElementStyle* elementBtnStyle, GUIElementStyle* foldoutBtnStyle, GUIElementStyle* selectionBackgroundStyle, 
-		GUIElementStyle* editBoxStyle, GUIElementStyle* dragHighlightStyle, GUIElementStyle* dragSepHighlightStyle)
+	GUISceneTreeView* GUISceneTreeView::create(const GUIOptions& options, const CM::String& backgroundStyle,
+		const CM::String& elementBtnStyle, const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, 
+		const CM::String& editBoxStyle, const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle)
 	{
 		return new (cm_alloc<GUISceneTreeView, PoolAlloc>()) GUISceneTreeView(backgroundStyle, elementBtnStyle, 
-			foldoutBtnStyle, selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create(options, &GUISkin::DefaultStyle));
+			foldoutBtnStyle, selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create(options));
 	}
 
 	void GUISceneTreeView::updateTreeElement(SceneTreeElement* element)

BansheeEditor/Source/BsGUITabButton.cpp

@@ -18,30 +18,39 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUITabButton::GUITabButton(const GUIElementStyle* style, const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const GUIContent& content, const GUILayoutOptions& layoutOptions)
-		:GUIToggle(style, content, toggleGroup, layoutOptions), mIndex(index), mDraggedState(false)
+	GUITabButton::GUITabButton(const CM::String& styleName, const GUIToggleGroupPtr& toggleGroup, 
+		CM::UINT32 index, const GUIContent& content, const GUILayoutOptions& layoutOptions)
+		:GUIToggle(styleName, content, toggleGroup, layoutOptions), mIndex(index), mDraggedState(false)
 	{
 
 	}
 
-	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const HString& text, const GUIElementStyle* style)
+	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, 
+		const HString& text, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(style, toggleGroup, index, GUIContent(text), GUILayoutOptions::create(style));
+		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(
+			getStyleName<GUITabButton>(styleName), toggleGroup, index, GUIContent(text), GUILayoutOptions::create());
 	}
 
-	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const HString& text, const GUIOptions& layoutOptions, const GUIElementStyle* style)
+	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, 
+		const HString& text, const GUIOptions& layoutOptions, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(style, toggleGroup, index, GUIContent(text), GUILayoutOptions::create(layoutOptions, style));
+		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(
+			getStyleName<GUITabButton>(styleName), toggleGroup, index, GUIContent(text), GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const GUIContent& content, const GUIElementStyle* style)
+	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, 
+		const GUIContent& content, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(style, toggleGroup, index, content, GUILayoutOptions::create(style));
+		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(
+			getStyleName<GUITabButton>(styleName), toggleGroup, index, content, GUILayoutOptions::create());
 	}
 
-	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const GUIContent& content, const GUIOptions& layoutOptions, const GUIElementStyle* style)
+	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, 
+		const GUIContent& content, const GUIOptions& layoutOptions, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(style, toggleGroup, index, content, GUILayoutOptions::create(layoutOptions, style));
+		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(
+			getStyleName<GUITabButton>(styleName), toggleGroup, index, content, GUILayoutOptions::create(layoutOptions));
 	}
 
 	void GUITabButton::_setDraggedState(bool active) 

BansheeEditor/Source/BsGUITabbedTitleBar.cpp

@@ -23,25 +23,25 @@ namespace BansheeEditor
 	const UINT32 GUITabbedTitleBar::TAB_SPACING = 20;
 	const UINT32 GUITabbedTitleBar::OPTION_BTN_SPACING = 3;
 
-	GUITabbedTitleBar::GUITabbedTitleBar(RenderWindow* parentWindow, GUIElementStyle* backgroundStyle, GUIElementStyle* tabBtnStyle, 
-		GUIElementStyle* minBtnStyle, GUIElementStyle* closeBtnStyle, const GUILayoutOptions& layoutOptions)
+	GUITabbedTitleBar::GUITabbedTitleBar(RenderWindow* parentWindow, const CM::String& backgroundStyle, const CM::String& tabBtnStyle, 
+		const CM::String& minBtnStyle, const CM::String& closeBtnStyle, const GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mParentWindow(parentWindow), mMinBtn(nullptr), 
 		mCloseBtn(nullptr), mBackgroundImage(nullptr), mUniqueTabIdx(0), mActiveTabIdx(0),
 		mDragInProgress(false), mDraggedBtn(nullptr), mDragBtnOffset(0), mInitialDragOffset(0), mBackgroundStyle(backgroundStyle),
 		mTabBtnStyle(tabBtnStyle), mMinimizeBtnStyle(minBtnStyle), mCloseBtnStyle(closeBtnStyle), mTempDraggedWidget(nullptr),
 		mTempDraggedTabIdx(0)
 	{
-		if(mBackgroundStyle == nullptr)
-			mBackgroundStyle = parent.getSkin().getStyle("TitleBarBackground");
+		if(mBackgroundStyle == CM::StringUtil::BLANK)
+			mBackgroundStyle = "TitleBarBackground";
 
-		if(mMinimizeBtnStyle == nullptr)
-			mMinimizeBtnStyle = parent.getSkin().getStyle("WinMinimizeBtn");
+		if(mMinimizeBtnStyle == CM::StringUtil::BLANK)
+			mMinimizeBtnStyle = "WinMinimizeBtn";
 
-		if(mCloseBtnStyle == nullptr)
-			mCloseBtnStyle = parent.getSkin().getStyle("WinCloseBtn");
+		if(mCloseBtnStyle == CM::StringUtil::BLANK)
+			mCloseBtnStyle = "WinCloseBtn";
 
-		if(mTabBtnStyle == nullptr)
-			mTabBtnStyle = parent.getSkin().getStyle("TabbedBarBtn");
+		if(mTabBtnStyle == CM::StringUtil::BLANK)
+			mTabBtnStyle = "TabbedBarBtn";
 
 		mBackgroundImage = GUITexture::create(mBackgroundStyle);
 		_registerChildElement(mBackgroundImage);
@@ -62,21 +62,15 @@ namespace BansheeEditor
 
 	}
 
-	GUITabbedTitleBar* GUITabbedTitleBar::create(RenderWindow* parentWindow, GUIElementStyle* backgroundStyle, 
-		GUIElementStyle* tabBtnStyle, GUIElementStyle* minBtnStyle, GUIElementStyle* closeBtnStyle)
+	GUITabbedTitleBar* GUITabbedTitleBar::create(RenderWindow* parentWindow, const CM::String& backgroundStyle, 
+		const CM::String& tabBtnStyle, const CM::String& minBtnStyle, const CM::String& closeBtnStyle)
 	{
 		return new (cm_alloc<GUITabbedTitleBar, PoolAlloc>()) GUITabbedTitleBar(parentWindow, backgroundStyle, tabBtnStyle, 
-			minBtnStyle, closeBtnStyle, GUILayoutOptions::create(&GUISkin::DefaultStyle));
-	}
-
-	GUITabbedTitleBar* GUITabbedTitleBar::create(RenderWindow* parentWindow, const GUILayoutOptions& layoutOptions)
-	{
-		return new (cm_alloc<GUITabbedTitleBar, PoolAlloc>()) GUITabbedTitleBar(parentWindow, nullptr, nullptr, 
-			nullptr, nullptr, layoutOptions);
+			minBtnStyle, closeBtnStyle, GUILayoutOptions::create());
 	}
 
 	GUITabbedTitleBar* GUITabbedTitleBar::create(RenderWindow* parentWindow, const GUILayoutOptions& layoutOptions, 
-		GUIElementStyle* backgroundStyle, GUIElementStyle* tabBtnStyle, GUIElementStyle* minBtnStyle, GUIElementStyle* closeBtnStyle)
+		const CM::String& backgroundStyle, const CM::String& tabBtnStyle, const CM::String& minBtnStyle, const CM::String& closeBtnStyle)
 	{
 		return new (cm_alloc<GUITabbedTitleBar, PoolAlloc>()) GUITabbedTitleBar(parentWindow, backgroundStyle, tabBtnStyle, 
 			minBtnStyle, closeBtnStyle, layoutOptions);

BansheeEditor/Source/BsGUITextField.cpp

@@ -14,7 +14,7 @@ using namespace BansheeEngine;
 namespace BansheeEditor
 {
 	GUITextField::GUITextField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, CM::UINT32 labelWidth, 
-		GUIElementStyle* labelStyle, GUIElementStyle* inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mInputBox(nullptr)
 	{
 		mInputBox = GUIInputBox::create(false, inputBoxStyle);

BansheeEditor/Source/BsGUIToggleField.cpp

@@ -14,7 +14,7 @@ using namespace BansheeEngine;
 namespace BansheeEditor
 {
 	GUIToggleField::GUIToggleField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-		UINT32 labelWidth, GUIElementStyle* labelStyle, GUIElementStyle* toggleStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		UINT32 labelWidth, const CM::String& labelStyle, const CM::String& toggleStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mToggle(nullptr)
 	{
 		mToggle = GUIToggle::create(HString(L""), toggleStyle);

BansheeEditor/Source/BsGUITreeView.cpp

@@ -82,35 +82,35 @@ namespace BansheeEditor
 		return nullptr;
 	}
 
-	GUITreeView::GUITreeView(GUIElementStyle* backgroundStyle, GUIElementStyle* elementBtnStyle, 
-		GUIElementStyle* foldoutBtnStyle, GUIElementStyle* selectionBackgroundStyle, GUIElementStyle* editBoxStyle, 
-		BS::GUIElementStyle* dragHighlightStyle, BS::GUIElementStyle* dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
+	GUITreeView::GUITreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
+		const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
+		const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mBackgroundStyle(backgroundStyle),
 		mElementBtnStyle(elementBtnStyle), mFoldoutBtnStyle(foldoutBtnStyle), mEditBoxStyle(editBoxStyle), mEditElement(nullptr), mIsElementSelected(false),
 		mNameEditBox(nullptr), mSelectionBackgroundStyle(selectionBackgroundStyle), mDragInProgress(nullptr), mDragHighlightStyle(dragHighlightStyle),
 		mDragSepHighlightStyle(dragSepHighlightStyle), mDragHighlight(nullptr), mDragSepHighlight(nullptr), mMouseOverDragElement(nullptr), mMouseOverDragElementTime(0.0f),
 		mScrollState(ScrollState::None), mLastScrollTime(0.0f)
 	{
-		if(mBackgroundStyle == nullptr)
-			mBackgroundStyle = parent.getSkin().getStyle("TreeViewBackground");
+		if(mBackgroundStyle == CM::StringUtil::BLANK)
+			mBackgroundStyle = "TreeViewBackground";
 
-		if(mElementBtnStyle == nullptr)
-			mElementBtnStyle = parent.getSkin().getStyle("TreeViewElementBtn");
+		if(mElementBtnStyle == CM::StringUtil::BLANK)
+			mElementBtnStyle = "TreeViewElementBtn";
 
-		if(mFoldoutBtnStyle == nullptr)
-			mFoldoutBtnStyle = parent.getSkin().getStyle("TreeViewFoldoutBtn");
+		if(mFoldoutBtnStyle == CM::StringUtil::BLANK)
+			mFoldoutBtnStyle = "TreeViewFoldoutBtn";
 
-		if(mSelectionBackgroundStyle == nullptr)
-			mSelectionBackgroundStyle = parent.getSkin().getStyle("TreeViewSelectionBackground");
+		if(mSelectionBackgroundStyle == CM::StringUtil::BLANK)
+			mSelectionBackgroundStyle = "TreeViewSelectionBackground";
 
-		if(mEditBoxStyle == nullptr)
-			mEditBoxStyle = parent.getSkin().getStyle("TreeViewEditBox");
+		if(mEditBoxStyle == CM::StringUtil::BLANK)
+			mEditBoxStyle = "TreeViewEditBox";
 
-		if(mDragHighlightStyle == nullptr)
-			mDragHighlightStyle = parent.getSkin().getStyle("TreeViewElementHighlight");
+		if(mDragHighlightStyle == CM::StringUtil::BLANK)
+			mDragHighlightStyle = "TreeViewElementHighlight";
 
-		if(mDragSepHighlightStyle == nullptr)
-			mDragSepHighlightStyle = parent.getSkin().getStyle("TreeViewElementSepHighlight");
+		if(mDragSepHighlightStyle == CM::StringUtil::BLANK)
+			mDragSepHighlightStyle = "TreeViewElementSepHighlight";
 
 		mBackgroundImage = GUITexture::create(mBackgroundStyle);
 		mNameEditBox = GUITreeViewEditBox::create(mEditBoxStyle);

BansheeEditor/Source/BsGUITreeViewEditBox.cpp

@@ -14,18 +14,18 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUITreeViewEditBox* GUITreeViewEditBox::create(const BS::GUIElementStyle* style)
+	GUITreeViewEditBox* GUITreeViewEditBox::create(const CM::String& styleName)
 	{
-		return new (cm_alloc<GUITreeViewEditBox, PoolAlloc>()) GUITreeViewEditBox(style, GUILayoutOptions::create(style));
+		return new (cm_alloc<GUITreeViewEditBox, PoolAlloc>()) GUITreeViewEditBox(getStyleName<GUITreeViewEditBox>(styleName), GUILayoutOptions::create());
 	}
 
-	GUITreeViewEditBox* GUITreeViewEditBox::create(const BS::GUIOptions& layoutOptions, const BS::GUIElementStyle* style)
+	GUITreeViewEditBox* GUITreeViewEditBox::create(const BS::GUIOptions& layoutOptions, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUITreeViewEditBox, PoolAlloc>()) GUITreeViewEditBox(style, GUILayoutOptions::create(layoutOptions, style));
+		return new (cm_alloc<GUITreeViewEditBox, PoolAlloc>()) GUITreeViewEditBox(getStyleName<GUITreeViewEditBox>(styleName), GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUITreeViewEditBox::GUITreeViewEditBox(const BS::GUIElementStyle* style, const BS::GUILayoutOptions& layoutOptions)
-		:GUIInputBox(style, layoutOptions, false)
+	GUITreeViewEditBox::GUITreeViewEditBox(const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions)
+		:GUIInputBox(styleName, layoutOptions, false)
 	{
 
 	}

BansheeEditor/Source/BsGUIVector2Field.cpp

@@ -16,7 +16,7 @@ namespace BansheeEditor
 	const UINT32 GUIVector2Field::ELEMENT_LABEL_WIDTH = 10;
 
 	GUIVector2Field::GUIVector2Field(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-		CM::UINT32 labelWidth, GUIElementStyle* labelStyle, GUIElementStyle* inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		CM::UINT32 labelWidth, const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mFieldX(nullptr), mFieldY(nullptr)
 	{
 		mFieldX = GUIFloatField::create(HString(L"X"), ELEMENT_LABEL_WIDTH, labelStyle, inputBoxStyle);

BansheeEditor/Source/BsGUIVector3Field.cpp

@@ -16,7 +16,7 @@ namespace BansheeEditor
 	const UINT32 GUIVector3Field::ELEMENT_LABEL_WIDTH = 10;
 
 	GUIVector3Field::GUIVector3Field(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-		CM::UINT32 labelWidth, GUIElementStyle* labelStyle, GUIElementStyle* inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		CM::UINT32 labelWidth, const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mFieldX(nullptr), mFieldY(nullptr)
 	{
 		mFieldX = GUIFloatField::create(HString(L"X"), ELEMENT_LABEL_WIDTH, labelStyle, inputBoxStyle);

BansheeEditor/Source/BsGUIVector4Field.cpp

@@ -16,7 +16,7 @@ namespace BansheeEditor
 	const UINT32 GUIVector4Field::ELEMENT_LABEL_WIDTH = 10;
 
 	GUIVector4Field::GUIVector4Field(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-		CM::UINT32 labelWidth, GUIElementStyle* labelStyle, GUIElementStyle* inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		CM::UINT32 labelWidth, const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mFieldX(nullptr), mFieldY(nullptr)
 	{
 		mFieldX = GUIFloatField::create(HString(L"X"), ELEMENT_LABEL_WIDTH, labelStyle, inputBoxStyle);

BansheeEditor/Source/BsGUIWindowDropArea.cpp

@@ -18,21 +18,23 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUIWindowDropArea::GUIWindowDropArea(const GUIElementStyle* style, const GUILayoutOptions& layoutOptions)
-		:GUITexture(style, HSpriteTexture(), GUIImageScaleMode::ScaleToFit, layoutOptions)
+	GUIWindowDropArea::GUIWindowDropArea(const CM::String& styleName, const GUILayoutOptions& layoutOptions)
+		:GUITexture(styleName, HSpriteTexture(), GUIImageScaleMode::ScaleToFit, layoutOptions)
 	{ }
 
 	GUIWindowDropArea::~GUIWindowDropArea()
 	{ }
 
-	GUIWindowDropArea* GUIWindowDropArea::create(const GUIElementStyle* style)
+	GUIWindowDropArea* GUIWindowDropArea::create(const CM::String& styleName)
 	{
-		return new (cm_alloc<GUIWindowDropArea, PoolAlloc>()) GUIWindowDropArea(style, GUILayoutOptions::create(style));
+		return new (cm_alloc<GUIWindowDropArea, PoolAlloc>()) 
+			GUIWindowDropArea(getStyleName<GUIWindowDropArea>(styleName), GUILayoutOptions::create());
 	}
 
-	GUIWindowDropArea* GUIWindowDropArea::create(const GUIOptions& layoutOptions, const GUIElementStyle* style)
+	GUIWindowDropArea* GUIWindowDropArea::create(const GUIOptions& layoutOptions, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUIWindowDropArea, PoolAlloc>()) GUIWindowDropArea(style, GUILayoutOptions::create(layoutOptions, style));
+		return new (cm_alloc<GUIWindowDropArea, PoolAlloc>()) 
+			GUIWindowDropArea(getStyleName<GUIWindowDropArea>(styleName), GUILayoutOptions::create(layoutOptions));
 	}
 
 	void GUIWindowDropArea::setFocused(bool focused)

BansheeEditor/Source/BsGUIWindowFrame.cpp

@@ -21,8 +21,8 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUIWindowFrame::GUIWindowFrame(const GUIElementStyle* style, const GUILayoutOptions& layoutOptions)
-		:GUITexture(style, HSpriteTexture(), GUIImageScaleMode::StretchToFit, layoutOptions)
+	GUIWindowFrame::GUIWindowFrame(const CM::String& styleName, const GUILayoutOptions& layoutOptions)
+		:GUITexture(styleName, HSpriteTexture(), GUIImageScaleMode::StretchToFit, layoutOptions)
 	{
 
 	}
@@ -30,14 +30,14 @@ namespace BansheeEditor
 	GUIWindowFrame::~GUIWindowFrame()
 	{ }
 
-	GUIWindowFrame* GUIWindowFrame::create(const GUIElementStyle* style)
+	GUIWindowFrame* GUIWindowFrame::create(const CM::String& styleName)
 	{
-		return new (cm_alloc<GUIWindowFrame, PoolAlloc>()) GUIWindowFrame(style, GUILayoutOptions::create(style));
+		return new (cm_alloc<GUIWindowFrame, PoolAlloc>()) GUIWindowFrame(getStyleName<GUIWindowFrame>(styleName), GUILayoutOptions::create());
 	}
 
-	GUIWindowFrame* GUIWindowFrame::create(const GUIOptions& layoutOptions, const GUIElementStyle* style)
+	GUIWindowFrame* GUIWindowFrame::create(const GUIOptions& layoutOptions, const CM::String& styleName)
 	{
-		return new (cm_alloc<GUIWindowFrame, PoolAlloc>()) GUIWindowFrame(style, GUILayoutOptions::create(layoutOptions, style));
+		return new (cm_alloc<GUIWindowFrame, PoolAlloc>()) GUIWindowFrame(getStyleName<GUIWindowFrame>(styleName), GUILayoutOptions::create(layoutOptions));
 	}
 
 	void GUIWindowFrame::setFocused(bool focused)

BansheeEditor/Source/BsGUIWindowFrameWidget.cpp

@@ -23,11 +23,11 @@ namespace BansheeEditor
 
 		GUIArea* backgroundArea = GUIArea::createStretchedXY(*this, 0, 0, 0, 0, 500);
 		backgroundArea->getLayout().addElement(GUITexture::create(GUIImageScaleMode::RepeatToFit, 
-			GUIOptions(GUIOption::flexibleWidth(), GUIOption::flexibleHeight()), getSkin().getStyle("WindowBackground")));
+			GUIOptions(GUIOption::flexibleWidth(), GUIOption::flexibleHeight()), "WindowBackground"));
 
 		mWindowFrameArea = GUIArea::createStretchedXY(*this, 0, 0, 0, 0, 499);
 
-		mWindowFrame = GUIWindowFrame::create(getSkin().getStyle("WindowFrame"));
+		mWindowFrame = GUIWindowFrame::create("WindowFrame");
 		mWindowFrameArea->getLayout().addElement(mWindowFrame);
 
 		refreshNonClientAreas();

Inspector.txt

@@ -28,33 +28,11 @@ REFACTOR c++ GUI a bit:
    - When dragging over GameObjectField cursor needs to change depending whether drop will be accepted or not
    - How will I limit it to just certain component types?
 
-Refactor GUIElements so that they don't require GUIwidget on creation
-Hide "mStyle"
- - Replace it with getStyle()
-   - If custom style is set always return that
-   - If widget is set return widget style
-   - Otherwise return dummy style
- - Need to ensure that anything that uses mStyle is constantly refreshed instead of just queried once during construction
-
-GUIScrollBar uses parent.GetSkin - need to get around that
- - Likely a method like _overrideDefaultStyleName()
- - Or just inherit the type if its only for a couple of buttons?
- - OR PROBABLY replace current GUIElementStyle parameter with a string overriding the default style
- - Also using it:
-   - GUIFoldout
-   - GUITreeView
-   - GUITabbedTitleBar
-   - GUIGameObjectField
-
-DockManager was retrieving a viewport from the parent widget. Provide it manually?
-
 Make a common class for ScriptGUIElement as they all share:
  - Destroy(), DestroyInstance(), SetParent(), SetVisible() methods, and potentially others
 
 Add InsertElement to GUILayout
 
-
-
 -------------
 Implementation order:
  - Component foldout