WindowFactoryManager.h

/***********************************************************************
        created:        22/2/2004
        author:         Paul D Turner
        
        purpose:        Defines interface for WindowFactoryManager class
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2006 Paul D Turner & The CEGUI Development Team
 *
 *   Permission is hereby granted, free of charge, to any person obtaining
 *   a copy of this software and associated documentation files (the
 *   "Software"), to deal in the Software without restriction, including
 *   without limitation the rights to use, copy, modify, merge, publish,
 *   distribute, sublicense, and/or sell copies of the Software, and to
 *   permit persons to whom the Software is furnished to do so, subject to
 *   the following conditions:
 *
 *   The above copyright notice and this permission notice shall be
 *   included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 ***************************************************************************/
#ifndef _CEGUIWindowFactoryManager_h_
#define _CEGUIWindowFactoryManager_h_

#include "CEGUI/Base.h"
#include "CEGUI/String.h"
#include "CEGUI/Singleton.h"
#include "CEGUI/Logger.h"
#include "CEGUI/IteratorBase.h"
#include "CEGUI/WindowFactory.h"
#include "CEGUI/TplWindowFactory.h"
#include "CEGUI/Exceptions.h"
#include <map>
#include <vector>

#if defined(_MSC_VER)
#       pragma warning(push)
#       pragma warning(disable : 4275)
#       pragma warning(disable : 4251)
#endif


// Start of CEGUI namespace section
namespace CEGUI
{
class CEGUIEXPORT WindowFactoryManager :
    public Singleton<WindowFactoryManager>,
    public AllocatedObject<WindowFactoryManager>
{
public:
    struct CEGUIEXPORT FalagardWindowMapping
    {
        String  d_windowType;
        String  d_lookName;
        String  d_baseType;
        String  d_rendererType;
        String  d_effectName;
    };

        class CEGUIEXPORT AliasTargetStack
        {
        public:
                AliasTargetStack(void) {}


                ~AliasTargetStack(void) {}


                const String&   getActiveTarget(void) const;

                uint    getStackedTargetCount(void) const;


        private:
                friend class WindowFactoryManager;

                typedef std::vector<String
            CEGUI_VECTOR_ALLOC(String)> TargetTypeStack; 

                TargetTypeStack d_targetStack; 
        };


        /*************************************************************************
                Construction and Destruction
        *************************************************************************/
        WindowFactoryManager(void);


        ~WindowFactoryManager(void)
        {
                Logger::getSingleton().logEvent("CEGUI::WindowFactoryManager singleton destroyed");
        }


        /*************************************************************************
                Public Interface
        *************************************************************************/
        void    addFactory(WindowFactory* factory);

    template <typename T>
    static void addFactory();

    template <typename T>
    static void addWindowType();

        void    removeFactory(const String& name);


        void    removeFactory(WindowFactory* factory);


    void removeAllFactories(void);


        WindowFactory*  getFactory(const String& type) const;


    bool        isFactoryPresent(const String& name) const;


        void    addWindowTypeAlias(const String& aliasName, const String& targetType);


        void    removeWindowTypeAlias(const String& aliasName, const String& targetType);

        void removeAllWindowTypeAliases();

    void addFalagardWindowMapping(const String& newType,
                                  const String& targetType,
                                  const String& lookName,
                                  const String& renderer,
                                  const String& effectName = String(""));

    void removeFalagardWindowMapping(const String& type);

    void removeAllFalagardWindowMappings();

    bool isFalagardMappedType(const String& type) const;

    const String& getMappedLookForType(const String& type) const;

    const String& getMappedRendererForType(const String& type) const;

    String getDereferencedAliasType(const String& type) const;

    const FalagardWindowMapping& getFalagardMappingForType(const String& type) const;

private:
        /*************************************************************************
                Implementation Data
        *************************************************************************/
        typedef std::map<String, WindowFactory*, StringFastLessCompare
        CEGUI_MAP_ALLOC(String, WindowFactory*)> WindowFactoryRegistry; 
        typedef std::map<String, AliasTargetStack, StringFastLessCompare
        CEGUI_MAP_ALLOC(String, AliasTargetStack)> TypeAliasRegistry; 
    typedef std::map<String, FalagardWindowMapping, StringFastLessCompare
        CEGUI_MAP_ALLOC(String, FalagardWindowMapping)> FalagardMapRegistry; 
    typedef std::vector<WindowFactory*
        CEGUI_VECTOR_ALLOC(WindowFactory*)> OwnedWindowFactoryList;

        WindowFactoryRegistry   d_factoryRegistry;                      
        TypeAliasRegistry               d_aliasRegistry;                        
    FalagardMapRegistry     d_falagardRegistry;         
    static OwnedWindowFactoryList  d_ownedFactories;

public:
        /*************************************************************************
                Iterator stuff
        *************************************************************************/
        typedef ConstMapIterator<WindowFactoryRegistry> WindowFactoryIterator;
        typedef ConstMapIterator<TypeAliasRegistry>             TypeAliasIterator;
    typedef ConstMapIterator<FalagardMapRegistry>   FalagardMappingIterator;

        WindowFactoryIterator   getIterator(void) const;


        TypeAliasIterator       getAliasIterator(void) const;


    FalagardMappingIterator getFalagardMappingIterator() const;
};

//----------------------------------------------------------------------------//
template <typename T>
void WindowFactoryManager::addFactory()
{
    // create the factory object
    WindowFactory* factory = CEGUI_NEW_AO T;

    // only do the actual add now if our singleton has already been created
    if (WindowFactoryManager::getSingletonPtr())
    {
        Logger::getSingleton().logEvent("Created WindowFactory for '" +
                                        factory->getTypeName() +
                                        "' windows.");
        // add the factory we just created
        CEGUI_TRY
        {
            WindowFactoryManager::getSingleton().addFactory(factory);
        }
        CEGUI_CATCH (Exception&)
        {
            Logger::getSingleton().logEvent("Deleted WindowFactory for '" +
                                            factory->getTypeName() +
                                            "' windows.");
            // delete the factory object
            CEGUI_DELETE_AO factory;
            CEGUI_RETHROW;
        }
    }

    d_ownedFactories.push_back(factory);
}

//----------------------------------------------------------------------------//
template <typename T>
void WindowFactoryManager::addWindowType()
{
    WindowFactoryManager::addFactory<TplWindowFactory<T> >();
}

//----------------------------------------------------------------------------//

} // End of  CEGUI namespace section


#if defined(_MSC_VER)
#       pragma warning(pop)
#endif

#endif  // end of guard _CEGUIWindowFactoryManager_h_