char use1;
sf::Sprite sprite;
sf::CairoImage img;
 
void DrawFunc1(cairo_t *cr, float Width, float Height, void *data)
{
	// Do cairo stuff, just remember that the context is prescaled so
	// all coordinates are between 0.0 and 1.0.
}
void DrawFunc2(cairo_t *cr, float Width, float Height, void *data)
{
}
 
void SetupStuff(void)
{
	use1 = 0;
	img.Create(100,100, DrawFunc1);
	sprite.SetImage(img);
}
 
void RenderStuff(const RenderTarget &target)
{
	target.Draw(sprite);
	// The following is just a silly thing that redraws the image on
	// certain conditions using another function.
	if (use1 == 1)
		img.Redraw(DrawFunc1); // Redraw takes an optional second argument that will be passed along to the draw function.
	else if (use1 == 2)
		img.Redraw(DrawFunc2);
	use1 = 0;
	// To resize the image you have to do img.Create(width, height)
}

#ifndef _CAIROSHAPE_H_
#define _CAIROSHAPE_H_
 
#include <SFML/System/Resource.hpp>
#include <SFML/Graphics/Sprite.hpp>
#include <SFML/Graphics/Image.hpp>
#include <cairo/cairo.h>
 
namespace sf
{
	typedef void (draw_func)(cairo_t *cr, float Width, float Height, void *data);
 
	class Image;
 
	void DefaultDrawFunc(cairo_t *cr, float Width, float Height, void *data);
 
	class CairoImage : public Image
	{
	public:
		CairoImage();
		CairoImage(const CairoImage &Copy);
		CairoImage(unsigned int Width, unsigned int Height, draw_func *func = 0);
 
		~CairoImage();
 
		bool LoadFromFile(const std::string &Filename);
		bool SaveToFile(const std::string& Filename) const;
		bool Create(unsigned int Width, unsigned int Height, draw_func *func = 0);
		void Redraw(draw_func *func = 0, void *func_data = 0);
		bool RenderCairoContent(void *func_data = 0);
	protected:
		draw_func *fDraw;
	private:
	};
}
 
#endif /* _CAIROSHAPE_H_ */

#include "cairoshape.hh"
#include <SFML/Graphics/RenderTarget.hpp>
#include <GL/glew.h>
 
#include <iostream>
#include <iomanip>
using namespace std;
 
#ifndef max
  #define max(a, b) (a > b ? a : b)
#endif
 
namespace sf
{
	void DefaultDrawFunc(cairo_t *cr, float Width, float Height)
	{
		// First row
		cairo_rectangle(cr, 0.00, 0.00, 0.33, 0.33);
		cairo_set_source_rgba(cr, 1.0, 0.0, 0.0, 1.0);
		cairo_fill(cr);
 
		cairo_rectangle(cr, 0.33, 0.00, 0.66, 0.33);
		cairo_set_source_rgba(cr, 0.0, 1.0, 0.0, 1.0);
		cairo_fill(cr);
 
		cairo_rectangle(cr, 0.66, 0.00, 1.00, 0.33);
		cairo_set_source_rgba(cr, 0.0, 0.0, 1.0, 1.0);
		cairo_fill(cr);
 
		// Second row
		cairo_rectangle(cr, 0.00, 0.33, 0.33, 0.66);
		cairo_set_source_rgba(cr, 1.0, 0.0, 0.0, 1.0);
		cairo_fill(cr);
 
		cairo_rectangle(cr, 0.33, 0.33, 0.66, 0.66);
		cairo_set_source_rgba(cr, 0.0, 1.0, 0.0, 1.0);
		cairo_fill(cr);
 
		cairo_rectangle(cr, 0.66, 0.33, 1.00, 0.66);
		cairo_set_source_rgba(cr, 0.0, 0.0, 1.0, 1.0);
		cairo_fill(cr);
 
		// Third row
		cairo_rectangle(cr, 0.00, 0.66, 0.33, 1.00);
		cairo_set_source_rgba(cr, 1.0, 0.0, 0.0, 1.0);
		cairo_fill(cr);
 
		cairo_rectangle(cr, 0.33, 0.66, 0.66, 1.00);
		cairo_set_source_rgba(cr, 0.0, 1.0, 0.0, 1.0);
		cairo_fill(cr);
 
		cairo_rectangle(cr, 0.66, 0.66, 1.00, 1.00);
		cairo_set_source_rgba(cr, 0.0, 0.0, 1.0, 1.0);
		cairo_fill(cr);
 
		// Random rectangle
		cairo_rectangle(cr, 0.1, 0.1, 0.8, 0.8);
		cairo_set_source_rgba(cr, (rand()%255)/255.0,(rand()%255)/255.0,(rand()%255)/255.0,0.75);
		cairo_set_line_width(cr, 0.05);
		cairo_stroke(cr);
	}
 
	CairoImage::CairoImage()
		: Image()
	{
	}
 
	CairoImage::CairoImage(const CairoImage &Copy)
		: Image()
	{
	}
 
	CairoImage::CairoImage(unsigned int Width, unsigned int Height, draw_func func)
		: Image(Width, Height, Color(255,255,255,255)), fDraw(func)
	{
		Create(Width, Height, func);
	}
 
	CairoImage::~CairoImage()
	{
	}
 
	bool CairoImage::LoadFromFile(const std::string &Filename)
	{
		return Image::LoadFromFile(Filename);
	}
 
	bool CairoImage::SaveToFile(const std::string& Filename) const
	{
		return Image::SaveToFile(Filename);
	}
 
	bool CairoImage::Create(unsigned int Width, unsigned int Height, draw_func *func)
	{
		Image::Create(Width, Height, Color(0,0,0,255));
		if (func) fDraw = func;
		RenderCairoContent();
		return true;
	}
 
		void CairoImage::Redraw(draw_func *func, void *func_data)
	{
		if (func) fDraw = func;
		RenderCairoContent(func_data);
	}
 
	bool CairoImage::RenderCairoContent(void *func_data)
	{
		cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, GetWidth(), GetHeight());
		if (cairo_surface_status(surface) == CAIRO_STATUS_SUCCESS)
		{
			cairo_t *cr = cairo_create(surface);
			if (cairo_status(cr) == CAIRO_STATUS_SUCCESS)
			{
				cairo_scale(cr, GetWidth(), GetHeight());
				if (fDraw)
				{
					fDraw(cr, GetWidth(), GetHeight(), func_data);
				}
				cairo_destroy(cr);
				Uint8 *data = cairo_image_surface_get_data(surface);
				if (data)
				{
					unsigned int size = GetWidth()*GetHeight()*4;
					for (unsigned int i = 0 ; i < size ; i += 4)
					{
						Uint8 tmp = data[i];
						data[i] = data[i+2];
						data[i+2] = tmp;
					}
					LoadFromPixels(GetWidth(), GetHeight(), data);
				}
			}
			else
			{
				cairo_surface_destroy(surface);
				return false;
			}
			cairo_surface_destroy(surface);
		}
		else return false;
		return true;
	}
}