screen.h

// © Copyright 2010 - 2016 BlackTopp Studios Inc.
/* This file is part of The Mezzanine Engine.

    The Mezzanine Engine is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    The Mezzanine Engine is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with The Mezzanine Engine.  If not, see <http://www.gnu.org/licenses/>.
*/
/* The original authors have included a copy of the license specified above in the
   'Docs' folder. See 'gpl.txt'
*/
/* We welcome the use of the Mezzanine engine to anyone, including companies who wish to
   Build professional software and charge for their product.

   However there are some practical restrictions, so if your project involves
   any of the following you should contact us and we will try to work something
   out:
    - DRM or Copy Protection of any kind(except Copyrights)
    - Software Patents You Do Not Wish to Freely License
    - Any Kind of Linking to Non-GPL licensed Works
    - Are Currently In Violation of Another Copyright Holder's GPL License
    - If You want to change our code and not add a few hundred MB of stuff to
        your distribution

   These and other limitations could cause serious legal problems if you ignore
   them, so it is best to simply contact us or the Free Software Foundation, if
   you have any questions.

   Joseph Toppi - toppij@gmail.com
   John Blackwood - makoenergy02@gmail.com
*/
#ifndef _uiscreen_h
#define _uiscreen_h

#include "matrix4x4.h"
#include "UI/glyph.h"
#include "UI/vertex.h"
#include "UI/quadrenderable.h"
#include "UI/widget.h"
#include "UI/widgetfactory.h"

namespace Mezzanine
{
    namespace Graphics
    {
        class Viewport;
        class SceneManager;
    }
    namespace UI
    {
        class Button;
        class CheckBox;
        class DropDownList;
        class EditBox;
        class GridContainer;
        class HorizontalContainer;
        class HorizontalScrollbar;
        class LineList;
        class ListBox;
        class MenuEntry;
        class RadioButton;
        class Scrollbar;
        class Spinner;
        class StackButton;
        class TabSet;
        class VerticalContainer;
        class VerticalScrollbar;
        class Widget;
        class Window;

        class Sprite;
        class TextureAtlas;
        class MouseHoverStrategy;
        class MarkupParser;
        class UIManager;
        struct ScreenInternalData;
        ///////////////////////////////////////////////////////////////////////////////
        /// @brief This class stores how the calls to Render are to be done.
        /// @details
        ///////////////////////////////////////
        struct AtlasAndPosition
        {
            /// @brief The name of the atlas to be rendered with.
            String Atlas;
            /// @brief The number of vertices to be rendered.
            Whole RenderCount;
            /// @brief The index of the first verticy to be rendered.
            Whole RenderStart;
            /// @brief The index of the last verticy to be rendered.
            Whole RenderEnd;

            /// @brief Blank constructor.
            AtlasAndPosition() :
                RenderCount(0), RenderStart(0), RenderEnd(0)
                {  }
            /// @brief Atlas constructor.
            /// @param AtlasName The name of the atlas the specified vertices will use to render.
            AtlasAndPosition(const String& AtlasName) :
                Atlas(AtlasName), RenderCount(0), RenderStart(0), RenderEnd(0)
                {  }
        };//AtlasAndPosition

        ///////////////////////////////////////////////////////////////////////////////
        /// @brief This class stores all vertices pertaining to a layer sorted by their priority for rendering.
        /// @details
        ///////////////////////////////////////
        class ScreenRenderData
        {
        public:
            /// @brief Container storing all of the vertices to be rendered.
            std::vector<VertexData> Vertices;

            /// @brief Clears all Vertex vectors.
            void Clear();
            /// @brief Gets the combined size of all Vertex vectors.
            Whole Size();
            /// @brief Appends the contents of another ScreenRenderData to the end of this.
            /// @param OtherData The other ScreenRenderData to append.
            void Append(ScreenRenderData& OtherData);
            /// @brief Array access operator spanning all 3 Vertex vectors.
            /// @param Index The index to access.
            /// @return Returns a reference to the VertexData at the specified index.
            VertexData& operator[](const Whole& Index);
        };//ScreenRenderData

