From 2b19c80a7e1c5522538734bc7ee18a38e94d50a9 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Thu, 13 Apr 2017 16:19:35 +0800
Subject: [PATCH 01/17] Create header and source

---
 MiniEngine_Xml.cpp | 1 +
 MiniEngine_Xml.h   | 3 +++
 2 files changed, 4 insertions(+)
 create mode 100644 MiniEngine_Xml.cpp
 create mode 100644 MiniEngine_Xml.h

diff --git a/MiniEngine_Xml.cpp b/MiniEngine_Xml.cpp
new file mode 100644
index 0000000..7c31e77
--- /dev/null
+++ b/MiniEngine_Xml.cpp
@@ -0,0 +1 @@
+#include "MiniEngine_Xml.h"
diff --git a/MiniEngine_Xml.h b/MiniEngine_Xml.h
new file mode 100644
index 0000000..a5f1a4d
--- /dev/null
+++ b/MiniEngine_Xml.h
@@ -0,0 +1,3 @@
+#pragma once
+#include "MiniEngine.h"
+

From f9c2e872df47a6fc90fb0dfab43d94d15066bb22 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Thu, 13 Apr 2017 20:28:16 +0800
Subject: [PATCH 02/17] Change rapidxml header to avoid compile errors

---
 rapidxml/rapidxml_print.hpp | 76 +++++++++++++++++++++++++++----------
 1 file changed, 55 insertions(+), 21 deletions(-)

diff --git a/rapidxml/rapidxml_print.hpp b/rapidxml/rapidxml_print.hpp
index d03d5f5..718db5f 100644
--- a/rapidxml/rapidxml_print.hpp
+++ b/rapidxml/rapidxml_print.hpp
@@ -28,10 +28,10 @@ namespace rapidxml
     //! \cond internal
     namespace internal
     {
-        
+
         ///////////////////////////////////////////////////////////////////////////
         // Internal character operations
-    
+
         // Copy characters from given range to given output iterator
         template<class OutIt, class Ch>
         inline OutIt copy_chars(const Ch *begin, const Ch *end, OutIt out)
@@ -40,7 +40,7 @@ namespace rapidxml
                 *out++ = *begin++;
             return out;
         }
-        
+
         // Copy characters from given range to given output iterator and expand
         // characters into references (&lt; &gt; &apos; &quot; &amp;)
         template<class OutIt, class Ch>
@@ -59,17 +59,17 @@ namespace rapidxml
                     case Ch('<'):
                         *out++ = Ch('&'); *out++ = Ch('l'); *out++ = Ch('t'); *out++ = Ch(';');
                         break;
-                    case Ch('>'): 
+                    case Ch('>'):
                         *out++ = Ch('&'); *out++ = Ch('g'); *out++ = Ch('t'); *out++ = Ch(';');
                         break;
-                    case Ch('\''): 
+                    case Ch('\''):
                         *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('p'); *out++ = Ch('o'); *out++ = Ch('s'); *out++ = Ch(';');
                         break;
-                    case Ch('"'): 
+                    case Ch('"'):
                         *out++ = Ch('&'); *out++ = Ch('q'); *out++ = Ch('u'); *out++ = Ch('o'); *out++ = Ch('t'); *out++ = Ch(';');
                         break;
-                    case Ch('&'): 
-                        *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('m'); *out++ = Ch('p'); *out++ = Ch(';'); 
+                    case Ch('&'):
+                        *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('m'); *out++ = Ch('p'); *out++ = Ch(';');
                         break;
                     default:
                         *out++ = *begin;    // No expansion, copy character
@@ -101,7 +101,41 @@ namespace rapidxml
 
         ///////////////////////////////////////////////////////////////////////////
         // Internal printing operations
-    
+
+        /// Forward Declaration : Fix Compile Bug in MinGW
+        template<class OutIt, class Ch>
+        inline OutIt print_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);
+
+        template<class OutIt, class Ch>
+        inline OutIt print_children(OutIt out, const xml_node<Ch> *node, int flags, int indent);
+
+        template<class OutIt, class Ch>
+        inline OutIt print_attributes(OutIt out, const xml_node<Ch> *node, int flags);
+
+        template<class OutIt, class Ch>
+        inline OutIt print_data_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);
+
+        template<class OutIt, class Ch>
+        inline OutIt print_cdata_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);
+
+        template<class OutIt, class Ch>
+        inline OutIt print_element_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);
+
+        template<class OutIt, class Ch>
+        inline OutIt print_declaration_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);
+
+        template<class OutIt, class Ch>
+        inline OutIt print_comment_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);
+
+        template<class OutIt, class Ch>
+        inline OutIt print_doctype_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);
+
+        template<class OutIt, class Ch>
+        inline OutIt print_pi_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);
+
+
+
+
         // Print node
         template<class OutIt, class Ch>
         inline OutIt print_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
@@ -119,12 +153,12 @@ namespace rapidxml
             case node_element:
                 out = print_element_node(out, node, flags, indent);
                 break;
-            
+
             // Data
             case node_data:
                 out = print_data_node(out, node, flags, indent);
                 break;
-            
+
             // CDATA
             case node_cdata:
                 out = print_cdata_node(out, node, flags, indent);
@@ -139,7 +173,7 @@ namespace rapidxml
             case node_comment:
                 out = print_comment_node(out, node, flags, indent);
                 break;
-            
+
             // Doctype
             case node_doctype:
                 out = print_doctype_node(out, node, flags, indent);
@@ -155,7 +189,7 @@ namespace rapidxml
                 assert(0);
                 break;
             }
-            
+
             // If indenting not disabled, add line break after node
             if (!(flags & print_no_indenting))
                 *out = Ch('\n'), ++out;
@@ -163,8 +197,8 @@ namespace rapidxml
             // Return modified iterator
             return out;
         }
