#ifndef IMAGEMANAGER_H
#define IMAGEMANAGER_H

#include "SDL/SDL.h"
#include <string>
#include <vector>

struct imgrecord
{
    std::string name;
    //int r,g,b;
    SDL_Surface* ptr;
    int refs;
};

//////////////////////////////////////////////////////////////

class imageManager
{
    static std::vector<imgrecord> images;

    static SDL_Surface* loadfrombmp( std::string );

    public:
    static SDL_Surface* demand( std::string);
    static void release( std:: string);
};

#endif

#include "imagemanager.h"

std::vector<imgrecord> imageManager::images; //declaring static data members

SDL_Surface *imageManager::loadfrombmp(std::string imgname)
{
    SDL_Surface * loadedimage;
    SDL_Surface * displayimage;

    loadedimage = SDL_LoadBMP( imgname.c_str() );

    if (loadedimage == NULL)
    {
        return NULL;
    }

    displayimage = SDL_DisplayFormat( loadedimage ); //converts the surface to a form
                                                     //that is 'suitable for fast blitting'
    SDL_FreeSurface (loadedimage);

    return displayimage;
}

SDL_Surface *imageManager::demand(std::string imgname)
{
    imgrecord newrecord;

    for (int i=0;i< images.size();i++)
    {
        if (imgname == images.name)
        {
            images.at(i).refs++;
            return images.at(i).ptr;
        }
    }

    newrecord.ptr = loadfrombmp( imgname);
    if (newrecord.ptr != NULL)
    {
        newrecord.refs=1;
        newrecord.name= imgname;
        images.push_back(newrecord);
        return newrecord.ptr;
    }

    return NULL;
}

void imageManager::release(std::string imgname)
{
    imgrecord newrecord;
    int i;

    for (i=0;i<images.size();i++)
    {
        if (imgname == images.at(i).name)
        {
            images.at(i).refs--;
            break;
        }
    }
    if (images.at(i).refs<=0)
    {
        SDL_FreeSurface( images.at(i).ptr );
    }
    images.erase(images.begin() + i);
}

    Image(const std::string &file, const SDL_Color &colourkey);

#ifndef IMAGEMANAGER_H#define IMAGEMANAGER_H#include "SDL/SDL.h"#include "shared_ptr.hpp"#include <string>#include <map>class Image;typedef boost::shared_ptr<Image> img_sptr;class Image{    SDL_Surface *mysurface;    // Only implement these if you really need to.    // Most of the time you don't want to be copying SDL_Surfaces,    // it is expensive    // Better to simple use boost::shared_ptr<Image>    //    // Declare them here, private and don't implement them    // This means that the compiler won't generate its defaults    Image(const Image &other);    Image &operator=(const Image &other);    // You should only need to store the surface pointer here    // Other state information like the per-surface alpha and    // colour key can be obtained from surface->format IIRC.    public:    // you could have another constructor that takes a SDL_RWops    // if you want to make Image instances from memory data.    //    //    Image(const std::string &file);    //not implemented yet        //Image(const std::string &file, const SDL_Color &colorkey);        //Image(const std::string &file, Uint8 alpha);    // This class is not intended to be subclassed.    // This means you can avoid having a virtual destructor    ~Image();    // You can have as many overloads as you like    // For example, to perform clipped blits you could have an overload    // that takes a SDL_Rect parameter.    // These should be marked as const, but I'm not sure if    // SDL is const-correct with surface blitting due to internal    // issues, but try to do so if you can.    void draw(int x, int y, SDL_Surface *screen, SDL_Rect *clip = NULL) const;    // Don't bother providing set/get SDL_Surface, I don't think you need it    // Best not to provide functions like setColorKey or setAlpha at all    // if you can avoid it. See below for details.};//////////////////////////////////////////////////////////////class imageManager{    static std::map<std::string, img_sptr > mymap;    public:    static img_sptr demand( std::string);};#endif

#include "imagemanager.h"#include <iostream>Image::Image(const std::string &file){    SDL_Surface * loadedimage;    SDL_Surface * displayimage;    loadedimage = SDL_LoadBMP( file.c_str() );    if (loadedimage != NULL)    {        mysurface = SDL_DisplayFormat( loadedimage ); //converts the surface to a form                                                      //that is "suitable for fast blitting"        std::cout << file << " loaded sucessfully\n";    }    else    {        mysurface = NULL;    }}Image::~Image(){    std::cout << "An image was deconstructed\n";    SDL_FreeSurface (mysurface);}void Image::draw(int x, int y, SDL_Surface *screen, SDL_Rect *clip) const{    SDL_Rect temp;    temp.x=x;    temp.y=y;    if (screen == NULL)    {        std::cout << "Screen is NULL\n";    }    if (mysurface == NULL)    {        std::cout << "MySurface is NULL\n";    }    std::cout << "Draw begun ...\n";    std::cout << "Mysurface is " << mysurface << "\n";    std::cout << SDL_BlitSurface(mysurface, clip, screen, &temp) << "\n";    std::cout << "Draw finished\n";}std::map<std::string, img_sptr > imageManager::mymap;img_sptr imageManager::demand(std::string imgname){    std::map<std::string, img_sptr >::iterator iter;    img_sptr newpointer;    std::cout << imgname << " demanded.\n";    iter = mymap.find(imgname);    if (iter == mymap.end())    {        std::cout << "Demand not in map\n";        newpointer.reset( new Image( imgname ));        mymap.insert( std::pair<std::string, img_sptr >( imgname, newpointer ) );        return newpointer;    }    else    {        std::cout << "Demand in map\n";        return iter->second;    }}