        ///////////////////////////////////////////////////////////////////////////////
        /// @class Screen
        /// @headerfile screen.h
        /// @brief This class is a helper class for creating UI's.  It is responsible for storing and keeping
        /// track of all the elements of a single UI screen.
        /// @details UI's can optionally be divided up into Screens.  Each screen is batched together
        /// for rendering, so keeping the amount of screens to a minimum will improve performance.
        ///////////////////////////////////////
        class MEZZ_LIB Screen : public QuadRenderable
        {
        public:
            /// @brief Basic container type for @ref Widget storage by this class.
            typedef std::map<String,Widget*>                WidgetContainer;
            /// @brief Iterator type for @ref Widget instances stored by this class.
            typedef WidgetContainer::iterator               WidgetIterator;
            /// @brief Const Iterator type for @ref Widget instances stored by this class.
            typedef WidgetContainer::const_iterator         ConstWidgetIterator;
            /// @brief Basic container type for @ref Widget storage by this class.
            typedef std::map<String,WidgetFactory*>         WidgetFactoryContainer;
            /// @brief Iterator type for @ref Widget instances stored by this class.
            typedef WidgetFactoryContainer::iterator        WidgetFactoryIterator;
            /// @brief Const Iterator type for @ref Widget instances stored by this class.
            typedef WidgetFactoryContainer::const_iterator  ConstWidgetFactoryIterator;
            /// @brief Basic container type for the storage of render data on this screen.
            typedef std::vector<AtlasAndPosition>           TextureVertexContainer;
            /// @brief Callback type for child processing.
            typedef Boole (ChildCallback)(QuadRenderable* Quad);
        protected:
            friend class Mezzanine::UI::UIManager;

            /// @internal
            /// @brief A container storing a mapping of the textures needed to render each section of vertices.
            TextureVertexContainer TextureByVertex;
            /// @internal
            /// @brief A container storing the actual vertices to be rendered.
            ScreenRenderData VertexCache;
            /// @internal
            /// @brief A container storing all the factories for the widgets supported by this screen.
            WidgetFactoryContainer WidgetFactories;
            /// @internal
            /// @brief A container storing all the created Widgets owned by this screen.
            WidgetContainer Widgets;

            /// @internal
            /// @brief The transformation matrix used to update vertex transforms if needed.
            Matrix4x4 VertexTransform;
            /// @internal
            /// @brief The name of the this screens primary atlas for texture lookups.
            String PrimaryAtlas;
            /// @internal
            /// @brief The scaling to be applied to all vertices that are generated by this screen.
            /// @note This member is set once and barely used, could be replaced with individual constructions where used.
            Vector3 Scale;
            /// @internal
            /// @brief The pixel position on this screen where the mouse clicked on a Widget.
            Vector2 MouseHitPosition;
            /// @internal
            /// @brief The inverse size (1/size) of the viewport this screen is bound to in pixels.
            Vector2 InverseSize;

            /// @internal
            /// @brief A pointer to the class storing all sensative internal data THAT IS NOT FOR YOUR EYES!
            ScreenInternalData* SID;
            /// @internal
            /// @brief A pointer to the UIManager that owns this screen.
            UIManager* UIMan;
            /// @internal
            /// @brief A pointer to the viewport this screen is bound to.
            Graphics::Viewport* GameViewport;
            /// @internal
            /// @brief A pointer to the strategy to be used when detecting the hovered widget.
            MouseHoverStrategy* MouseStrat;

            /// @internal
            /// @brief The current orientation mode of this screen.
            Mezzanine::OrientationMode Orientation;

            /// @internal
            /// @brief Gets a pointer to the SceneManager connected to this screens viewport.
            /// @return Returns a pointer to the SceneManager that will be rendering this screen.
            virtual Graphics::SceneManager* GetSceneManager() const;
            /// @internal
            /// @brief Gets a registered WidgetFactory that creates the specified type of widget.
            /// @exception If a widget factor of the specified widget type isn't registered then a II_IDENTITY_NOT_FOUND_EXCEPTION will be thrown.
            /// @param WidgetTypeName The name of the widget type to retrieve the factory for.
            /// @return Returns a pointer to the specified factory.  This pointer will always be valid if an exception isn't thrown.
            virtual WidgetFactory* GetWidgetFactoryExcept(const String& WidgetTypeName);
            /// @internal
            /// @brief Verifies uniqueness of a widget and inserts it if it is.
            /// @exception If a widget with the same name already exists in this Screen, a II_DUPLICATE_IDENTITY_EXCEPTION will be thrown.
            /// @param ToInsert The widget to be verified and inserted.
            /// @return Returns a pointer to the same widget that was passed into this method.
            virtual Widget* CheckAndInsertExcept(Widget* ToInsert);