-        
-        // Print children of the node                               
+
+        // Print children of the node
         template<class OutIt, class Ch>
         inline OutIt print_children(OutIt out, const xml_node<Ch> *node, int flags, int indent)
         {
@@ -249,7 +283,7 @@ namespace rapidxml
             *out = Ch('<'), ++out;
             out = copy_chars(node->name(), node->name() + node->name_size(), out);
             out = print_attributes(out, node, flags);
-            
+
             // If node is childless
             if (node->value_size() == 0 && !node->first_node())
             {
@@ -308,11 +342,11 @@ namespace rapidxml
 
             // Print attributes
             out = print_attributes(out, node, flags);
-            
+
             // Print declaration end
             *out = Ch('?'), ++out;
             *out = Ch('>'), ++out;
-            
+
             return out;
         }
 
@@ -384,7 +418,7 @@ namespace rapidxml
     //! \param node Node to be printed. Pass xml_document to print entire document.
     //! \param flags Flags controlling how XML is printed.
     //! \return Output iterator pointing to position immediately after last character of printed text.
-    template<class OutIt, class Ch> 
+    template<class OutIt, class Ch>
     inline OutIt print(OutIt out, const xml_node<Ch> &node, int flags = 0)
     {
         return internal::print_node(out, &node, flags, 0);
@@ -397,7 +431,7 @@ namespace rapidxml
     //! \param node Node to be printed. Pass xml_document to print entire document.
     //! \param flags Flags controlling how XML is printed.
     //! \return Output stream.
-    template<class Ch> 
+    template<class Ch>
     inline std::basic_ostream<Ch> &print(std::basic_ostream<Ch> &out, const xml_node<Ch> &node, int flags = 0)
     {
         print(std::ostream_iterator<Ch>(out), node, flags);
@@ -408,7 +442,7 @@ namespace rapidxml
     //! \param out Output stream to print to.
     //! \param node Node to be printed.
     //! \return Output stream.
-    template<class Ch> 
+    template<class Ch>
     inline std::basic_ostream<Ch> &operator <<(std::basic_ostream<Ch> &out, const xml_node<Ch> &node)
     {
         return print(out, node);

From b40db11955b60080aab295d8e092e75099eb27d1 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Tue, 16 May 2017 15:23:34 +0800
Subject: [PATCH 03/17] Query of font size is supported

---
 MiniEngine.cpp | 22 ++++++++++++++++++++++
 MiniEngine.h   |  3 +++
 2 files changed, 25 insertions(+)

diff --git a/MiniEngine.cpp b/MiniEngine.cpp
index 283bcd6..0287cd3 100644
--- a/MiniEngine.cpp
+++ b/MiniEngine.cpp
@@ -1164,6 +1164,28 @@ namespace MiniEngine
         return 0;
     }
 
+    Rect Font::sizeText(const std::string& Text) throw (ErrorViewer)
+    {
+        int w=0,h=0;
+        if(TTF_SizeText(_get(),Text.c_str(),&w,&h)!=0)
+        {
+            /// Something might be wrong
+            throw ErrorViewer();
+        }
+        return Rect(0,0,w,h);
+    }
+
+    Rect Font::sizeUTF8(const std::string& Text) throw (ErrorViewer)
+    {
+        int w=0,h=0;
+        if(TTF_SizeUTF8(_get(),Text.c_str(),&w,&h)!=0)
+        {
+            /// Something might be wrong
+            throw ErrorViewer();
+        }
+        return Rect(0,0,w,h);
+    }
+
     /// rendering surfaces...
     Surface Font::renderText(std::string Text,RGBA fg)
     {
diff --git a/MiniEngine.h b/MiniEngine.h
index 4f09bc4..c74064e 100644
--- a/MiniEngine.h
+++ b/MiniEngine.h
@@ -373,6 +373,9 @@ namespace MiniEngine
 
 		std::tuple<Style> getFontStyles();
 
+        Rect sizeText(const std::string& Text) throw (ErrorViewer);
+        Rect sizeUTF8(const std::string& Text) throw (ErrorViewer);
+
 		Surface renderText(std::string Text, RGBA fg);
 		Surface renderTextWrapped(std::string Text, RGBA fg, int WrapLength);
 		Surface renderTextShaded(std::string Text, RGBA fg, RGBA bg);

From 00a3000d1d31d3dc1fd710f0eefebcdc5b3c8ae7 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Tue, 16 May 2017 15:52:00 +0800
Subject: [PATCH 04/17] Fix bug in Font::setFontStyle

---
 MiniEngine.h | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/MiniEngine.h b/MiniEngine.h
index c74064e..00cfa1d 100644
--- a/MiniEngine.h
+++ b/MiniEngine.h
@@ -362,13 +362,14 @@ namespace MiniEngine
 		template<typename... Args>
 		void setFontStyle(Style style,Args&&... args)
 		{
-            _internal_fontcalc=0;
-            _setFontStyle(style,std::forward(args...));
+		    int fontcalc=0;
+		    _setFontStyle(fontcalc,style,args...);
 		}
 
 		void setFontStyle(Style style)
 		{
-            _real_setFontStyle(_style_caster(style));
+            int fontcalc=0;
+            _setFontStyle(fontcalc,style);
 		}
 
 		std::tuple<Style> getFontStyles();
@@ -397,21 +398,20 @@ namespace MiniEngine
 		Texture renderUTF8Solid(Renderer rnd, std::string Text, RGBA fg);
     protected:
 		template<typename... Args>
-        void _setFontStyle(Style style,Args&&... args)
+        void _setFontStyle(int& fontcalc,Style style,Args&&... args)
         {
-            _internal_fontcalc|=_style_caster(style);
-            _setFontStyle(args...);
+            fontcalc|=_style_caster(style);
+            _setFontStyle(fontcalc,args...);
         }
 
-        void _setFontStyle(Style style)
+        void _setFontStyle(int& fontcalc,Style style)
         {
-            _internal_fontcalc|=_style_caster(style);
-            _real_setFontStyle(_internal_fontcalc);
+            fontcalc|=_style_caster(style);
+            _real_setFontStyle(fontcalc);
         }
 	private:
 	    void _real_setFontStyle(int);
 	    int _style_caster(Style);
-        int _internal_fontcalc;
 
 		std::shared_ptr<TTF_Font> _font;
 		void _set(TTF_Font*);

From 6901b0054cdde5563fe2f8cfdb593e73e6707de8 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Tue, 16 May 2017 16:23:40 +0800
Subject: [PATCH 05/17] Add font style single-query methods

---
 MiniEngine.cpp | 129 +++++++++++++++++++++++++++++++++++++++++++------
 MiniEngine.h   |  15 +++++-
 2 files changed, 128 insertions(+), 16 deletions(-)

diff --git a/MiniEngine.cpp b/MiniEngine.cpp
index 0287cd3..c7b9bd1 100644
--- a/MiniEngine.cpp
+++ b/MiniEngine.cpp
@@ -116,6 +116,52 @@ namespace MiniEngine
                 return SDL_SYSTEM_CURSOR_ARROW;
             }
         }
+
+        int getTTFFontStyleFromFontStyle(Font::Style style)
+        {
+            switch(style)
+            {
+            case Font::Style::Bold:
+                return TTF_STYLE_BOLD;
+            case Font::Style::Italic:
+                return TTF_STYLE_ITALIC;
+            case Font::Style::Normal:
+                return TTF_STYLE_NORMAL;
+            case Font::Style::StrikeThrough:
+                return TTF_STYLE_STRIKETHROUGH;
+            case Font::Style::UnderLine:
+                return TTF_STYLE_UNDERLINE;
+            default:
+                return TTF_STYLE_NORMAL;
+            }
+        }
+
+        std::vector<Font::Style> getFontStyleVecFromMixedTTFFontStyle(int Mixed_TTF_Font_Style)
+        {
+            std::vector<Font::Style> vec;
+            if(Mixed_TTF_Font_Style&TTF_STYLE_BOLD)
+            {
+                vec.push_back(Font::Style::Bold);
+            }
+            if(Mixed_TTF_Font_Style&TTF_STYLE_ITALIC)
+            {
+                vec.push_back(Font::Style::Italic);
+            }
+            if(Mixed_TTF_Font_Style&TTF_STYLE_STRIKETHROUGH)
+            {
+                vec.push_back(Font::Style::StrikeThrough);
+            }
+            if(Mixed_TTF_Font_Style&TTF_STYLE_UNDERLINE)
+            {
+                vec.push_back(Font::Style::UnderLine);
+            }
+            if(vec.empty())
+            {
+                vec.push_back(Font::Style::Normal);
+            }
+
+            return vec;
+        }
     }/// End of namespace _internal
 
 	Rect::Rect(int X, int Y, int W, int H)
@@ -1139,6 +1185,68 @@ namespace MiniEngine
 		return (_get() != nullptr);
 	}
 
