uimanager.cpp

// © Copyright 2010 - 2014 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 _uiuimanager_cpp
#define _uiuimanager_cpp

#include "UI/uimanager.h"
#include "UI/textureatlashandler.h"
#include "UI/textureatlas.h"
#include "UI/hotkeyhandler.h"
#include "UI/actionhandler.h"
#include "UI/screen.h"
#include "UI/button.h"
#include "UI/widget.h"
#include "UI/glyph.h"

// includes for the creation and destruction of the global parser
#include "UI/defaultmarkupparser.h"

#include "Graphics/cameramanager.h"
#include "Graphics/graphicsmanager.h"
#include "Graphics/viewport.h"
#include "Input/inputmanager.h"
#include "Input/mouse.h"
#include "eventmanager.h"
#include "resourcemanager.h"

#include "mathtool.h"
#include "timer.h"
#include "entresol.h"

#include <Ogre.h>

namespace Mezzanine
{
    template<> UI::UIManager* Singleton<UI::UIManager>::SingletonPtr = NULL;

    namespace UI
    {
        ///////////////////////////////////////////////////////////////////////////////
        // WidgetUpdateWorkUnit Methods

        WidgetUpdateWorkUnit::WidgetUpdateWorkUnit(const WidgetUpdateWorkUnit& Other)
            {  }

        WidgetUpdateWorkUnit& WidgetUpdateWorkUnit::operator=(const WidgetUpdateWorkUnit& Other)
            { return *this; }

        WidgetUpdateWorkUnit::WidgetUpdateWorkUnit(UIManager* Target) :
            TargetManager(Target) {  }

        WidgetUpdateWorkUnit::~WidgetUpdateWorkUnit()
            {  }

        ///////////////////////////////////////////////////////////////////////////////
        // Utility

        void WidgetUpdateWorkUnit::DoWork(Threading::DefaultThreadSpecificStorage::Type& CurrentThreadStorage)
            { this->TargetManager->UpdateScreens(); }

        ///////////////////////////////////////////////////////////////////////////////
        // UIManager Methods

        UIManager::UIManager() :
            HoveredWidget(NULL),
            WidgetFocus(NULL),

            WidgetUpdateWork(NULL),
            ThreadResources(NULL),

            ButtonAutoRegister(false),
            MouseMoved(false)
        {
            ResourceManager::GetSingletonPtr()->CreateAssetGroup("UI");
            this->AtlasHandler = new TextureAtlasHandler();
            this->HKHandler = new HotKeyHandler();
            //this->ActHandler = new ActionHandler();

            // Parser Work
            MarkupParser* DefaultParser = new DefaultMarkupParser();
            this->RegisterMarkupParser(DefaultParser->GetName(),DefaultParser);
            this->RegisterMarkupParser("",DefaultParser);

            this->WidgetUpdateWork = new WidgetUpdateWorkUnit(this);
        }

        UIManager::UIManager(XML::Node& XMLNode) :
            HoveredWidget(NULL),
            WidgetFocus(NULL),

            WidgetUpdateWork(NULL),
            ThreadResources(NULL),

            ButtonAutoRegister(false),
            MouseMoved(false)
        {
            /// @todo This class currently doesn't initialize anything from XML, if that changes this constructor needs to be expanded.
            ResourceManager::GetSingletonPtr()->CreateAssetGroup("UI");
            this->AtlasHandler = new TextureAtlasHandler();
            this->HKHandler = new HotKeyHandler();
            //this->ActHandler = new ActionHandler();

            // Parser Work
            MarkupParser* DefaultParser = new DefaultMarkupParser();
            this->RegisterMarkupParser(DefaultParser->GetName(),DefaultParser);
            this->RegisterMarkupParser("",DefaultParser);

            this->WidgetUpdateWork = new WidgetUpdateWorkUnit(this);
        }

        UIManager::~UIManager()
        {
            this->Deinitialize();
            this->DestroyAllScreens();

            delete this->WidgetUpdateWork;
        }