            /// @internal
            /// @brief Sets up all the necessary projection and world matrices for UI rendering.
            virtual void PrepareRenderSystem();
            /// @internal
            /// @brief Creates a new Vertex Buffer for vertices generated by the UI system.
            /// @param InitialSize The amount of space to allocate for the initial buffer, in number of vertices.
            virtual void CreateVertexBuffer(const Whole& InitialSize);
            /// @internal
            /// @brief Destroys the Vertex Buffer storing all the UI vertices generated by this screen.
            virtual void DestroyVertexBuffer();
            /// @internal
            /// @brief Resizes the Vertex Buffer.
            /// @note The Vertex Buffer will not shrink, only grow.  Passing in a smaller size will do nothing.
            /// @param RequestedSize The new size for the existing buffer.
            virtual void ResizeVertexBuffer(const Whole& RequestedSize);
        //public:
            /// @brief Internal constructor.
            /// @param RendName The name of this screen.
            /// @param Atlas The name of the primary atlas to be assigned to this screen.
            /// This can be overridden later, even by individual UI elements.
            /// @param WindowViewport The Viewport to which this screen belongs.
            /// @param Manager A pointer to the UI manager creating this screen.
            Screen(const String& RendName, const String& Atlas, Graphics::Viewport* WindowViewport, UIManager* Manager);
            /// @brief XML constructor.
            /// @param XMLNode The node of the xml document to construct from.
            /// @param Manager A pointer to the UI manager creating this screen.
            Screen(const XML::Node& XMLNode, UIManager* Manager);
            /// @brief Class destructor.
            virtual ~Screen();
        public:
            ///////////////////////////////////////////////////////////////////////////////
            // Utility and Visibility Methods

            /// @copydoc Renderable::SetVisible(Boole)
            virtual void SetVisible(Boole CanSee);
            /// @copydoc Renderable::GetVisible() const
            virtual Boole GetVisible() const;
            /// @copydoc Renderable::IsVisible() const
            virtual Boole IsVisible() const;
            /// @copydoc Renderable::Show()
            virtual void Show();
            /// @copydoc Renderable::Hide()
            virtual void Hide();

            /// @copydoc Renderable::GetRenderableType() const
            virtual RenderableType GetRenderableType() const;

            /// @brief Gets the current viewport dimensions.
            /// @return Returns a Vector2 representing the current viewport dimensions.
            virtual const Vector2& GetViewportDimensions() const;
            /// @brief Checks to see if the viewport has changed in size.  If so it updates all the UI elements on the screen.
            virtual void CheckViewportSize();
            /// @brief Gets the Viewport this screen is currently rendering to.
            /// @return Returns a pointer to the Viewport this screen is applied to.
            virtual Graphics::Viewport* GetViewport() const;
            /// @brief Gets the UIManager this screen belongs to.
            /// @return Returns a pointer to the UI manager that owns this screen.
            virtual UIManager* GetManager() const;

            ///////////////////////////////////////////////////////////////////////////////
            // Mouse Hover Methods

            /// @brief Sets the strategy to use when detect which object the mouse is hovered over.
            /// @note This method will replace whatever method is currently set if one is set.
            /// @param Strategy A pointer to the strategy to use.
            virtual void SetMouseHoverStrategy(MouseHoverStrategy* Strategy);
            /// @brief Gets the MouseHoverStrategy currently being used by this screen.
            /// @return Returns a pointer to the currently set MouseHoverStrategy.
            virtual MouseHoverStrategy* GetMouseHoverStrategy() const;
            /// @brief Gets the quad the mouse is over if any.
            /// @param MousePos The current mouse position.
            /// @return Returns the Widget the mouse is over, or NULL if there are none.
            virtual Widget* FindHoveredWidget(const Vector2& MousePos);
            /// @brief Gets the mouse position from the last call to "FindHoveredQuad(const Vector2&).
            /// @note Screens have a 1:1 ratio to viewports, not windows.  The returned coordinates is in viewport space.
            /// @warning This will not perform any additional checks.  Only returns the result of the last check.
            /// Verify the screen this is being called on is the one with the mouse over if prior to calling or you may get outdated information.
            /// @return Returns a valid point on this screen if the last check was valid, or (-1,-1) if the check failed.
            virtual const Vector2& GetMouseHitPosition() const;

            ///////////////////////////////////////////////////////////////////////////////
            // WidgetFactory Management

            /// @brief Adds/registers a widget factory with this Screen, allowing it to be constructed through this API.
            /// @param ToBeAdded The widget factory to be added.
            void AddWidgetFactory(WidgetFactory* ToBeAdded);
            /// @brief Removes a widget factory from this Screen.
            /// @param ToBeRemoved A pointer to the widget factory that is to be removed.
            void RemoveWidgetFactory(WidgetFactory* ToBeRemoved);
            /// @brief Removes a widget factory from this Screen.
            /// @param ImplName The name of the widget implementation created by the factory to be removed.
            void RemoveWidgetFactory(const String& ImplName);
            /// @brief Removes and destroys a widget factory in this Screen.
            /// @param ToBeDestroyed A pointer to the widget factory that is to be removed and destroyed.
            void DestroyWidgetFactory(WidgetFactory* ToBeDestroyed);
            /// @brief Removes and destroys a widget factory in this Screen.
            /// @param ImplName The name of the widget implementation created by the factory to be removed and destroyed.
            void DestroyWidgetFactory(const String& ImplName);
            /// @brief Destroys all widget factories in this Screen.
            /// @warning The destruction of widget factories should only be done after the corresponding managers have been destroyed, otherwise this will cause an exception.
            void DestroyAllWidgetFactories();
            /// @brief Adds all the default widget factories provided by the engine to the Screen.
            void AddAllDefaultWidgetFactories();

