lst_sEntry *
lst_InsertPred (
  thread_sMutex		*mp,
  lst_sEntry		*succ,		/* Insert before this element */
  lst_sEntry		*link,		/* Link to insert */
  void			*item		/* Item to insert */
)
{
  lst_sEntry		*pred;

  if (mp != NULL) sync_MutexLock(mp);

  pwr_Assert(checkInit(link));

  pred = succ->blink;
  
  pwr_Assert(check(succ));
  pwr_Assert(check(pred));
  pwr_Assert(pred->flink == succ);

  link->flink = succ;
  link->blink = succ->blink;
  succ->blink = pred->flink = link;
  if (item != NULL)
    link->item = item;

  if (mp != NULL) sync_MutexUnlock(mp);

  return pred;  
}

	//may cause a performace drop...
	void Image::draw_rotated(float x, float y, float ax, float ay, float angle, float from_x, float from_y, float w, float h)
	{
		if(checkInit()==false) throw Exception("Fatal error: attempt to use GameEngine library without initialization!");

		//create a cropped surface from the original
		SDL_Surface* cropped = SDL_CreateRGBSurface(0, w, h, 32, 0, 0, 0, 0);
		srcrect.x = from_x; srcrect.y = from_y;
		srcrect.w = w; srcrect.h = h;
		SDL_BlitSurface(implementation->sdlSurface, &srcrect, cropped, null);

		//zoom the cropped fragment
		rotozoom_surface = rotozoomSurface(cropped, angle*toDegree, 1, 0);

		int w1 = implementation->sdlSurface->w,
			h1 = implementation->sdlSurface->h,
			w2 = rotozoom_surface->w,
			h2 = rotozoom_surface->h;

		int ax2 = w2/2 + (ax - w1/2)*cos(angle) - (ay - h1/2)*sin(angle);
		int ay2 = h2/2 + (ay - h1/2)*cos(angle) - (ax - w1/2)*sin(angle);

		dstrect.x = x-ax2;
		dstrect.y = y-ay2;

		//blit the rotated cropped fragment, leaving the original intact
		SDL_BlitSurface(rotozoom_surface, null, GameEngine::display->implementation->sdlDisplaySurface, &dstrect);
		SDL_FreeSurface(cropped);
		SDL_FreeSurface(rotozoom_surface);
	}

lst_sEntry *
lst_InsertSucc (
  thread_sMutex		*mp,
  lst_sEntry		*pred,		/* Insert after this element */
  lst_sEntry		*link,		/* link to insert */
  void			*item		/* Item to insert */
)
{
  lst_sEntry		*succ;

  if (mp != NULL) sync_MutexLock(mp);

  pwr_Assert(checkInit(link));

  succ = pred->flink;
  
  pwr_Assert(check(succ));
  pwr_Assert(check(pred));
  pwr_Assert(succ->blink == pred);

  link->blink = pred;
  link->flink = pred->flink;
  pred->flink = succ->blink = link;
  if (item != NULL)
    link->item = item;

  if (mp != NULL) sync_MutexUnlock(mp);

  return succ;  
}

bool PlaylistHandler::createPlaylist(std::string name) {
    checkInit();
    QDomNode node = root.firstChild();
    while (!node.isNull()) {
        QDomElement element = node.toElement();
        if (!element.isNull()) {
            if (element.tagName() == "Playlist") {
                if (element.attribute("name").toStdString() == name) {
                    return false;
                }
            }
        }
        node = node.nextSibling();
    }
    QDomElement thisPlaylist = doc.createElement("Playlist");
    thisPlaylist.setAttribute("name", QString::fromStdString(name));
    boost::uuids::uuid uuidobj = boost::uuids::random_generator()();
    std::stringstream ss;
    ss << uuidobj;
    QString uuid = QString::fromStdString(ss.str());
    thisPlaylist.setAttribute("id", uuid);
    root.appendChild(thisPlaylist);
    save();
    emit playlistsChanged(getPlaylists());
    return true;
}

	Image::~Image()
	{
		checkInit();
		SDL_FreeSurface(this->implementation->sdlSurface);
		if(this->implementation != null) SDL_FreeSurface(this->implementation->cachedSdlSurface);
		delete implementation;
	}

	Event* EventQueue::waitForEvent()
	{
		if(checkInit()==false) throw Exception("Fatal error: attempt to use GameEngine library without initialization!");
		Event* ev = new Event;
		SDL_WaitEvent(ev->implementation->sdlEvent);
		return ev;
	}

	Image::Image(const string& filename)
	: implementation(new Implementation())
	{
		checkInit();
		this->implementation->sdlSurface = IMG_Load(filename.c_str() );
		if ( this->implementation->sdlSurface == null)
			throw AdapterException(string("Could not load image \"") + filename + "\": " + IMG_GetError());

		// attempt to use 32bit format, which are better suited to rotozoom
		if(this->implementation->sdlSurface->format->BitsPerPixel != 32)
		{
			SDL_PixelFormat format32 = *(this->implementation->sdlSurface->format);
			format32.BitsPerPixel = 32;
			SDL_Surface* surf = SDL_ConvertSurface(this->implementation->sdlSurface, &format32, 0);
			if(surf != null)  // if 32bit surf could not be obtained, move on
			{
				SDL_FreeSurface(this->implementation->sdlSurface);
				this->implementation->sdlSurface = surf;
			}
		}

		this->implementation->cachedSdlSurface = null;

		// todo make a bool flag on SDL 1.2 adapter image to toogle AA when rotozooming.
	}

	Event* EventQueue::waitForEvent()
	{
		checkInit();
		Event* ev = new Event;
		al_wait_for_event(this->implementation->allegroEventQueue, ev->implementation->allegroEvent);
		return ev;
	}