        void UIManager::HandlePreFocusInput(const Input::MetaCode& Code)
        {
            if( Code.IsKeyboardEvent() )
                this->HandlePreFocusKeyboardInput( Code );
            else if( Code.IsMouseEvent() )
                this->HandlePreFocusMouseInput( Code );
            else if( Code.IsControllerEvent() )
                this->HandlePreFocusControllerInput( Code );
            /// @todo If other devices are added, appropriate functions should be added to this class, and called here.
        }

        void UIManager::HandlePostFocusInput(const Input::MetaCode& Code)
        {
            if( Code.IsKeyboardEvent() )
                this->HandlePostFocusKeyboardInput( Code );
            else if( Code.IsMouseEvent() )
                this->HandlePostFocusMouseInput( Code );
            else if( Code.IsControllerEvent() )
                this->HandlePostFocusControllerInput( Code );
            /// @todo If other devices are added, appropriate functions should be added to this class, and called here.
        }

        void UIManager::HandlePreFocusKeyboardInput(const Input::MetaCode& Code)
        {

        }

        void UIManager::HandlePreFocusMouseInput(const Input::MetaCode& Code)
        {
            if( Code.IsMouseButton() ) {
                if( Input::BUTTON_PRESSING == Code.GetMetaValue() ) {
                    // Update the focus
                    //Bool Switched = SwitchFocus(HoveredWidget);
                    this->SwitchFocus(HoveredWidget);

                    // If we got a valid focus, there is more work to be done
                    if( this->WidgetFocus ) {
                        // Regardless of it has changed, lock the focus
                        if( !FocusIsLocked() ) {
                            this->WidgetFocus->_OnFocusLocked();
                            this->FocusLockCode = Code;
                        }

                        // If we have a new focus, inform it of the input
                        // Only do this if we switched because if it's an old focus it already had a chance
                        // at the input code, and we don't want to double dip.
                        //if( Switched )
                        //    this->WidgetFocus->_HandleInput(Code);
                    }
                }else if( Input::BUTTON_LIFTING == Code.GetMetaValue() ) {
                    if( this->WidgetFocus ) {
                        // Check the code to see if we're releasing the focus lock
                        if( this->FocusLockCode.GetCode() == Code.GetCode() ) {
                            this->WidgetFocus->_OnFocusUnlocked();
                            this->FocusLockCode.SetNullValues();
                        }

                        // Pass on the input
                        //this->WidgetFocus->_HandleInput(Code);
                    }
                }
            }
        }

        void UIManager::HandlePreFocusControllerInput(const Input::MetaCode& Code)
        {
            /// @todo There is currently nothing that the UI system as a whole needs controller inputs.
            /// Perhaps when we implement consoles this should be expanded, maybe even sooner then that.
        }

        void UIManager::HandlePostFocusKeyboardInput(const Input::MetaCode& Code)
        {

        }

        void UIManager::HandlePostFocusMouseInput(const Input::MetaCode& Code)
        {
            if( Code.IsMouseMotionEvent() )
            {

            }
        }

        void UIManager::HandlePostFocusControllerInput(const Input::MetaCode& Code)
        {
            /// @todo There is currently nothing that the UI system as a whole needs controller inputs.
            /// Perhaps when we implement consoles this should be expanded, maybe even sooner then that.
        }

        bool UIManager::SwitchFocus(Widget* NewFocus)
        {
            // Check if the focus is changing at all
            if( this->WidgetFocus != NewFocus && !this->FocusIsLocked() )
            {
                // If we already have a focus, drop it
                if( this->WidgetFocus )
                    this->WidgetFocus->_OnFocusLost();

                // Assign the new focus
                this->WidgetFocus = NewFocus;

                // If the new focus is valid, notify it of it's new status
                if( this->WidgetFocus )
                    this->WidgetFocus->_OnFocusGained();

                // Acknowledge the focus was changed
                return true;
            }
            // Nothing changed
            return false;
        }

        bool UIManager::FocusIsLocked() const
        {
            return ( Input::KEY_UNKNOWN != FocusLockCode.GetCode() );
        }

        ///////////////////////////////////////////////////////////////////////////////
        // Texture Atlas Management