            ///////////////////////////////////////////////////////////////////////////////
            // Widget Management

            /// @brief Creates a widget from an XML::Node.
            /// @note This IS a polymorphic create method, and can create a widget of any type that has it's factory registered.
            /// @exception This method will throw an exception if the WidgetNode is not named after a known widget.
            /// @param WidgetNode The XML node populated with data needed to construct a widget.
            /// @return Returns a pointer to the created widget.
            virtual Widget* CreateWidget(const XML::Node& WidgetNode);
            /// @brief Creates a widget based on the provided typename.
            /// @note This IS a polymorphic create method, and can create a widget of any type that has it's factory registered.
            /// @param TypeName The class name of the widget to be created.
            /// @param RendName The unique instance name to be given to the widget.
            /// @param Params A NameValuePairMap containing the params to be applied during construction.
            /// @return Returns a pointer to the created widget.
            virtual Widget* CreateWidget(const String& TypeName, const String& RendName, const NameValuePairMap& Params);
            /// @brief Creates a widget based on the provided typename.
            /// @note This IS a polymorphic create method, and can create a widget of any type that has it's factory registered.
            /// @param TypeName The class name of the widget to be created.
            /// @param RendName The unique instance name to be given to the widget.
            /// @param RendRect The dimensions that will be assigned to the created Widget.
            /// @param Params A NameValuePairMap containing the params to be applied during construction.
            /// @return Returns a pointer to the created widget.
            virtual Widget* CreateWidget(const String& TypeName, const String& RendName, const UnifiedRect& RendRect, const NameValuePairMap& Params);

            /// @brief Gets a widget in this screen by name.
            /// @param Name The name of the widget to get.
            /// @return Returns a pointer to the widget of the specified name.
            virtual Widget* GetWidget(const String& Name);
            /// @brief Gets the number of widgets being used in this screen.
            /// @return Returns the number of widgets this screen is storing.
            virtual Whole GetNumWidgets();

            /// @brief Destroys a widget.
            /// @param ToBeDestroyed Pointer to the widget you want destroyed.
            virtual void DestroyWidget(Widget* ToBeDestroyed);
            /// @brief Destroys all widgets being stored by this screen.
            virtual void DestroyAllWidgets();

            ///////////////////////////////////////////////////////////////////////////////
            // Convenience Widget Creation Methods