pwr_tBoolean
lst_IsLinked (
  thread_sMutex		*mp,
  lst_sEntry		*link
)
{
  pwr_tBoolean		is_linked;
  lst_sEntry		*pred;
  lst_sEntry		*succ;

  if (mp != NULL) sync_MutexLock(mp);

  pwr_Assert(checkInit(link));

  pred = link->blink;
  succ = link->flink;
  
  pwr_Assert(check(succ));
  pwr_Assert(check(pred));
  pwr_Assert(pred->flink == link);
  pwr_Assert(succ->blink == link);

  is_linked = link->flink != link;

  if (mp != NULL) sync_MutexUnlock(mp);

  return is_linked;
}

	Image::Image(string filename)
	{
		if(checkInit()==false) throw Exception("Fatal error: attempt to use GameEngine library without initialization!");
		this->implementation = new Implementation;
		this->implementation->sdlSurface = IMG_Load(filename.c_str() );
		if ( this->implementation->sdlSurface == null)
			throw Exception("Could not load image \"" + filename + "\": " + IMG_GetError());
	}

	//FIXME
	void EventQueue::listenEvents()
	{
		if(checkInit()==false) throw Exception("Fatal error: attempt to use GameEngine library without initialization!");
//		al_flush_event_queue(this->implementation->allegroEventQueue);
//		al_register_event_source(this->implementation->allegroEventQueue, al_get_display_event_source(GameEngine::display->implementation->allegroDisplay));
//		al_register_event_source(this->implementation->allegroEventQueue, al_get_keyboard_event_source());
//		al_register_event_source(this->implementation->allegroEventQueue, al_get_mouse_event_source());
	}

char serialConfig(unsigned char * buffer, unsigned int length){
	unsigned long int i ;
	unsigned long int timer = 0;
	clearClk();
	setProgramm();
	__delay_cycles(10*CONFIG_CYCLES);	
	clearProgramm();
	__delay_cycles(5*CONFIG_CYCLES);		
	while(checkInit() > 0 && timer < 200) timer ++; // waiting for init pin to go down
	if(timer >= 200){
		 printf("Init pin not going down !");
		 setProgramm();
		 return -1;	
	}
	timer = 0;
	__delay_cycles(5*CONFIG_CYCLES);
	#ifndef MARK1
	setProgramm();
	while(checkInit() == 0 && timer < 0xFFFFFF){
		 timer ++; // waiting for init pin to go up
	}
	if(timer >= 0xFFFFFF){
		 printf("Init pin not going high ! \n");	
		 return -1;
	}
	#endif
	timer = 0;
	printf("Starting configuration ! \n");
	for(i = 0 ; i < length ; i ++){
		serialConfigWriteByte(buffer[i]);	
	}
	while(timer < 50){
		clearClk();
		__delay_cycles(CONFIG_CYCLES);
		setClk();	
		timer ++ ;
	}
	clearClk();
	clearDout();
	if(!checkDone() && timer >= 255){
		 printf("Done pin not going high ! \n");
		 return -1;	
	}
	return 1 ;
}

	void Image::draw(float x, float y)
	{
		if(checkInit()==false) throw Exception("Fatal error: attempt to use GameEngine library without initialization!");

		//draws all source region
		dstrect.x = x; dstrect.y = y;

		SDL_BlitSurface(this->implementation->sdlSurface, null, GameEngine::display->implementation->sdlDisplaySurface, &dstrect);
	}

	void Display::clear()
	{
		if(checkInit()==false) throw Exception("Fatal error: attempt to use GameEngine library without initialization!");
		if ( SDL_FillRect(this->implementation->sdlDisplaySurface, null, 0) == -1 )
		{
			string msg = string("SDL_FillRect error! ") + SDL_GetError();
			cout << msg << endl;
			throw Exception(msg);
		}
	}

	void Display::refresh()
	{
		if(checkInit()==false) throw Exception("Fatal error: attempt to use GameEngine library without initialization!");
		//flip surface if double-buffered, update rect if single-buffered instead
		if( SDL_Flip(this->implementation->sdlDisplaySurface) == -1 )
		{
			string message = string("Failed to swap the buffers/refresh the display: ") + SDL_GetError();
			cout << message << endl;
			throw Exception(message);
		}
	}

	Font::Font(const string& filename, int size, bool antialiasing, bool hinting, bool kerning)
	: implementation(new Implementation)
	{
		checkInit();

		//I know, pretty odd...
		int flags = (antialiasing? 0 : ALLEGRO_TTF_MONOCHROME)	| (hinting? 0 : ALLEGRO_TTF_NO_AUTOHINT) | (kerning? 0 : ALLEGRO_TTF_NO_KERNING);
		this->implementation->allegroFont = al_load_ttf_font(filename.c_str(), size, flags);

		if(this->implementation->allegroFont == null)
			throw AdapterException("Font %s could not be loaded: Error %d", filename.c_str(), al_get_errno());
	}

	Event::MouseButton::value Event::getEventMouseButton()
	{
		if(checkInit()==false) throw Exception("Fatal error: attempt to use GameEngine library without initialization!");
		switch(this->implementation->sdlEvent->button.button)
		{
			case SDL_BUTTON_LEFT:		return Event::MouseButton::LEFT;
			case SDL_BUTTON_MIDDLE:		return Event::MouseButton::MIDDLE;
			case SDL_BUTTON_RIGHT:		return Event::MouseButton::RIGHT;

			default:	return Event::MouseButton::UNKNOWN;
		}
	}

PTYPE TSpaceGrid2D::getY(int j)
{
	
	checkInit();
	
	if(j>=0 && j<=NY)
		return j*hy + y0;
	else
	{
		printf("Error in TSpaceGrid2D::getY: Index out of bounds\n");
		exit(EXIT_FAILURE);
	}	
}