        void UIManager::LoadMTA(const String& Name, const String& Group)
        {
            this->AtlasHandler->LoadAtlasFromFile(Name,Group);
        }

        TextureAtlas* UIManager::GetAtlas(const String& AtlasName)
        {
            return this->AtlasHandler->GetAtlas(AtlasName);
        }

        ///////////////////////////////////////////////////////////////////////////////
        // Screen Management

        Screen* UIManager::CreateScreen(const String& ScreenName, const String& Atlas, Graphics::Viewport* WindowViewport)
        {
            Screen* MezzScreen = new Screen(ScreenName,Atlas,WindowViewport,this);
            this->Screens.push_back(MezzScreen);
            return MezzScreen;
        }

        Screen* UIManager::GetScreen(const String& Name)
        {
            for( ScreenIterator it = this->Screens.begin() ; it != this->Screens.end() ; it++ )
            {
                if ( Name == (*it)->GetName() ) {
                    Screen* MezzScreen = (*it);
                    return MezzScreen;
                }
            }
            return 0;
        }

        Screen* UIManager::GetScreen(const Whole& Index)
        {
            return this->Screens[Index];
        }

        Whole UIManager::GetNumScreens()
        {
            return this->Screens.size();
        }

        void UIManager::DestroyScreen(Screen* Screen)
        {
            for( ScreenIterator it = this->Screens.begin() ; it != this->Screens.end() ; it++ )
            {
                if( Screen == (*it) ) {
                    delete (*it);
                    this->Screens.erase(it);
                    return;
                }
            }
        }

        void UIManager::DestroyAllScreens()
        {
            for( ScreenIterator it = this->Screens.begin() ; it != this->Screens.end() ; it++ )
            {
                delete (*it);
            }
            this->Screens.clear();
        }

        void UIManager::ShowScreensOnViewport(Graphics::Viewport* WindowViewport)
        {
            for( ScreenIterator ScreenIt = this->Screens.begin() ; ScreenIt != this->Screens.end() ; ++ScreenIt )
            {
                if( (*ScreenIt)->GetViewport() == WindowViewport ) {
                    (*ScreenIt)->Show();
                }
            }
        }

        void UIManager::ShowAllScreens()
        {
            for( ScreenIterator ScreenIt = this->Screens.begin() ; ScreenIt != this->Screens.end() ; ++ScreenIt )
            {
                (*ScreenIt)->Show();
            }
        }

        void UIManager::HideScreensOnViewport(Graphics::Viewport* WindowViewport, Screen* Exclude)
        {
            for( ScreenIterator ScreenIt = this->Screens.begin() ; ScreenIt != this->Screens.end() ; ++ScreenIt )
            {
                if( (*ScreenIt)->GetViewport() == WindowViewport ) {
                    (*ScreenIt)->Hide();
                }
            }
        }

        void UIManager::HideAllScreens()
        {
            for( ScreenIterator ScreenIt = this->Screens.begin() ; ScreenIt != this->Screens.end() ; ++ScreenIt )
            {
                (*ScreenIt)->Hide();
            }
        }

        Screen* UIManager::GetVisibleScreenOnViewport(Graphics::Viewport* WindowViewport)
        {
            for( ScreenIterator ScreenIt = this->Screens.begin() ; ScreenIt != this->Screens.end() ; ++ScreenIt )
            {
                if( (*ScreenIt)->GetViewport() == WindowViewport && (*ScreenIt)->IsVisible() ) {
                    return (*ScreenIt);
                }
            }
            return NULL;
        }

        ///////////////////////////////////////////////////////////////////////////////
        // HotKey and Activation Management

        void UIManager::BindHotKey(const Input::MetaCode& HotKey, Button* BoundButton)
        {
            this->HKHandler->BindHotKey(HotKey,BoundButton);
        }

        void UIManager::UnbindHotKey(const Input::MetaCode& HotKey, Button* BoundButton)
        {
            this->HKHandler->UnbindHotKey(HotKey,BoundButton);
        }