            /// @brief Creates a generic widget.
            /// @note This IS NOT a polymorphic create method.  It will case an instance of the widget base class.
            /// @param RendName The name to be given to this Widget.
            /// @return Returns a pointer to the created Widget.
            virtual Widget* CreateWidget(const String& RendName);
            /// @brief Creates a generic widget.
            /// @note This IS NOT a polymorphic create method.  It will case an instance of the widget base class.
            /// @param RendName The name to be given to this Widget.
            /// @param RendRect The rect describing this Widget's transform relative to it's parent.
            /// @return Returns a pointer to the created Widget.
            virtual Widget* CreateWidget(const String& RendName, const UnifiedRect& RendRect);
            /// @brief Creates a Button.
            /// @param RendName The name to be given to this Button.
            /// @return Returns a pointer to the created Button.
            virtual Button* CreateButton(const String& RendName);
            /// @brief Creates a Button.
            /// @param RendName The name to be given to this Button.
            /// @param RendRect The rect describing this Button's transform relative to it's parent.
            /// @return Returns a pointer to the created Button.
            virtual Button* CreateButton(const String& RendName, const UnifiedRect& RendRect);
            /// @brief Creates a StackButton.
            /// @param RendName The name to be given to this StackButton.
            /// @return Returns a pointer to the created StackButton.
            virtual StackButton* CreateStackButton(const String& RendName);
            /// @brief Creates a MenuButton.
            /// @param RendName The name to be given to this StackButton.
            /// @param RendRect The rect describing this StackButton's transform relative to it's parent.
            /// @return Returns a pointer to the created StackButton.
            virtual StackButton* CreateStackButton(const String& RendName, const UnifiedRect& RendRect);
            /// @brief Creates a RadioButton.
            /// @param RendName The name to be given to this RadioButton.
            /// @return Returns a pointer to the created RadioButton.
            virtual RadioButton* CreateRadioButton(const String& RendName);
            /// @brief Creates a RadioButton.
            /// @param RendName The name to be given to this RadioButton.
            /// @param RendRect The rect describing this RadioButton's transform relative to it's parent.
            /// @return Returns a pointer to the created RadioButton.
            virtual RadioButton* CreateRadioButton(const String& RendName, const UnifiedRect& RendRect);
            /// @brief Creates a CheckBox.
            /// @param RendName The name of the CheckBox.
            /// @return Returns a pointer to the created CheckBox.
            virtual CheckBox* CreateCheckBox(const String& RendName);
            /// @brief Creates a CheckBox.
            /// @param RendName The name of the CheckBox.
            /// @param RendRect The Rect representing the position and size of the CheckBox.
            /// @return Returns a pointer to the created CheckBox.
            virtual CheckBox* CreateCheckBox(const String& RendName, const UnifiedRect& RendRect);
            /// @brief Creates a EditBox.
            /// @param RendName The name of the EditBox.
            /// @param EditLayerType The type of text layer to be auto-created for editing.
            /// @param EditFont A pointer to the font to be used by the edit layer.
            /// @return Returns a pointer to the created EditBox.
            virtual EditBox* CreateEditBox(const String& RendName, const RenderLayerType EditLayerType, FontData* EditFont);
            /// @brief Creates a EditBox.
            /// @param RendName The name of the EditBox.
            /// @param EditLayerType The type of text layer to be auto-created for editing.
            /// @param EditFontName The name of the font to be used by the edit layer.
            /// @return Returns a pointer to the created EditBox.
            virtual EditBox* CreateEditBox(const String& RendName, const RenderLayerType EditLayerType, const String& EditFontName);
            /// @brief Creates a EditBox.
            /// @param RendName The name of the EditBox.
            /// @param RendRect The Rect representing the position and size of the EditBox.
            /// @param EditLayerType The type of text layer to be auto-created for editing.
            /// @param EditFont A pointer to the font to be used by the edit layer.
            /// @return Returns a pointer to the created EditBox.
            virtual EditBox* CreateEditBox(const String& RendName, const UnifiedRect& RendRect, const RenderLayerType EditLayerType, FontData* EditFont);
            /// @brief Creates a EditBox.
            /// @param RendName The name of the EditBox.
            /// @param RendRect The Rect representing the position and size of the EditBox.
            /// @param EditLayerType The type of text layer to be auto-created for editing.
            /// @param EditFontName The name of the font to be used by the edit layer.
            /// @return Returns a pointer to the created EditBox.
            virtual EditBox* CreateEditBox(const String& RendName, const UnifiedRect& RendRect, const RenderLayerType EditLayerType, const String& EditFontName);

            /// @brief Creates a Scrollbar aligned on the X axis.
            /// @param RendName The name of the HorizontalScrollbar.
            /// @param Style The style of scrollbar you want to create, see Scrollbar documentation for more details.
            /// @return Returns a pointer to the created HorizontalScrollbar.
            virtual HorizontalScrollbar* CreateHorizontalScrollbar(const String& RendName, const UI::ScrollbarStyle Style);
            /// @brief Creates a Scrollbar aligned on the X axis.
            /// @param RendName The name of the HorizontalScrollbar.
            /// @param RendRect The Rect representing the position and size of the HorizontalScrollbar.
            /// @param Style The style of scrollbar you want to create, see Scrollbar documentation for more details.
            /// @return Returns a pointer to the created HorizontalScrollbar.
            virtual HorizontalScrollbar* CreateHorizontalScrollbar(const String& RendName, const UnifiedRect& RendRect, const UI::ScrollbarStyle Style);
            /// @brief Creates a Scrollbar aligned on the Y axis.
            /// @param RendName The name of the VerticalScrollbar.
            /// @param Style The style of scrollbar you want to create, see Scrollbar documentation for more details.
            /// @return Returns a pointer to the created VerticalScrollbar.
            virtual VerticalScrollbar* CreateVerticalScrollbar(const String& RendName, const UI::ScrollbarStyle Style);
            /// @brief Creates a Scrollbar aligned on the Y axis.
            /// @param RendName The name of the VerticalScrollbar.
            /// @param RendRect The Rect representing the position and size of the VerticalScrollbar.
            /// @param Style The style of scrollbar you want to create, see Scrollbar documentation for more details.
            /// @return Returns a pointer to the created VerticalScrollbar.
            virtual VerticalScrollbar* CreateVerticalScrollbar(const String& RendName, const UnifiedRect& RendRect, const UI::ScrollbarStyle Style);
            /// @brief Creates a Spinner.
            /// @param RendName The name of the Spinner.
            /// @param SpinStyle The layout of buttons this Spinner will have.
            /// @param EditFont A pointer to the font to be used by the edit layer.
            /// @return Returns a pointer to the created Spinner.
            virtual Spinner* CreateSpinner(const String& RendName, const SpinnerStyle SpinStyle, FontData* EditFont);
            /// @brief Creates a Spinner.
            /// @param RendName The name of the Spinner.
            /// @param SpinStyle The layout of buttons this Spinner will have.
            /// @param EditFontName The name of the font to be used by the edit layer.
            /// @return Returns a pointer to the created Spinner.
            virtual Spinner* CreateSpinner(const String& RendName, const SpinnerStyle SpinStyle, const String& EditFontName);
            /// @brief Creates a Spinner.
            /// @param RendName The name of the Spinner.
            /// @param RendRect The Rect representing the position and size of the Spinner.
            /// @param SpinStyle The layout of buttons this Spinner will have.
            /// @param EditFont A pointer to the font to be used by the edit layer.
            /// @return Returns a pointer to the created Spinner.
            virtual Spinner* CreateSpinner(const String& RendName, const UnifiedRect& RendRect, const SpinnerStyle SpinStyle, FontData* EditFont);
            /// @brief Creates a Spinner.
            /// @param RendName The name of the Spinner.
            /// @param RendRect The Rect representing the position and size of the Spinner.
            /// @param SpinStyle The layout of buttons this Spinner will have.
            /// @param EditFontName The name of the font to be used by the edit layer.
            /// @return Returns a pointer to the created Spinner.
            virtual Spinner* CreateSpinner(const String& RendName, const UnifiedRect& RendRect, const SpinnerStyle SpinStyle, const String& EditFontName);