+    bool Font::isNormal()
+    {
+        return !(TTF_GetFontStyle(_get()));
+    }
+
+    bool Font::isBold()
+    {
+        return (TTF_GetFontStyle(_get()) & TTF_STYLE_BOLD );
+    }
+
+    bool Font::isItalic()
+    {
+        return (TTF_GetFontStyle(_get()) & TTF_STYLE_ITALIC );
+    }
+
+    bool Font::isUnderLine()
+    {
+        return (TTF_GetFontStyle(_get()) & TTF_STYLE_UNDERLINE );
+    }
+
+    bool Font::isStrikeThrough()
+    {
+        return (TTF_GetFontStyle(_get()) & TTF_STYLE_STRIKETHROUGH );
+    }
+
+    void Font::setNormal()
+    {
+        _real_setFontStyle(TTF_STYLE_NORMAL);
+    }
+
+    void Font::setBold(bool enable)
+    {
+        if( enable!=isBold() )
+        {
+            _real_setFontStyle( TTF_GetFontStyle(_get()) | (enable?TTF_STYLE_BOLD:!TTF_STYLE_BOLD) );
+        }
+    }
+
+    void Font::setItalic(bool enable)
+    {
+        if( enable!=isItalic() )
+        {
+            _real_setFontStyle( TTF_GetFontStyle(_get()) | (enable?TTF_STYLE_ITALIC:!TTF_STYLE_ITALIC) );
+        }
+    }
+
+    void Font::setUnderLine(bool enable)
+    {
+        if( enable!=isUnderLine() )
+        {
+            _real_setFontStyle( TTF_GetFontStyle(_get()) | (enable?TTF_STYLE_UNDERLINE:!TTF_STYLE_UNDERLINE) );
+        }
+    }
+
+    void Font::setStrikeThrough(bool enable)
+    {
+        if( enable!=isStrikeThrough() )
+        {
+            _real_setFontStyle( TTF_GetFontStyle(_get()) | (enable?TTF_STYLE_STRIKETHROUGH:!TTF_STYLE_STRIKETHROUGH) );
+        }
+    }
+
     void Font::_real_setFontStyle(int Style)
     {
         TTF_SetFontStyle(_get(),Style);
@@ -1146,22 +1254,13 @@ namespace MiniEngine
 
     int Font::_style_caster(Style style)
     {
-        switch(style)
-        {
-        case Style::Bold:
-            return TTF_STYLE_BOLD;
-        case Style::Italic:
-            return TTF_STYLE_ITALIC;
-        case Style::Normal:
-            return TTF_STYLE_NORMAL;
-        case Style::StrikeThrough:
-            return TTF_STYLE_STRIKETHROUGH;
-        case Style::UnderLine:
-            return TTF_STYLE_UNDERLINE;
-        }
+        return _internal::getTTFFontStyleFromFontStyle(style);
+    }
 
-        /// If an error occurs, return 0 instead of -1.
-        return 0;
+    std::vector<Font::Style> Font::getFontStyles()
+    {
+        int styles=TTF_GetFontStyle(_get());
+        return _internal::getFontStyleVecFromMixedTTFFontStyle(styles);
     }
 
     Rect Font::sizeText(const std::string& Text) throw (ErrorViewer)
diff --git a/MiniEngine.h b/MiniEngine.h
index 00cfa1d..9844c5f 100644
--- a/MiniEngine.h
+++ b/MiniEngine.h
@@ -22,6 +22,7 @@
 #include <string>
 #include <memory>
 #include <functional>
+#include <vector>
 
 #define _DECL_DEPRECATED [[deprecated]]
 
@@ -359,6 +360,18 @@ namespace MiniEngine
 		int use(std::string FontFileName, int size);
 		bool isReady();
 
+		bool isNormal();
+        bool isBold();
+        bool isItalic();
+        bool isUnderLine();
+        bool isStrikeThrough();
+
+        void setNormal();
+        void setBold(bool);
+        void setItalic(bool);
+        void setUnderLine(bool);
+        void setStrikeThrough(bool);
+
 		template<typename... Args>
 		void setFontStyle(Style style,Args&&... args)
 		{
@@ -372,7 +385,7 @@ namespace MiniEngine
             _setFontStyle(fontcalc,style);
 		}
 
-		std::tuple<Style> getFontStyles();
+		std::vector<Style> getFontStyles();
 
         Rect sizeText(const std::string& Text) throw (ErrorViewer);
         Rect sizeUTF8(const std::string& Text) throw (ErrorViewer);

From 65435476b6dca52f20d9a56b436d2ece3d168792 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Tue, 16 May 2017 16:27:35 +0800
Subject: [PATCH 06/17] Add Configure Header

---
 MiniEngine.h        | 23 +----------------------
 MiniEngine_Config.h | 23 +++++++++++++++++++++++
 MiniEngine_Event.h  |  3 ++-
 3 files changed, 26 insertions(+), 23 deletions(-)
 create mode 100644 MiniEngine_Config.h

diff --git a/MiniEngine.h b/MiniEngine.h
index 9844c5f..6d93321 100644
--- a/MiniEngine.h
+++ b/MiniEngine.h
@@ -1,31 +1,10 @@
 #pragma once
-
-#ifdef _MSC_VER
-/// Visual Studio (VC++ Compiler)
-#include <SDL.h>
-#undef main
-#include <SDL_image.h>
-#include <SDL_ttf.h>
-#include <SDL_mixer.h>
-
-/// VC++ does not implied C++ exception. Use this to ignore compile warning on this.
-#pragma warning (disable:4290)
-#else
-/// CodeBlocks (MinGW Compiler)
-#include <SDL2/SDL.h>
-#undef main
-#include <SDL2/SDL_image.h>
-#include <SDL2/SDL_ttf.h>
-#include <SDL2/SDL_mixer.h>
-#endif
-
+#include "MiniEngine_Config.h"
 #include <string>
 #include <memory>
 #include <functional>
 #include <vector>
 
-#define _DECL_DEPRECATED [[deprecated]]
-
 namespace MiniEngine
 {
 
diff --git a/MiniEngine_Config.h b/MiniEngine_Config.h
new file mode 100644
index 0000000..df13523
--- /dev/null
+++ b/MiniEngine_Config.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#ifdef _MSC_VER
+/// Visual Studio (VC++ Compiler)
+#include <SDL.h>
+#undef main
+#include <SDL_image.h>
+#include <SDL_ttf.h>
+#include <SDL_mixer.h>
+
+/// VC++ does not implied C++ exception. Use this to ignore compile warning on this.
+#pragma warning (disable:4290)
+#else
+/// CodeBlocks (MinGW Compiler)
+#include <SDL2/SDL.h>
+#undef main
+#include <SDL2/SDL_image.h>
+#include <SDL2/SDL_ttf.h>
+#include <SDL2/SDL_mixer.h>
+
+#endif /// End of #ifdef _MSC_VER
+
+#define _DECL_DEPRECATED [[deprecated]]
diff --git a/MiniEngine_Event.h b/MiniEngine_Event.h
index 9a136db..0f44f23 100644
--- a/MiniEngine_Event.h
+++ b/MiniEngine_Event.h
@@ -1,7 +1,8 @@
 #pragma once
-#include "MiniEngine.h"
+#include "MiniEngine_Config.h"
 #include <map>
 #include <list>
+#include <functional>
 
 typedef SDL_Event Event;
 typedef decltype(Event::type) _SDLEventType_;

From 0d5e8e289381bcff6f5d69c9625ff02a399b87ec Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Tue, 16 May 2017 16:50:16 +0800
Subject: [PATCH 07/17] Set include path of VS to normal in config

---
 MiniEngine_Config.h | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/MiniEngine_Config.h b/MiniEngine_Config.h
index df13523..8533ea2 100644
--- a/MiniEngine_Config.h
+++ b/MiniEngine_Config.h
@@ -2,22 +2,18 @@
 
 #ifdef _MSC_VER
 /// Visual Studio (VC++ Compiler)
-#include <SDL.h>
-#undef main
-#include <SDL_image.h>
-#include <SDL_ttf.h>
-#include <SDL_mixer.h>
-
 /// VC++ does not implied C++ exception. Use this to ignore compile warning on this.
 #pragma warning (disable:4290)
+#define _COMPILER_LABLE 1
 #else
 /// CodeBlocks (MinGW Compiler)
+#define _COMPILER_LABLE 2
+#endif /// End of #ifdef _MSC_VER
+
 #include <SDL2/SDL.h>
 #undef main
 #include <SDL2/SDL_image.h>
 #include <SDL2/SDL_ttf.h>
 #include <SDL2/SDL_mixer.h>
 
-#endif /// End of #ifdef _MSC_VER
-
 #define _DECL_DEPRECATED [[deprecated]]

From b6ecc0f8560db5f9b1603e38a4959db165afefe1 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Tue, 16 May 2017 22:33:21 +0800
Subject: [PATCH 08/17] Enhanced Window Constructor

---
 MiniEngine.cpp | 63 ++++++++++++++++++++++++++++++++++++++++++++++++--
 MiniEngine.h   | 15 +++++++++++-
 2 files changed, 75 insertions(+), 3 deletions(-)

diff --git a/MiniEngine.cpp b/MiniEngine.cpp
index c7b9bd1..1f28b1a 100644
--- a/MiniEngine.cpp
+++ b/MiniEngine.cpp
@@ -51,6 +51,56 @@ namespace MiniEngine
             }
         }
 