        ///////////////////////////////////////////////////////////////////////////////
        // Activation Management

        void UIManager::EnableButtonAutoRegister(bool Enable)
        {
            this->ButtonAutoRegister = Enable;
        }

        bool UIManager::ButtonAutoRegisterEnabled()
        {
            return this->ButtonAutoRegister;
        }

        void UIManager::AddAutoRegisterCode(const Input::MetaCode& Code)
        {
            for( InputIterator It = this->AutoRegisterCodes.begin() ; It != this->AutoRegisterCodes.end() ; It++ )
            {
                if((*It)==Code)
                    return;
            }
            this->AutoRegisterCodes.push_back(Code);
        }

        void UIManager::RemoveAutoRegisterCode(const Input::MetaCode& Code)
        {
            for( InputIterator It = this->AutoRegisterCodes.begin() ; It != this->AutoRegisterCodes.end() ; It++ )
            {
                if((*It)==Code) {
                    this->AutoRegisterCodes.erase(It);
                    return;
                }
            }
        }

        void UIManager::RemoveAllAutoRegisterCodes()
        {
            this->AutoRegisterCodes.clear();
        }

        UIManager::InputContainer* UIManager::GetAutoRegisteredCodes()
        {
            return &(this->AutoRegisterCodes);
        }

        ///////////////////////////////////////////////////////////////////////////////
        // MarkupParser Management

        void UIManager::RegisterMarkupParser(const String& ParserName, MarkupParser* ToAdd)
        {
            MarkupParserIterator MarkupIt = this->MarkupParsers.find(ParserName);
            if( MarkupIt != this->MarkupParsers.end() ) {
                MEZZ_EXCEPTION(Exception::II_DUPLICATE_IDENTITY_EXCEPTION,"A MarkupParser with the name \"" + ParserName + "\" is already registered.");
            }else{
                this->MarkupParsers.insert( std::pair<String,UI::MarkupParser*>(ParserName,ToAdd) );
            }
        }

        bool UIManager::IsMarkupParserRegistered(const String& ParserName) const
        {
            ConstMarkupParserIterator MarkupIt = this->MarkupParsers.find(ParserName);
            return ( MarkupIt != this->MarkupParsers.end() );
        }

        MarkupParser* UIManager::GetMarkupParser(const String& ParserName) const
        {
            ConstMarkupParserIterator MarkupIt = this->MarkupParsers.find(ParserName);
            if( MarkupIt != this->MarkupParsers.end() ) return (*MarkupIt).second;
            else return NULL;
        }

        void UIManager::UnregisterMarkupParser(const String& ParserName)
        {
            MarkupParserIterator MarkupIt = this->MarkupParsers.find(ParserName);
            if( MarkupIt != this->MarkupParsers.end() )
                this->MarkupParsers.erase(MarkupIt);
        }

        void UIManager::UnregisterAllMarkupParsers()
        {
            this->MarkupParsers.clear();
        }

        void UIManager::DestroyMarkupParser(const String& ParserName)
        {
            MarkupParserIterator MarkupIt = this->MarkupParsers.find(ParserName);
            if( MarkupIt != this->MarkupParsers.end() ) {
                delete (*MarkupIt).second;
                this->MarkupParsers.erase(MarkupIt);
            }
        }

        void UIManager::DestroyAllMarkupParsers()
        {
            for( MarkupParserIterator MarkupIt = this->MarkupParsers.begin() ; MarkupIt != this->MarkupParsers.end() ; ++MarkupIt )
            {
                delete (*MarkupIt).second;
            }
            this->MarkupParsers.clear();
        }

        ///////////////////////////////////////////////////////////////////////////////
        // Fetch Methods

        Widget* UIManager::GetHoveredWidget() const
            { return this->HoveredWidget; }

        Widget* UIManager::GetWidgetFocus() const
            { return this->WidgetFocus; }

        TextureAtlasHandler* UIManager::GetAtlasHandler() const
            { return this->AtlasHandler; }

        ///////////////////////////////////////////////////////////////////////////////
        // Utility

