CEGUIWindowFactoryManager.h

/***********************************************************************
        filename:       CEGUIWindowFactoryManager.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 "CEGUIBase.h"
#include "CEGUIString.h"
#include "CEGUISingleton.h"
#include "CEGUILogger.h"
#include "CEGUIIteratorBase.h"
#include "CEGUIWindowFactory.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:
    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>     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();


        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 addFalagardWindowMapping(const String& newType,
                                  const String& targetType,
                                  const String& lookName,
                                  const String& renderer,
                                  const String& effectName = String(""));

    void removeFalagardWindowMapping(const String& type);

    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*, String::FastLessCompare>       WindowFactoryRegistry;          
        typedef std::map<String, AliasTargetStack, String::FastLessCompare>     TypeAliasRegistry;              
    typedef std::map<String, FalagardWindowMapping, String::FastLessCompare> FalagardMapRegistry;    

    typedef std::vector<WindowFactory*> OwnedWindowFactoryList;

        WindowFactoryRegistry   d_factoryRegistry;                      
        TypeAliasRegistry               d_aliasRegistry;                        
    FalagardMapRegistry     d_falagardRegistry;         

    static OwnedWindowFactoryList  d_ownedFactories;

public:
        /*************************************************************************
                Iterator stuff
        *************************************************************************/
        typedef ConstBaseIterator<WindowFactoryRegistry>        WindowFactoryIterator;
        typedef ConstBaseIterator<TypeAliasRegistry>            TypeAliasIterator;
    typedef ConstBaseIterator<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 = new 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
            delete factory;
            CEGUI_RETHROW;
        }
    }

    d_ownedFactories.push_back(factory);
}

} // End of  CEGUI namespace section


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

#endif  // end of guard _CEGUIWindowFactoryManager_h_