+        /// FIXME: return SDL_WindowFlags or Uint32 ?
+        Uint32 getSDLWindowFlagsFromWindowType(WindowType type)
+        {
+            switch(type)
+            {
+            case WindowType::FullScreen:
+                return SDL_WINDOW_FULLSCREEN;
+            case WindowType::OpenGL:
+                return SDL_WINDOW_OPENGL;
+            case WindowType::Shown:
+                return SDL_WINDOW_SHOWN;
+            case WindowType::Hidden:
+                return SDL_WINDOW_HIDDEN;
+            case WindowType::Borderless:
+                return SDL_WINDOW_BORDERLESS;
+            case WindowType::Resizable:
+                return SDL_WINDOW_RESIZABLE;
+            case WindowType::Minimized:
+                return SDL_WINDOW_MINIMIZED;
+            case WindowType::Maximized:
+                return SDL_WINDOW_MAXIMIZED;
+            case WindowType::InputGrabbed:
+                return SDL_WINDOW_INPUT_GRABBED;
+            case WindowType::InputFocus:
+                return SDL_WINDOW_INPUT_FOCUS;
+            case WindowType::MouseFocus:
+                return SDL_WINDOW_MOUSE_FOCUS;
+            case WindowType::FullScreenDesktop:
+                return SDL_WINDOW_FULLSCREEN_DESKTOP;
+            case WindowType::Foreign:
+                return SDL_WINDOW_FOREIGN;
+            case WindowType::AllowHighDPI:
+                return SDL_WINDOW_ALLOW_HIGHDPI;
+            case WindowType::MouseCapture:
+                return SDL_WINDOW_MOUSE_CAPTURE;
+            case WindowType::AlwaysOnTop:
+                return SDL_WINDOW_ALWAYS_ON_TOP;
+            case WindowType::SkipTaskBar:
+                return SDL_WINDOW_SKIP_TASKBAR;
+            case WindowType::Utility:
+                return SDL_WINDOW_UTILITY;
+            case WindowType::ToolTip:
+                return SDL_WINDOW_TOOLTIP;
+            case WindowType::PopUpMenu:
+                return SDL_WINDOW_POPUP_MENU;
+            default:
+                return 0;/// Return 0 on default.
+            }
+        }
+
         SystemCursorType getCursorTypeFromSDLSystemCursor(SDL_SystemCursor id)
         {
             switch(id)
@@ -978,9 +1028,18 @@ namespace MiniEngine
 	    return _wnd.get();
 	}
 