            /// @brief Creates a MenuEntry.
            /// @param RendName The name to be given to this MenuEntry.
            /// @return Returns a pointer to the created MenuEntry.
            virtual MenuEntry* CreateMenuEntry(const String& RendName);
            /// @brief Creates a MenuEntry.
            /// @param RendName The name to be given to this MenuEntry.
            /// @param RendRect The rect describing this MenuEntry's transform relative to it's parent.
            /// @return Returns a pointer to the created MenuEntry.
            virtual MenuEntry* CreateMenuEntry(const String& RendName, const UnifiedRect& RendRect);
            /// @brief Creates a TabSet.
            /// @param RendName The name to be given to this TabSet.
            /// @return Returns a pointer to the created TabSet.
            virtual TabSet* CreateTabSet(const String& RendName);
            /// @brief Creates a TabSet.
            /// @param RendName The name to be given to this TabSet.
            /// @param RendRect The rect describing this TabSet's transform relative to it's parent.
            /// @return Returns a pointer to the created TabSet.
            virtual TabSet* CreateTabSet(const String& RendName, const UnifiedRect& RendRect);
            /// @brief Creates a ListBox.
            /// @param RendName The name to be given to this ListBox.
            /// @param Style The style of scrollbar you want to create, see Scrollbar documentation for more details.
            /// @return Returns a pointer to the created ListBox.
            virtual ListBox* CreateListBox(const String& RendName, const UI::ScrollbarStyle Style);
            /// @brief Creates a ListBox.
            /// @param RendName The name to be given to this ListBox.
            /// @param RendRect The rect describing this ListBox's transform relative to it's parent.
            /// @param Style The style of scrollbar you want to create, see Scrollbar documentation for more details.
            /// @return Returns a pointer to the created ListBox.
            virtual ListBox* CreateListBox(const String& RendName, const UnifiedRect& RendRect, const UI::ScrollbarStyle Style);
            /// @brief Creates a DropDownList.
            /// @param RendName The name to be given to this DropDownList.
            /// @param Style An enum value representing how the scrollbar child of the ListBox will be constructed.  See @ref UI::ScrollbarStyle enum for more info.
            /// @return Returns a pointer to the created DropDownList.
            virtual DropDownList* CreateDropDownList(const String& RendName, const UI::ScrollbarStyle Style);
            /// @brief Creates a DropDownList.
            /// @param RendName The name to be given to this DropDownList.
            /// @param RendRect The rect describing this DropDownList's transform relative to it's parent.
            /// @param Style An enum value representing how the scrollbar child of the ListBox will be constructed.  See @ref UI::ScrollbarStyle enum for more info.
            /// @return Returns a pointer to the created DropDownList.
            virtual DropDownList* CreateDropDownList(const String& RendName, const UnifiedRect& RendRect, const UI::ScrollbarStyle Style);

