ImageManager.h

/***********************************************************************
    filename:   CEGUIImageManager.h
    created:    Wed Feb 16 2011
    author:     Paul D Turner <paul@cegui.org.uk>
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2011 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 _CEGUIImageManager_h_
#define _CEGUIImageManager_h_

#include "CEGUI/Singleton.h"
#include "CEGUI/ChainedXMLHandler.h"
#include "CEGUI/String.h"
#include "CEGUI/Size.h"
#include "CEGUI/ImageFactory.h"
#include "CEGUI/Logger.h"
#include "CEGUI/Exceptions.h"
#include "CEGUI/IteratorBase.h"
#include <map>

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

// Start of CEGUI namespace section
namespace CEGUI
{
class CEGUIEXPORT ImageManager :
        public Singleton<ImageManager>,
        public AllocatedObject<ImageManager>,
        public ChainedXMLHandler
{
public:
    ImageManager();
    ~ImageManager();

    template <typename T>
    void addImageType(const String& name);

    void removeImageType(const String& name);

    bool isImageTypeAvailable(const String& name) const;

    Image& create(const String& type, const String& name);

    Image& create(const XMLAttributes& attributes);

    void destroy(Image& image);
    void destroy(const String& name);
    void destroyAll();

    Image& get(const String& name) const;
    bool isDefined(const String& name) const;

    uint getImageCount() const;

    void loadImageset(const String& filename, const String& resource_group = "");
    void loadImagesetFromString(const String& source);

    void destroyImageCollection(const String& prefix,
                                const bool delete_texture = true);

    void addFromImageFile(const String& name,
                          const String& filename,
                          const String& resource_group = "");

    void notifyDisplaySizeChanged(const Sizef& size);

    static void setImagesetDefaultResourceGroup(const String& resourceGroup)
        { d_imagesetDefaultResourceGroup = resourceGroup; }

    static const String& getImagesetDefaultResourceGroup()
        { return d_imagesetDefaultResourceGroup; }

    // XMLHandler overrides
    const String& getSchemaName() const;
    const String& getDefaultResourceGroup() const;

    typedef std::pair<Image*, ImageFactory*> ImagePair;

    typedef std::map<String, ImagePair,
                     StringFastLessCompare
                     CEGUI_MAP_ALLOC(String, Image*)> ImageMap;

    typedef ConstMapIterator<ImageMap> ImageIterator;

    ImageIterator getIterator() const;

private:
    // implement chained xml handler abstract interface
    void elementStartLocal(const String& element, const XMLAttributes& attributes);
    void elementEndLocal(const String& element);

    typedef std::map<String, ImageFactory*, StringFastLessCompare
        CEGUI_MAP_ALLOC(String, ImageFactory*)> ImageFactoryRegistry;

    void destroy(ImageMap::iterator& iter);

    // XML parsing helper functions.
    void elementImagesetStart(const XMLAttributes& attributes);
    void elementImageStart(const XMLAttributes& attributes);
    void validateImagesetFileVersion(const XMLAttributes& attrs);

    static String d_imagesetDefaultResourceGroup;

    ImageFactoryRegistry d_factories;
    ImageMap d_images;
};

//---------------------------------------------------------------------------//
template <typename T>
void ImageManager::addImageType(const String& name)
{
    if (isImageTypeAvailable(name))
        CEGUI_THROW(AlreadyExistsException(
            "Image type already exists: " + name));

    d_factories[name] = CEGUI_NEW_AO TplImageFactory<T>;

    Logger::getSingleton().logEvent(
        "[CEGUI::ImageManager] Registered Image type: " + name);
}

//---------------------------------------------------------------------------//
} // End of  CEGUI namespace section

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

#endif  // end of guard _CEGUIImageManager_h_