-	Window::Window(std::string Title, int Width, int Height, std::initializer_list<RendererType> RendererFlags) throw(ErrorViewer)
+	Window::Window(std::string Title, int Width, int Height,
+                std::initializer_list<RendererType> RendererFlags,
+                std::initializer_list<WindowType> WindowFlags , int WindowPositionX, int WindowPositionY) throw(ErrorViewer)
 	{
-		SDL_Window* temp = SDL_CreateWindow(Title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Width, Height, SDL_WINDOW_SHOWN);
+	    /// Calculate Window Flags
+	    Uint32 windowFlag=0;
+	    for(auto v:WindowFlags)
+        {
+            windowFlag|=_internal::getSDLWindowFlagsFromWindowType(v);
+        }
+
+		SDL_Window* temp = SDL_CreateWindow(Title.c_str(), WindowPositionX, WindowPositionY, Width, Height, windowFlag);
 		if (temp == NULL)
 		{
 			ErrorViewer e;
diff --git a/MiniEngine.h b/MiniEngine.h
index 6d93321..c02f55b 100644
--- a/MiniEngine.h
+++ b/MiniEngine.h
@@ -252,10 +252,23 @@ namespace MiniEngine
 
 	enum class MessageBoxType { Error, Warning, Information };
 
+	enum class WindowType
+	{
+	    FullScreen, OpenGL, Shown, Hidden,
+	    Borderless, Resizable, Minimized, Maximized,
+	    InputGrabbed, InputFocus, MouseFocus,
+	    FullScreenDesktop, Foreign, AllowHighDPI,
+	    MouseCapture, AlwaysOnTop, SkipTaskBar,
+	    Utility, ToolTip, PopUpMenu
+	};
+
 	class Window
 	{
 	public:
-		Window(std::string Title, int Width, int Height, std::initializer_list<RendererType> RendererFlags = { RendererType::Accelerated,RendererType::TargetTexture }) throw(ErrorViewer);
+		Window(std::string Title, int Width, int Height,
+         std::initializer_list<RendererType> RendererFlags = { RendererType::Accelerated,RendererType::TargetTexture },
+         std::initializer_list<WindowType> WindowFlags = {WindowType::Shown} ,
+         int WindowPositionX=SDL_WINDOWPOS_CENTERED, int WindowPositionY=SDL_WINDOWPOS_CENTERED) throw(ErrorViewer);
 		Renderer getRenderer() const;
 
 		void setRenderer(RendererType Type)

From fc4940c09bd4e8aa960ce6285c7bb786c3b9926d Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Wed, 17 May 2017 21:40:33 +0800
Subject: [PATCH 09/17] Add XML Objects

Document,Node,Attribute...
---
 MiniEngine_Xml.cpp | 96 ++++++++++++++++++++++++++++++++++++++++++++++
 MiniEngine_Xml.h   | 87 ++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 182 insertions(+), 1 deletion(-)

diff --git a/MiniEngine_Xml.cpp b/MiniEngine_Xml.cpp
index 7c31e77..72491f8 100644
--- a/MiniEngine_Xml.cpp
+++ b/MiniEngine_Xml.cpp
@@ -1 +1,97 @@
 #include "MiniEngine_Xml.h"
+#include "rapidxml/rapidxml_print.hpp"
+#include "rapidxml/rapidxml_utils.hpp"
+#include <fstream>
+
+namespace MiniEngine
+{
+
+namespace XML
+{
+
+Document::Document()
+{
+    _is_ready=false;
+}
+
+Document::Document(const std::string& filename)
+{
+    if(loadFrom(filename,false)!=0)
+    {
+        _is_ready=false;
+    }
+    else
+    {
+        _is_ready=true;
+    }
+}
+
+int Document::loadFrom(const std::string& filename, bool clearCurrent)
+{
+    std::ifstream ifs(filename);
+    if(!ifs)
+    {
+        /// File Read Error.
+        return -1;
+    }
+    rapidxml::file<> infilereader(ifs);
+    if(clearCurrent)
+    {
+        _doc.clear();
+    }
+    _doc.parse<0>(infilereader.data());
+    return 0;
+}
+
+int Document::saveTo(const std::string& filename)
+{
+    std::string ans;
+    rapidxml::print(std::back_inserter(ans),_doc,0);
+
+    std::ofstream ofs(filename);
+
+    if(!ofs) return -1;
+
+    ofs<<ans;
+
+    return 0;
+}
+
+bool Document::ready()
+{
+    return _is_ready;
+}
+
+Node Document::newNode(const std::string& name,const std::string& value)
+{
+    Node node;
+    node._pnode=_doc.allocate_node(rapidxml::node_type::node_element,
+                       _allocate_string(name),_allocate_string(value));
+    node._pdoc=this;
+    return node;
+}
+
+Attribute Document::newAttr(const std::string& name,const std::string& value)
+{
+    Attribute attr;
+    attr._pattr=_doc.allocate_attribute(_allocate_string(name),_allocate_string(value));
+    attr._pdoc=this;
+    return attr;
+}
+
+//protected
+char* Document::_allocate_string(const std::string& str)
+{
+    return _doc.allocate_string(str.c_str(),str.size());
+}
+
+//protected
+char* Document::_allocate_string(const char* source,int sz)
+{
+    return _doc.allocate_string(source,sz);
+}
+
+
+}/// End of namespace MiniEngine::XML
+
+}/// End of namespace MiniEngine
diff --git a/MiniEngine_Xml.h b/MiniEngine_Xml.h
index a5f1a4d..6d61abc 100644
--- a/MiniEngine_Xml.h
+++ b/MiniEngine_Xml.h
@@ -1,3 +1,88 @@
 #pragma once
-#include "MiniEngine.h"
+#include "rapidxml/rapidxml.hpp"
+#include <string>
+
+namespace MiniEngine
+{
+
+namespace XML
+{
+
+typedef rapidxml::xml_node<> XNode;
+typedef rapidxml::xml_attribute<> XAttr;
+typedef rapidxml::xml_document<> XDoc;
+
+/// Fwd Decl
+class Document;
+
+class Attribute
+{
+private:
+    XAttr* _pattr;
+    Document* _pdoc;
+    friend class Document;
+};
+
+class Node
+{
+public:
+    void push_front(const Node&);
+    void push_back(const Node&);
+    void insert(const Node& where,const Node& val);
+
+    void remove_first_node();
+    void remove_last_node();
+    void remove_node(const Node& todelete);
+    void remove_all_node();
+
+    void push_front(const Attribute&);
+    void push_back(const Attribute&);
+    void insert(const Attribute& where,const Attribute& val);
+
+    void remove_first_attr();
+    void remove_last_attr();
+    void remove_attr(const Attribute& todelete);
+    void remove_all_attr();
+
+    bool operator == (const Node& node)
+    {
+        return _pnode==node._pnode && _pdoc==node._pdoc;
+    }
+
+    bool hasPrevNode() const;
+    bool hasNextNode() const;
+    bool hasParentNode() const;
+    Node getPrevNode() const;
+    Node getNextNode() const;
+    Node getParentNode() const;
+
+private:
+    XNode* _pnode;
+    Document* _pdoc;
+    friend class Document;
+};
+
+class Document
+{
+public:
+    Document();
+    Document(const std::string& filename);
+    int loadFrom(const std::string& filename,bool clearCurrent=true);
+    int saveTo(const std::string& filename);
+    bool ready();
+    Node newNode(const std::string& name,const std::string& value);
+    Attribute newAttr(const std::string& name,const std::string& value);
+protected:
+    char* _allocate_string(const std::string& str);
+    char* _allocate_string(const char* pstr,int sz);
+private:
+    XDoc _doc;
+    bool _is_ready;
+};
+
+
+
+}/// End of namespace MiniEngine::XML
+
+}/// End of namespace MiniEngine
 

From d47a3ed09d6250aa82ec090003d0228d3f9a6f79 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Wed, 17 May 2017 23:24:43 +0800
Subject: [PATCH 10/17] Add support functions of XML Node

---
 MiniEngine_Xml.cpp | 111 +++++++++++++++++++++++++++++++++++++++++++--
 MiniEngine_Xml.h   |  17 ++++++-
 2 files changed, 121 insertions(+), 7 deletions(-)

diff --git a/MiniEngine_Xml.cpp b/MiniEngine_Xml.cpp
index 72491f8..0bc26d9 100644
--- a/MiniEngine_Xml.cpp
+++ b/MiniEngine_Xml.cpp
@@ -9,6 +9,107 @@ namespace MiniEngine
 namespace XML
 {
 
+void Node::push_front(const Node& node)
+{
+    _pnode->prepend_node(node._pnode);
+}
+
+void Node::push_back(const Node& node)
+{
+    _pnode->append_node(node._pnode);
+}
+
+void Node::insert(const Node& where, const Node& val)
+{
+    _pnode->insert_node(where._pnode,val._pnode);
+}
+
+void Node::remove_first_node()
+{
+    _pnode->remove_first_node();
+}
+
+void Node::remove_last_node()
+{
+    _pnode->remove_last_node();
+}
+
+void Node::remove_node(const Node& todelete)
+{
+    _pnode->remove_node(todelete._pnode);
+}
+
+void Node::remove_all_node()
+{
+    _pnode->remove_all_nodes();
+}
+
+void Node::push_front(const Attribute& attr)
+{
+    _pnode->prepend_attribute(attr._get());
+}
+
+void Node::push_back(const Attribute& attr)
+{
+    _pnode->append_attribute(attr._get());
+}
+
+void Node::insert(const Attribute& where, const Attribute& val)
+{
+    _pnode->insert_attribute(where._get(),val._get());
+}
+
+void Node::remove_first_attr()
+{
+    _pnode->remove_first_attribute();
+}
+
+void Node::remove_last_attr()
+{
+    _pnode->remove_last_attribute();
+}
+
+void Node::remove_attr(const Attribute& todelete)
+{
+    _pnode->remove_attribute(todelete._get());
+}
+
+void Node::remove_all_attr()
+{
+    _pnode->remove_all_attributes();
+}
+
+bool Node::hasPrevNode() const
+{
+    return _pnode->previous_sibling()!=nullptr;
+}
+
+bool Node::hasNextNode() const
+{
+    return _pnode->next_sibling()!=nullptr;
+}
+
+bool Node::hasParentNode() const
+{
+    return _pnode->parent()!=nullptr;
+}
+
+Node Node::getPrevNode() const
+{
+    return Node(_pnode->previous_sibling());
+}
+
+Node Node::getNextNode() const
+{
+    return Node(_pnode->next_sibling());
+}
+
+Node Node::getParentNode() const
+{
+    return Node(_pnode->parent());
+}
+
+
 Document::Document()
 {
     _is_ready=false;
@@ -65,17 +166,17 @@ bool Document::ready()
 Node Document::newNode(const std::string& name,const std::string& value)
 {
     Node node;
-    node._pnode=_doc.allocate_node(rapidxml::node_type::node_element,
-                       _allocate_string(name),_allocate_string(value));
-    node._pdoc=this;
+    node._set(_doc.allocate_node(rapidxml::node_type::node_element,
+                       _allocate_string(name),_allocate_string(value)));
+    node._setdoc(this);
     return node;
 }
 
 Attribute Document::newAttr(const std::string& name,const std::string& value)
 {
     Attribute attr;
-    attr._pattr=_doc.allocate_attribute(_allocate_string(name),_allocate_string(value));
-    attr._pdoc=this;
+    attr._set(_doc.allocate_attribute(_allocate_string(name),_allocate_string(value)));
+    attr._setdoc(this);
     return attr;
 }
 
diff --git a/MiniEngine_Xml.h b/MiniEngine_Xml.h
index 6d61abc..d4838a5 100644
--- a/MiniEngine_Xml.h
+++ b/MiniEngine_Xml.h
@@ -17,15 +17,27 @@ class Document;
 
 class Attribute
 {
+public:
+    void _set(XAttr*);
+    XAttr* _get() const;
+    void _clear();
+    void _setdoc(Document*);
 private:
     XAttr* _pattr;
     Document* _pdoc;
-    friend class Document;
 };
 
 class Node
 {
 public:
+    void _set(XNode*);
+    XNode* _get();
+    void _clear();
+    void _setdoc(Document*);
+
+    Node();
+    Node(XNode*);
+
     void push_front(const Node&);
     void push_back(const Node&);
     void insert(const Node& where,const Node& val);
@@ -56,10 +68,11 @@ public:
     Node getNextNode() const;
     Node getParentNode() const;
 
+    Node clone();
+
 private:
     XNode* _pnode;
     Document* _pdoc;
-    friend class Document;
 };
 
 class Document

From 547be65c3ee6e9969afc0b5f69ba7637e8ad78a5 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Thu, 18 May 2017 09:00:27 +0800
Subject: [PATCH 11/17] Add more functions to Attr and Node

---
 MiniEngine_Xml.cpp | 116 +++++++++++++++++++++++++++++++++++++++++++++
 MiniEngine_Xml.h   |  24 +++++++---
 2 files changed, 134 insertions(+), 6 deletions(-)

diff --git a/MiniEngine_Xml.cpp b/MiniEngine_Xml.cpp
index 0bc26d9..2ea9ab3 100644
--- a/MiniEngine_Xml.cpp
+++ b/MiniEngine_Xml.cpp
@@ -9,6 +9,102 @@ namespace MiniEngine
 namespace XML
 {
 
+void Attribute::_set(XAttr* pattr)
+{
+    _pattr=pattr;
+}
+
+XAttr* Attribute::_get() const
+{
+    return _pattr;
+}
+
+void Attribute::_clear()
+{
+    _pattr=nullptr;
+}
+
+void Attribute::_setdoc(Document* pDoc)
+{
+    _pdoc=pDoc;
+}
+
+std::string Attribute::getName() const
+{
+    return std::string(getNameRaw());
+}
+
+std::string Attribute::getValue() const
+{
+    return std::string(getValueRaw());
+}
+
+char* Attribute::getNameRaw() const
+{
+    return _pattr->name();
+}
+
+char* Attribute::getValueRaw() const
+{
+    return _pattr->value();
+}
+
+
+Node::Node()
+{
+    _pnode=nullptr;
+    _pdoc=nullptr;
+}
+
+Node::Node(XNode* expNode)
+{
+    _pnode=expNode;
+    _pdoc=nullptr;
+}
+
+
+
+void Node::_set(XNode* node)
+{
+    _pnode=node;
+}
+
+XNode* Node::_get() const
+{
+    return _pnode;
+}
+
+void Node::_clear()
+{
+    _pnode=nullptr;
+}
+
+void Node::_setdoc(Document* pDoc)
+{
+    _pdoc=pDoc;
+}
+
+std::string Node::getName() const
+{
+    return std::string(getNameRaw());
+}
+
+std::string Node::getValue() const
+{
+    return std::string(getValueRaw());
+}
+
+char* Node::getNameRaw() const
+{
+    return _pnode->name();
+}
+
+char* Node::getValueRaw() const
+{
+    return _pnode->value();
+}
+
+
 void Node::push_front(const Node& node)
 {
     _pnode->prepend_node(node._pnode);
@@ -79,6 +175,11 @@ void Node::remove_all_attr()
     _pnode->remove_all_attributes();
 }
 
+bool Node::operator==(const Node& node)
+{
+    return _pnode==node._pnode && _pdoc==node._pdoc;
+}
+
 bool Node::hasPrevNode() const
 {
     return _pnode->previous_sibling()!=nullptr;
@@ -109,6 +210,11 @@ Node Node::getParentNode() const
     return Node(_pnode->parent());
 }
 
+bool Node::valid()
+{
+    return _pnode!=nullptr && _pdoc!=nullptr;
+}
+
 
 Document::Document()
 {
@@ -180,6 +286,16 @@ Attribute Document::newAttr(const std::string& name,const std::string& value)
     return attr;
 }
 
+Node Document::cloneNode(const Node& node)
+{
+    return Node(_doc.clone_node(node._get()));
+}
+
+void Document::clear()
+{
+    return _doc.clear();
+}
+
 //protected
 char* Document::_allocate_string(const std::string& str)
 {
diff --git a/MiniEngine_Xml.h b/MiniEngine_Xml.h
index d4838a5..431ce02 100644
--- a/MiniEngine_Xml.h
+++ b/MiniEngine_Xml.h
@@ -22,6 +22,12 @@ public:
     XAttr* _get() const;
     void _clear();
     void _setdoc(Document*);
+
+    std::string getName() const;
+    std::string getValue() const;
+
+    char* getNameRaw() const;
+    char* getValueRaw() const;
 private:
     XAttr* _pattr;
     Document* _pdoc;
@@ -31,13 +37,19 @@ class Node
 {
 public:
     void _set(XNode*);
-    XNode* _get();
+    XNode* _get() const;
     void _clear();
     void _setdoc(Document*);
 
     Node();
     Node(XNode*);
 
+    std::string getName() const;
+    std::string getValue() const;
+
+    char* getNameRaw() const;
+    char* getValueRaw() const;
+
     void push_front(const Node&);
     void push_back(const Node&);
     void insert(const Node& where,const Node& val);
@@ -56,10 +68,7 @@ public:
     void remove_attr(const Attribute& todelete);
     void remove_all_attr();
 
-    bool operator == (const Node& node)
-    {
-        return _pnode==node._pnode && _pdoc==node._pdoc;
-    }
+    bool operator == (const Node& node);
 
     bool hasPrevNode() const;
     bool hasNextNode() const;
@@ -68,7 +77,7 @@ public:
     Node getNextNode() const;
     Node getParentNode() const;
 
-    Node clone();
+    bool valid();
 
 private:
     XNode* _pnode;
@@ -85,6 +94,9 @@ public:
     bool ready();
     Node newNode(const std::string& name,const std::string& value);
     Attribute newAttr(const std::string& name,const std::string& value);
+    Node cloneNode(const Node&);
+    void clear();
+
 protected:
     char* _allocate_string(const std::string& str);
     char* _allocate_string(const char* pstr,int sz);

From 26beb30f77323299abd126faf1ca32127c1d0254 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Thu, 18 May 2017 13:04:20 +0800
Subject: [PATCH 12/17] Fix bug in StringEngine

---
 MiniEngine.cpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/MiniEngine.cpp b/MiniEngine.cpp
index 1f28b1a..0cffbb2 100644
--- a/MiniEngine.cpp
+++ b/MiniEngine.cpp
@@ -1967,6 +1967,7 @@ namespace MiniEngine
     {
         pimpl=new impl;
         pimpl->status=false;
+
         std::ifstream ifs(StringFile);
         if(!ifs) return;
         rapidxml::file<> strFile(ifs);
@@ -1999,9 +2000,11 @@ namespace MiniEngine
 
     std::string StringEngine::getString(std::string Tag)
     {
-        if(!ready()) return "";
-        char* context=pimpl->root->first_node(Tag.c_str())->value();
-        if(context==nullptr) return "";
+        if(!ready()) return "(StringEngine::STRING_NOT_FOUND)";
+        rapidxml::xml_node<>* pnode=pimpl->root->first_node(Tag.c_str());
+        if(pnode==nullptr) return "(StringEngine::STRING_NOT_FOUND)";
+        char* context=pnode->value();
+        if(context==nullptr) return "";/// Empty String.
         else return std::string(context);
     }
 

From c46455a2e76b9f6e4f51a50e3b218abbb99d616b Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Thu, 18 May 2017 17:58:10 +0800
Subject: [PATCH 13/17] Add Release Interface (For Global Objects Managing)

---
 MiniEngine.h | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/MiniEngine.h b/MiniEngine.h
index c02f55b..eaf29ae 100644
--- a/MiniEngine.h
+++ b/MiniEngine.h
@@ -126,6 +126,7 @@ namespace MiniEngine
 
         static Surface createSurface(int width,int height,int depth,int Rmask,int Gmask,int Bmask,int Amask) throw(ErrorViewer);
 
+        void release();
 	protected:
 		Surface() = default;
 	private:
@@ -161,6 +162,7 @@ namespace MiniEngine
 		RGBA getRGBA();
 		void setRGBA(RGBA pack);
 
+		void release();
 	protected:
 		/// updateInfo() must be called after Texture is changed.
 		void updateInfo();
@@ -212,6 +214,8 @@ namespace MiniEngine
 		Texture createTexture(int Width, int Height) throw(ErrorViewer);
 
 		bool isReady();
+
+		void release();
 	private:
 		std::shared_ptr<SDL_Renderer> _rnd;
 		void _set(SDL_Renderer*);
@@ -242,6 +246,8 @@ namespace MiniEngine
         static bool isShow();
 
         void activate();
+
+        void release();
     private:
         std::shared_ptr<SDL_Cursor> _cur;
         void _set(SDL_Cursor*);
@@ -314,8 +320,9 @@ namespace MiniEngine
 		void maximize();
 		void restore();
 
-
 		_DECL_DEPRECATED Surface getSurface();
+
+		void release();
     protected:
         template<typename... Args>
         void _setRenderer(RendererType Type,Args&&... args)
@@ -401,6 +408,8 @@ namespace MiniEngine
 		Texture renderUTF8Wrapped(Renderer rnd, std::string Text, RGBA fg, int WrapLength);
 		Texture renderUTF8Shaded(Renderer rnd, std::string Text, RGBA fg, RGBA bg);
 		Texture renderUTF8Solid(Renderer rnd, std::string Text, RGBA fg);
+
+		void release();
     protected:
 		template<typename... Args>
         void _setFontStyle(int& fontcalc,Style style,Args&&... args)
@@ -446,8 +455,11 @@ namespace MiniEngine
         int load(const std::string& Filename);
         int unload();
         void* get(const std::string& FunctionName);
+        void release();
     private:
-        void* _obj;
+        void* _get();
+        void _set(void*);
+        std::shared_ptr<void> _obj;
 	};
 
 	class SDLSystem

From 3e995ba610b2f448e18704801d4759f480e89a72 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Thu, 18 May 2017 18:14:29 +0800
Subject: [PATCH 14/17] Add XXX::release() implement.

---
 MiniEngine.cpp | 101 +++++++++++++++++++++++++++++++++++++++----------
 MiniEngine.h   |   3 ++
 2 files changed, 84 insertions(+), 20 deletions(-)

diff --git a/MiniEngine.cpp b/MiniEngine.cpp
index 0cffbb2..e2b9b17 100644
--- a/MiniEngine.cpp
+++ b/MiniEngine.cpp
@@ -407,6 +407,11 @@ namespace MiniEngine
         _set(SDL_RWFromMem(mem,size));
     }
 
+    void RWOP::release()
+    {
+        _clear();
+    }
+
     void Surface::_set(SDL_Surface* p)//private
     {
         _surf.reset(p,SDL_FreeSurface);
@@ -598,6 +603,11 @@ namespace MiniEngine
         return surf;
     }
 
+    void Surface::release()
+    {
+        _clear();
+    }
+
     void Texture::_set(SDL_Texture* p)//private
     {
         _text.reset(p,SDL_DestroyTexture);
@@ -706,6 +716,11 @@ namespace MiniEngine
 		rect.x = rect.y = 0;
 	}
 
+	void Texture::release()
+	{
+        _clear();
+	}
+
 	void Renderer::_set(SDL_Renderer* p)
 	{
         _rnd.reset(p,SDL_DestroyRenderer);
@@ -940,6 +955,16 @@ namespace MiniEngine
 		return t;
 	}
 
+    bool Renderer::isReady()
+	{
+		return (_get() != nullptr);
+	}
+
+	void Renderer::release()
+	{
+        _clear();
+	}
+
 	//private
 	void Cursor::_set(SDL_Cursor* p)
 	{
@@ -958,6 +983,11 @@ namespace MiniEngine
         return _cur.get();
 	}
 
+	void Cursor::_clear()
+	{
+        _cur.reset();
+	}
+
 	//static
     Cursor Cursor::CreateCursor(Surface surf,Point hotspot)
     {
@@ -1003,16 +1033,16 @@ namespace MiniEngine
         SDL_ShowCursor(Settings?SDL_ENABLE:SDL_DISABLE);
     }
 
+    void Cursor::release()
+    {
+        _clear();
+    }
+
     void Cursor::activate()
     {
         SDL_SetCursor(_get());
     }
 
-	bool Renderer::isReady()
-	{
-		return (_get() != nullptr);
-	}
-
 	void Window::_set(SDL_Window* p)
 	{
         _wnd.reset(p,SDL_DestroyWindow);
@@ -1165,6 +1195,12 @@ namespace MiniEngine
 		return s;
 	}
 
+	void Window::release()
+	{
+        _clear();
+	}
+
+	// private
 	Uint32 Window::_render_caster(RendererType Type)
 	{
 	    switch(Type)
@@ -1183,6 +1219,7 @@ namespace MiniEngine
 	    return 0;
 	}
 
+	// private
 	void Window::_setRenderer_Real(Uint32 flags)
 	{
 		winrnd._rnd.reset(SDL_CreateRenderer(_get(), -1, flags), SDL_DestroyRenderer);
@@ -1442,6 +1479,11 @@ namespace MiniEngine
 		return rnd.render(renderUTF8Solid(Text,fg));
 	}
 
+	void Font::release()
+	{
+        _clear();
+	}
+
 	void LogSystem::d(const char* fmt,...)
 	{
         va_list ap;
@@ -1490,6 +1532,21 @@ namespace MiniEngine
 	    va_end(ap);
 	}
 
+	void* SharedLibrary::_get()
+	{
+	    return _obj.get();
+	}
+
+	void SharedLibrary::_set(void* ptr)
+	{
+	    _obj.reset(ptr,SDL_UnloadObject);
+	}
+
+	void SharedLibrary::_clear()
+	{
+        _obj.reset();
+	}
+
     SharedLibrary::SharedLibrary()
     {
         _obj=nullptr;
@@ -1503,40 +1560,44 @@ namespace MiniEngine
 
     SharedLibrary::~SharedLibrary()
     {
-        if(_obj)
-        {
-            unload();
-        }
+
     }
 
     int SharedLibrary::load(const std::string& Filename)
     {
-        if(_obj) return -1;
+        if(_get()!=nullptr) return -1; /// Loaded
         else
         {
-            _obj=SDL_LoadObject(Filename.c_str());
-            if(_obj) return 0;
-            else return -2;
+            void* ptr=SDL_LoadObject(Filename.c_str());
+            if(ptr)
+            {
+                _set(ptr);
+                return 0; /// Success
+            }
+            else return -2; /// Failed to load
         }
     }
 
     int SharedLibrary::unload()
     {
-        if(_obj)
+        if(_get()!=nullptr)
         {
-            SDL_UnloadObject(_obj);
-            _obj=nullptr;
-            return 0;
+            _clear();
+            return 0; /// Success to unload
         }
-        else return -1;
+        else return -1; /// Not Loaded.
     }
 
     void* SharedLibrary::get(const std::string& FunctionName)
     {
-        if(!_obj) return nullptr;
-        else return SDL_LoadFunction(_obj,FunctionName.c_str());
+        if(_get()==nullptr) return nullptr;
+        else return SDL_LoadFunction(_get(),FunctionName.c_str());
     }
 
+    void SharedLibrary::release()
+    {
+        _clear();
+    }
 
 	int SDLSystem::SDLInit()
 	{
diff --git a/MiniEngine.h b/MiniEngine.h
index eaf29ae..a99ce84 100644
--- a/MiniEngine.h
+++ b/MiniEngine.h
@@ -80,6 +80,8 @@ namespace MiniEngine
         RWOP(void* mem,int size);
         RWOP()=default;
         ~RWOP()=default;
+
+        void release();
     private:
         std::shared_ptr<SDL_RWops> _op;
         SDL_RWops* _get();
@@ -459,6 +461,7 @@ namespace MiniEngine
     private:
         void* _get();
         void _set(void*);
+        void _clear();
         std::shared_ptr<void> _obj;
 	};
 

From 54e057b590b8c969b8cf9038a8e577a04e829a7c Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Sat, 20 May 2017 16:00:19 +0800
Subject: [PATCH 15/17] Add More Function of Attr and Node

---
 MiniEngine_Xml.cpp | 96 +++++++++++++++++++++++++++++++++++++++-------
 MiniEngine_Xml.h   | 44 ++++++++++++++-------
 2 files changed, 112 insertions(+), 28 deletions(-)

diff --git a/MiniEngine_Xml.cpp b/MiniEngine_Xml.cpp
index 2ea9ab3..7056b96 100644
--- a/MiniEngine_Xml.cpp
+++ b/MiniEngine_Xml.cpp
@@ -29,6 +29,18 @@ void Attribute::_setdoc(Document* pDoc)
     _pdoc=pDoc;
 }
 
+Attribute::Attribute()
+{
+    _pattr=nullptr;
+    _pdoc=nullptr;
+}
+
+Attribute::Attribute(XAttr* pAttr)
+{
+    _pattr=pAttr;
+    _pdoc=nullptr;
+}
+
 std::string Attribute::getName() const
 {
     return std::string(getNameRaw());
@@ -49,6 +61,27 @@ char* Attribute::getValueRaw() const
     return _pattr->value();
 }
 
+bool Attribute::hasPrevAttr() const
+{
+    return _pattr->previous_attribute()!=nullptr;
+}
+
+bool Attribute::hasNextAttr() const
+{
+    return _pattr->next_attribute()!=nullptr;
+}
+
+Attribute Attribute::getPrevAttr() const
+{
+    return Attribute(_pattr->previous_attribute());
+}
+
+Attribute Attribute::getNextAttr() const
+{
+    return Attribute(_pattr->next_attribute());
+}
+
+
 
 Node::Node()
 {
@@ -105,74 +138,88 @@ char* Node::getValueRaw() const
 }
 
 
-void Node::push_front(const Node& node)
+Node& Node::push_front(const Node& node)
 {
     _pnode->prepend_node(node._pnode);
+    return *this;
 }
 
-void Node::push_back(const Node& node)
+Node& Node::push_back(const Node& node)
 {
     _pnode->append_node(node._pnode);
+    return *this;
 }
 
-void Node::insert(const Node& where, const Node& val)
+Node& Node::insert(const Node& where, const Node& val)
 {
     _pnode->insert_node(where._pnode,val._pnode);
+    return *this;
 }
 
-void Node::remove_first_node()
+Node& Node::remove_first_node()
 {
     _pnode->remove_first_node();
+    return *this;
 }
 
-void Node::remove_last_node()
+Node& Node::remove_last_node()
 {
     _pnode->remove_last_node();
+    return *this;
 }
 
-void Node::remove_node(const Node& todelete)
+Node& Node::remove_node(const Node& todelete)
 {
     _pnode->remove_node(todelete._pnode);
+    return *this;
 }
 
-void Node::remove_all_node()
+Node& Node::remove_all_node()
 {
     _pnode->remove_all_nodes();
+    return *this;
 }
 
-void Node::push_front(const Attribute& attr)
+Node& Node::push_front(const Attribute& attr)
 {
     _pnode->prepend_attribute(attr._get());
+    return *this;
 }
 
-void Node::push_back(const Attribute& attr)
+Node& Node::push_back(const Attribute& attr)
 {
     _pnode->append_attribute(attr._get());
+    return *this;
 }
 
-void Node::insert(const Attribute& where, const Attribute& val)
+Node& Node::insert(const Attribute& where, const Attribute& val)
 {
     _pnode->insert_attribute(where._get(),val._get());
+    return *this;
 }
 
-void Node::remove_first_attr()
+Node& Node::remove_first_attr()
 {
     _pnode->remove_first_attribute();
+    return *this;
 }
 
-void Node::remove_last_attr()
+Node& Node::remove_last_attr()
 {
     _pnode->remove_last_attribute();
+    return *this;
 }
 
-void Node::remove_attr(const Attribute& todelete)
+Node& Node::remove_attr(const Attribute& todelete)
 {
     _pnode->remove_attribute(todelete._get());
+    return *this;
 }
 
-void Node::remove_all_attr()
+Node& Node::remove_all_attr()
 {
     _pnode->remove_all_attributes();
+    return *this;
 }
 
 bool Node::operator==(const Node& node)
@@ -205,6 +252,16 @@ Node Node::getNextNode() const
     return Node(_pnode->next_sibling());
 }
 
+Node Node::getPrevNode(const std::string& name) const
+{
+    return Node(_pnode->previous_sibling(name.c_str()));
+}
+
+Node Node::getNextNode(const std::string& name) const
+{
+    return Node(_pnode->next_sibling(name.c_str()));
+}
+
 Node Node::getParentNode() const
 {
     return Node(_pnode->parent());
@@ -216,6 +273,17 @@ bool Node::valid()
 }
 
 
+Node Node::getChild() const
+{
+    return _pnode->first_node();
+}
+
+Node Node::getChild(const std::string& nodename) const
+{
+    return _pnode->first_node(nodename.c_str());
+}
+
+
 Document::Document()
 {
     _is_ready=false;
diff --git a/MiniEngine_Xml.h b/MiniEngine_Xml.h
index 431ce02..fde952b 100644
--- a/MiniEngine_Xml.h
+++ b/MiniEngine_Xml.h
@@ -23,11 +23,22 @@ public:
     void _clear();
     void _setdoc(Document*);
 
+    Attribute();
+    Attribute(XAttr*);
+
     std::string getName() const;
     std::string getValue() const;
 
     char* getNameRaw() const;
     char* getValueRaw() const;
+
+    bool hasPrevAttr() const;
+    bool hasNextAttr() const;
+    Attribute getPrevAttr() const;
+    Attribute getNextAttr() const;
+    Attribute getPrevAttr(const std::string& name) const;
+    Attribute getNextAttr(const std::string& name) const;
+
 private:
     XAttr* _pattr;
     Document* _pdoc;
@@ -50,23 +61,23 @@ public:
     char* getNameRaw() const;
     char* getValueRaw() const;
 
-    void push_front(const Node&);
-    void push_back(const Node&);
-    void insert(const Node& where,const Node& val);
+    Node& push_front(const Node&);
+    Node& push_back(const Node&);
+    Node& insert(const Node& where,const Node& val);
 
-    void remove_first_node();
-    void remove_last_node();
-    void remove_node(const Node& todelete);
-    void remove_all_node();
+    Node& remove_first_node();
+    Node& remove_last_node();
+    Node& remove_node(const Node& todelete);
+    Node& remove_all_node();
 
-    void push_front(const Attribute&);
-    void push_back(const Attribute&);
-    void insert(const Attribute& where,const Attribute& val);
+    Node& push_front(const Attribute&);
+    Node& push_back(const Attribute&);
+    Node& insert(const Attribute& where,const Attribute& val);
 
-    void remove_first_attr();
-    void remove_last_attr();
-    void remove_attr(const Attribute& todelete);
-    void remove_all_attr();
+    Node& remove_first_attr();
+    Node& remove_last_attr();
+    Node& remove_attr(const Attribute& todelete);
+    Node& remove_all_attr();
 
     bool operator == (const Node& node);
 
@@ -76,6 +87,11 @@ public:
     Node getPrevNode() const;
     Node getNextNode() const;
     Node getParentNode() const;
+    Node getPrevNode(const std::string& name) const;
+    Node getNextNode(const std::string& name) const;
+
+    Node getChild() const;
+    Node getChild(const std::string& nodename) const;
 
     bool valid();
 

From a7ab24d8ab1400a736304ff6033bfc6b2f523715 Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Sun, 21 May 2017 21:08:53 +0800
Subject: [PATCH 16/17] Fix bug in class Timer (VoidCallable Constructor)

---
 MiniEngine.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/MiniEngine.h b/MiniEngine.h
index a99ce84..324d921 100644
--- a/MiniEngine.h
+++ b/MiniEngine.h
@@ -514,7 +514,7 @@ namespace MiniEngine
         template<typename VoidCallable,typename... Args>
         Timer(Uint32 interval,VoidCallable&& vcallable,Args&&... args) : Timer()
         {
-            auto realCall=[&](Uint32 ims)->Uint32{vcallable(ims,args...);return interval;};
+            auto realCall=[&](Uint32 ims)->Uint32{vcallable(ims,args...);return ims;};
             auto pfunc=new std::function<Uint32(Uint32 interval)>(realCall);
             _real_timer_call(_global_timer_executor,interval,pfunc);
         }

From ee8780fe30141a54ad28a1aff72ae081594371ea Mon Sep 17 00:00:00 2001
From: kiritow <1362050620@qq.com>
Date: Mon, 22 May 2017 15:02:04 +0800
Subject: [PATCH 17/17] Fix Runtime Bug in class Timer

Now callable and vcallable are copied, while args... remains referenced.
---
 MiniEngine.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/MiniEngine.h b/MiniEngine.h
index 324d921..44338c5 100644
--- a/MiniEngine.h
+++ b/MiniEngine.h
@@ -514,7 +514,7 @@ namespace MiniEngine
         template<typename VoidCallable,typename... Args>
         Timer(Uint32 interval,VoidCallable&& vcallable,Args&&... args) : Timer()
         {
-            auto realCall=[&](Uint32 ims)->Uint32{vcallable(ims,args...);return ims;};
+            auto realCall=[&,vcallable](Uint32 ims)->Uint32{vcallable(ims,args...);return ims;};
             auto pfunc=new std::function<Uint32(Uint32 interval)>(realCall);
             _real_timer_call(_global_timer_executor,interval,pfunc);
         }
@@ -523,7 +523,7 @@ namespace MiniEngine
         template<typename Callable,typename... Args>
         Timer(Callable&& callable,Uint32 interval,Args&&... args) : Timer()
         {
-            auto realCall=[&](Uint32 ims)->Uint32{return callable(ims,args...);};
+            auto realCall=[&,callable](Uint32 ims)->Uint32{return callable(ims,args...);};
             auto pfunc=new std::function<Uint32(Uint32 interval)>(realCall);
             _real_timer_call(_global_timer_executor,interval,pfunc);
         }