            /// @brief Creates a widget container aligned on the X axis.
            /// @param RendName The name to be given to this renderable.
            /// @return Returns a pointer to the created HorizontalContainer.
            virtual HorizontalContainer* CreateHorizontalContainer(const String& RendName);
            /// @brief Creates a widget container aligned on the X axis.
            /// @param RendName The name to be given to this renderable.
            /// @param RendRect The rect describing this widget's transform relative to it's parent.
            /// @return Returns a pointer to the created HorizontalContainer.
            virtual HorizontalContainer* CreateHorizontalContainer(const String& RendName, const UnifiedRect& RendRect);
            /// @brief Creates a widget container aligned on the Y axis.
            /// @param RendName The name to be given to this renderable.
            /// @return Returns a pointer to the created VerticalContainer.
            virtual VerticalContainer* CreateVerticalContainer(const String& RendName);
            /// @brief Creates a widget container aligned on the Y axis.
            /// @param RendName The name to be given to this renderable.
            /// @param RendRect The rect describing this widget's transform relative to it's parent.
            /// @return Returns a pointer to the created VerticalContainer.
            virtual VerticalContainer* CreateVerticalContainer(const String& RendName, const UnifiedRect& RendRect);
            /// @brief Creates a widget container for the placement of widgets on a 2D grid.
            /// @param RendName The name to be given to this renderable.
            /// @return Returns a pointer to the created GridContainer.
            virtual GridContainer* CreateGridContainer(const String& RendName);
            /// @brief Creates a widget container for the placement of widgets on a 2D grid.
            /// @param RendName The name to be given to this renderable.
            /// @param RendRect The rect describing this widget's transform relative to it's parent.
            /// @return Returns a pointer to the created GridContainer.
            virtual GridContainer* CreateGridContainer(const String& RendName, const UnifiedRect& RendRect);

            /*/// @brief Creates a Window.
            /// @return Returns a pointer to the created Window.
            /// @param Name The name of the Window.
            /// @param RendRect The Rect representing the position and size of the Window.
            virtual Window* CreateWidgetWindow(ConstString& Name, const Rect& RendRect);// */

            ///////////////////////////////////////////////////////////////////////////////
            // Atlas Query

            /// @brief Sets the Atlas to be assumed when one isn't provided for atlas related tasks.
            /// @param Atlas The name of the atlas to be used.
            virtual void SetPrimaryAtlas(const String& Atlas);
            /// @brief Gets the currently set primary atlas.
            /// @return Returns a string containing the name of the primary atlas that is set.
            virtual String GetPrimaryAtlas();
            /// @brief Gets the position of the white pixel from an Atlas.
            /// @param Atlas The name of the Atlas to get the white pixel from.
            /// @return Returns a Vector2 with the location of white pixel on the Atlas.
            Vector2 GetWhitePixel(const String& Atlas) const;
            /// @brief Gets a sprite from an Atlas.
            /// @param SpriteName The name of the sprite to retrieve.
            /// @param Atlas The name of the Atlas to get the sprite from.
            /// @return Returns a pointer to the requested Sprite.
            Sprite* GetSprite(const String& SpriteName, const String& Atlas) const;
            /// @brief Gets the specified FontData from an Atlas.
            /// @param FontName The name of the Font to retrieve.
            /// @param Atlas The name of the atlas to check the specified FontData for.
            /// @return Returns a pointer to the requested FontData.
            FontData* GetFont(const String& FontName, const String& Atlas) const;
            /// @brief Gets the texture size of the specified Atlas.
            /// @param Atlas The name of the atlas to get the texture size of.
            /// @return Returns a Vector2 containing the size of the requested Atlas.
            Vector2 GetTextureSize(const String& Atlas) const;
            /// @brief Gets an atlas that has been loaded.
            /// @param Atlas The name of the Atlas to retrieve, usually stored as a filename.
            /// @return Returns a pointer to the requested Texture Atlas.
            TextureAtlas* GetAtlas(const String& Atlas) const;
            /// @brief Gets the X axis Texel Offset for the current rendersystem.
            /// @return Retruns a real containing the texel offset to be applied to renderables on this screen.
            Real GetTexelOffsetX() const;
            /// @brief Gets the Y axis Texel Offset for the current rendersystem.
            /// @return Retruns a real containing the texel offset to be applied to renderables on this screen.
            Real GetTexelOffsetY() const;

            ///////////////////////////////////////////////////////////////////////////////
            // Other Query