        void UIManager::InjectInput(const Input::MetaCode& Code)
        {
            switch( Code.GetCode() )
            {
                case Input::MOUSEHORIZONTAL:
                case Input::MOUSEVERTICAL:
                {
                    this->MouseMoved = true;
                    break;
                }
                default:  /* Do Nothing */  break;
            }

            this->InjectedInputs.push_back(Code);
        }

        Widget* UIManager::CheckWidgetUnderPoint(Graphics::Viewport* VP, const Vector2& Point)
        {
            Screen* VisScreen = this->GetVisibleScreenOnViewport(VP);
            if( VisScreen != NULL ) {
                Widget* Wid = VisScreen->FindHoveredWidget(Point);
                return Wid;
            }
            return NULL;
        }

        Boolean UIManager::MouseIsInUISystem() const
        {
            return (HoveredWidget || WidgetFocus);
        }

        UIManager::FontResult UIManager::SuggestGlyphIndex(const Whole& Height, const String& Atlas)
        {
            TextureAtlas* TheAtlas = AtlasHandler->GetAtlas(Atlas);
            if(NULL == TheAtlas)
            {
                MEZZ_EXCEPTION(Exception::PARAMETERS_EXCEPTION,"Attempting to access TextureAtlas \"" + Atlas + "\", which does not exist or is not loaded.");
            }
            TextureAtlas::FontDataContainer& Fonts = TheAtlas->GetFonts();
            String LargerMatch, SmallerMatch;
            Real LargerHeight = 0;
            Real SmallerHeight = 0;
            Real LargerMatchDiff = 1000000.0;
            Real SmallerMatchDiff = 1000000.0;
            Real RequestedHeight = (Real)Height;

            for( TextureAtlas::FontDataIterator it = Fonts.begin() ; it != Fonts.end() ; it++ )
            {
                Real Diff = 0.0;
                if((*it).second->GetLineHeight() > RequestedHeight)
                {
                    Diff = (*it).second->GetLineHeight() - RequestedHeight;
                    if(Diff < LargerMatchDiff)
                    {
                        LargerMatch = (*it).first;
                        LargerHeight = (*it).second->GetLineHeight();
                        LargerMatchDiff = Diff;
                        continue;
                    }
                }else{
                    Diff = RequestedHeight - (*it).second->GetLineHeight();
                    if(Diff < SmallerMatchDiff)
                    {
                        SmallerMatch = (*it).first;
                        SmallerHeight = (*it).second->GetLineHeight();
                        SmallerMatchDiff = Diff;
                        continue;
                    }
                }
            }

            Real Scale = 1;
            if(!LargerMatch.empty())
            {
                Scale = RequestedHeight / LargerHeight;
                return FontResult(LargerMatch,Scale);
            }else{
                Scale = RequestedHeight / SmallerHeight;
                return FontResult(SmallerMatch,Scale);
            }
        }

