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 <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;
    };

        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)
        {
                Logger::getSingleton().logEvent("CEGUI::WindowFactoryManager singleton created");
        }


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


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


        void    removeFactory(const String& name);


        void    removeFactory(WindowFactory* factory);


        void    removeAllFactories(void)                {d_factoryRegistry.clear();}


        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);

    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;    

        WindowFactoryRegistry   d_factoryRegistry;                      
        TypeAliasRegistry               d_aliasRegistry;                        
    FalagardMapRegistry     d_falagardRegistry;         

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;
};

} // End of  CEGUI namespace section


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

#endif  // end of guard _CEGUIWindowFactoryManager_h_