            /// @brief Checks to see if a MarkupParser has already been registsered under a specific name.
            /// @param ParserName The name of the MarkupParser to check for.
            /// @return Returns true if a MarkupParser is registered under the specified name.
            bool IsMarkupParserRegistered(const String& ParserName) const;
            /// @brief Gets a MarkupParser by it's registered name.
            /// @param ParserName The name of the MarkupParser to retrieve.
            /// @return Returns a pointer to the requested MarkupParser, or NULL if none are registered under the specified name.
            UI::MarkupParser* GetMarkupParser(const String& ParserName) const;

            ///////////////////////////////////////////////////////////////////////////////
            // Serialization

            /// @copydoc Renderable::ProtoSerializeProperties(XML::Node&) const
            virtual void ProtoSerializeProperties(XML::Node& SelfRoot) const;
            /// @copydoc Renderable::ProtoDeSerializeProperties(const XML::Node&)
            virtual void ProtoDeSerializeProperties(const XML::Node& SelfRoot);

            /// @copydoc Renderable::GetDerivedSerializableName() const
            virtual String GetDerivedSerializableName() const;
            /// @copydoc Renderable::GetSerializableName()
            static String GetSerializableName();

            ///////////////////////////////////////////////////////////////////////////////
            // Internal Functions

            /// @copydoc Renderable::_MarkDirty()
            void _MarkDirty();
            /// @copydoc QuadRenderable::_MarkAllLayersDirty()
            virtual void _MarkAllLayersDirty();
            /// @internal
            /// @brief Manually calls the UI system to render this screen.
            void _RenderScreen();
            /// @internal
            /// @brief Forces an orientation mode change for this screen.
            /// @param Mode The orientation mode to be applied to the UI on this screen.
            void _SetOrientation(const Mezzanine::OrientationMode& Mode);
            /// @internal
            /// @brief Updates the vertex positions so they are in front of the camera in world space.
            /// @param RenderData Vector of the vertices to be transformed.
            /// @param Begin The first Vertex to transform in the range.
            /// @param End The last Vertex to transform in the range.
            void _Transform(ScreenRenderData& RenderData, const Whole& Begin, const Whole& End);
            /// @internal
            /// @brief Prepares all vertices for rendering to the screen.
            /// @param Force Whether or not to force preparation regardless of if they need it.
            void _RenderVertices(bool Force = false);

            /// @internal
            /// @brief Processes all children of this screen by their zorder.
            /// @param CB The callback implementing how the children are to be processed.
            /// @return Returns the result of the callback, and exits early if true.
            template<typename Callback>
            Boole _ProcessAllChildren(Callback* CB)
            {
                for( ChildIterator ChildIt = this->ChildrenBegin() ; ChildIt != this->ChildrenEnd() ; ++ChildIt )
                {
                    if( Screen::_ProcessAllChildren((*ChildIt),CB) )
                        return true;
                }
                return false;
            }
            /// @internal
            /// @brief Processes all children of this screen in reverse zorder.
            /// @param CB The callback implementing how the children are to be processed.
            /// @return Returns the result of the callback, and exits early if true.
            template<typename Callback>
            Boole _ReverseProcessAllChildren(Callback* CB)
            {
                for( ReverseChildIterator RChildIt = this->RChildrenBegin() ; RChildIt != this->RChildrenEnd() ; ++RChildIt )
                {
                    if( Screen::_ReverseProcessAllChildren((*RChildIt),CB) )
                        return true;
                }
                return false;
            }
            /// @internal
            /// @brief Processes all children of this screen by their zorder.
            /// @param Wid The Widget whose children need to be processed.
            /// @param CB The callback implementing how the children are to be processed.
            /// @return Returns the result of the callback, and exits early if true.
            template<typename Callback>
            static Boole _ProcessAllChildren(Widget* Wid, Callback* CB)
            {
                if( (*CB)(Wid) )
                    return true;
                for( ChildIterator ChildIt = Wid->ChildrenBegin() ; ChildIt != Wid->ChildrenEnd() ; ++ChildIt )
                {
                    if( Screen::_ProcessAllChildren((*ChildIt),CB) )
                        return true;
                }
                return false;
            }
            /// @internal
            /// @brief Processes all children of this screen in reverse zorder.
            /// @param Wid The Widget whose children need to be processed.
            /// @param CB The callback implementing how the children are to be processed.
            /// @return Returns the result of the callback, and exits early if true.
            template<typename Callback>
            static Boole _ReverseProcessAllChildren(Widget* Wid, Callback* CB)
            {
                for( ReverseChildIterator RChildIt = Wid->RChildrenBegin() ; RChildIt != Wid->RChildrenEnd() ; ++RChildIt )
                {
                    if( Screen::_ReverseProcessAllChildren((*RChildIt),CB) )
                        return true;
                }
                if( (*CB)(Wid) )
                    return true;

                return false;
            }
        };//uiscreen
    }//ui
}//Mezzanine

#endif