        void UIManager::UpdateScreens()
        {
            Input::Mouse* SysMouse = Input::InputManager::GetSingletonPtr()->GetSystemMouse();

            // Tell all screens to check if the veiwport dimensions have changed
            for( ScreenIterator ScIt = this->Screens.begin() ; ScIt != this->Screens.end() ; ++ScIt )
                (*ScIt)->CheckViewportSize();

            // Inject input delta's from the input system
            const MetaCodeContainer& Inputs = Input::InputManager::GetSingletonPtr()->GetInputDeltas();
            // InjectedInputs.insert(InjectedInputs.end(),Inputs.begin(),Inputs.end());  // ©ommented because we want to use "InjectInput()" so we can filter the codes.
            for( ConstMetaCodeIterator MCIt = Inputs.begin() ; MCIt != Inputs.end() ; ++MCIt )
                this->InjectInput( (*MCIt) );

            // Get the hovered quad based on mouse position
            // We don't care what is hovered so much if the mouse hasn't moved, or is hidden due to relative mode.
            if( this->MouseMoved && !SysMouse->GetRelativeMode() )
            {
                Widget* TempWidget = this->CheckWidgetUnderPoint(SysMouse->GetHoveredViewport(),SysMouse->GetViewportPosition());
                if( TempWidget != this->HoveredWidget )
                {
                    if( this->HoveredWidget ) {
                        this->HoveredWidget->_OnMouseExit();
                    }

                    this->HoveredWidget = TempWidget;

                    if( this->HoveredWidget ) {
                        this->HoveredWidget->_OnMouseEnter();
                        TheEntresol->Log( "New Hovered Widget Name: " + this->HoveredWidget->GetName() );
                    }
                }
            }

            // Check the focus to see if it's still visible.  Drop focus if it's not.
            if( this->WidgetFocus && !this->WidgetFocus->GetVisible() )
            {
                if( this->FocusIsLocked() ) {
                    this->WidgetFocus->_OnFocusUnlocked();
                    this->FocusLockCode.SetNullValues();
                }
                this->WidgetFocus->_OnFocusLost();
                this->WidgetFocus = NULL;
            }

            // Look at and process all injected inputs accordingly
            for( InputIterator InIt = this->InjectedInputs.begin() ; InIt != this->InjectedInputs.end() ; ++InIt )
            {
                // Allow our pre processes to get first dibs.
                this->HandlePreFocusInput( (*InIt) );

                // Allow the focus to consume the input if it needs/wants to.
                if( this->WidgetFocus && this->WidgetFocus->_HandleInput( (*InIt) ) )
                    continue;

                // If the focus doesn't consume the input, we pass it back to the system.
                this->HandlePostFocusInput( (*InIt) );
            }
            this->MouseMoved = false;
            this->InjectedInputs.clear();
        }

        void UIManager::Initialize()
        {
            if( !this->Initialized ) {
                this->TheEntresol->GetScheduler().AddWorkUnitMain( this->WidgetUpdateWork, "WidgetUpdateWork" );
                Input::InputManager* InputMan = Input::InputManager::GetSingletonPtr();
                if( InputMan )
                    this->WidgetUpdateWork->AddDependency( InputMan->GetDeviceUpdateWork() );

                this->Initialized = true;
            }
        }

        void UIManager::Deinitialize()
        {
            if( this->Initialized ) {
                this->TheEntresol->GetScheduler().RemoveWorkUnitMain( this->WidgetUpdateWork );
                this->WidgetUpdateWork->ClearDependencies();

                this->Initialized = false;
            }
        }

        WidgetUpdateWorkUnit* UIManager::GetWidgetUpdateWork()
        {
            return this->WidgetUpdateWork;
        }

        ///////////////////////////////////////////////////////////////////////////////
        // Type Identifier Methods

        ManagerBase::ManagerType UIManager::GetInterfaceType() const
            { return ManagerBase::MT_UIManager; }

        String UIManager::GetImplementationTypeName() const
            { return "DefaultUIManager"; }

        ///////////////////////////////////////////////////////////////////////////////
        // DefaultUIManagerFactory Methods

        DefaultUIManagerFactory::DefaultUIManagerFactory()
            {  }

        DefaultUIManagerFactory::~DefaultUIManagerFactory()
            {  }

        String DefaultUIManagerFactory::GetManagerTypeName() const
            { return "DefaultUIManager"; }

        ManagerBase* DefaultUIManagerFactory::CreateManager(NameValuePairList& Params)
        {
            if( UIManager::SingletonValid() ) {
                /// @todo Add something to log a warning that the manager exists and was requested to be constructed when we have a logging manager set up.
                return UIManager::GetSingletonPtr();
            }else return new UIManager();
        }

        ManagerBase* DefaultUIManagerFactory::CreateManager(XML::Node& XMLNode)
        {
            if( UIManager::SingletonValid() ) {
                /// @todo Add something to log a warning that the manager exists and was requested to be constructed when we have a logging manager set up.
                return UIManager::GetSingletonPtr();
            }else return new UIManager(XMLNode);
        }

        void DefaultUIManagerFactory::DestroyManager(ManagerBase* ToBeDestroyed)
            { delete ToBeDestroyed; }
    }//UI
}//Mezzanine

#endif