path: root/links/patches/100-add-sdl-driver.patch

--- a/configure.in	2010-09-25 18:50:12.247566685 +0200
+++ b/configure.in	2010-09-25 18:49:59.867570133 +0200
@@ -430,7 +430,7 @@
 AC_ARG_WITH(x, [  --without-x             compile without X Window System graphics driver],[if test "$withval" = no; then disable_x=yes; else disable_x=no; fi])
 AC_ARG_WITH(fb, [  --without-fb            compile without Linux Framebuffer graphics driver],[if test "$withval" = no; then disable_fb=yes; else disable_fb=no; fi])
 AC_ARG_WITH(directfb, [  --without-directfb      compile without DirectFB graphics driver],[if test "$withval" = no; then disable_directfb=yes; else disable_directfb=no; fi])
-dnl AC_ARG_WITH(sdl, [  --without-sdl           compile without SDL graphics driver],[if test "$withval" = no; then disable_sdl=yes; else disable_sdl=no; fi])
+AC_ARG_WITH(sdl, [  --without-sdl           compile without SDL graphics driver],[if test "$withval" = no; then disable_sdl=yes; else disable_sdl=no; fi])
 AC_ARG_WITH(pmshell, [  --without-pmshell       compile without PMShell graphics driver],[if test "$withval" = no; then disable_pmshell=yes; else disable_pmshell=no; fi])
 AC_ARG_WITH(atheos, [  --without-atheos        compile without Atheos graphics driver],[if test "$withval" = no; then disable_atheos=yes; else disable_atheos; fi])
 
@@ -501,25 +501,25 @@
 	fi
 fi
 
-dnl if test "$disable_sdl" != yes ; then
-dnl 	AC_PATH_PROG(SDL_CONFIG, sdl-config, no)
-dnl 	if test "$SDL_CONFIG" != "no"; then
-dnl 	        AC_MSG_CHECKING(for SDL >= 1.2.0)
-dnl         	sdl_version="`$SDL_CONFIG --version`"
-dnl 		if expr "$sdl_version" \>= 1.2.0 >/dev/null; then
-dnl 			AC_MSG_RESULT(yes)
-dnl 			SDL_CFLAGS="`$SDL_CONFIG --cflags`"
-dnl 			SDL_LIBS="`$SDL_CONFIG --libs`"
-dnl 	           	AC_DEFINE(GRDRV_SDL)
-dnl         	   	drivers="$drivers SDL"
-dnl 			CPPFLAGS="$CPPFLAGS $SDL_CFLAGS"
-dnl 			AC_CHECK_LIB(Xext, XextAddDisplay)
-dnl 			LIBS="$SDL_LIBS $LIBS"
-dnl 		else
-dnl 			AC_MSG_RESULT(no)
-dnl 		fi
-dnl 	fi
-dnl fi
+if test "$disable_sdl" != yes ; then
+	AC_PATH_PROG(SDL_CONFIG, sdl-config, no)
+	if test "$SDL_CONFIG" != "no"; then
+	        AC_MSG_CHECKING(for SDL >= 1.2.0)
+        	sdl_version="`$SDL_CONFIG --version`"
+		if expr "$sdl_version" \>= 1.2.0 >/dev/null; then
+			AC_MSG_RESULT(yes)
+			SDL_CFLAGS="`$SDL_CONFIG --cflags`"
+			SDL_LIBS="`$SDL_CONFIG --libs`"
+	           	AC_DEFINE(GRDRV_SDL)
+        	   	drivers="$drivers SDL"
+			CPPFLAGS="$CPPFLAGS $SDL_CFLAGS"
+			AC_CHECK_LIB(Xext, XextAddDisplay)
+			LIBS="$SDL_LIBS $LIBS"
+		else
+			AC_MSG_RESULT(no)
+		fi
+	fi
+fi
 
 if test "$disable_pmshell" != yes ; then
 	AC_CACHE_CHECK([for pmshell], ac_cv_have_pmshell,
--- a/Makefile.am	2010-09-25 18:42:40.087568555 +0200
+++ b/Makefile.am	2010-09-25 18:42:51.917570410 +0200
@@ -13,7 +13,7 @@
 else
 endif
 
-links_SOURCES=af_unix.c auth.c beos.c bfu.c block.c bookmarks.c cache.c charsets.c connect.c cookies.c default.c dip.c directfb.c directfb_cursors.h dither.c dns.c drivers.c error.c file.c finger.c font_include.c framebuffer.c ftp.c gif.c html.c html_gr.c html_r.c html_tbl.c http.c https.c img.c imgcache.c jpeg.c jsint.c kbd.c language.c links_icon.c listedit.c lru.c mailto.c main.c menu.c memory.c objreq.c os_dep.c pmshell.c png.c sched.c select.c session.c smb.c svgalib.c terminal.c tiff.c types.c url.c view.c view_gr.c x.c xbm.c links.h cfg.h os_dep.h os_depx.h setup.h codepage.h language.h codepage.inc entity.inc uni_7b.inc language.inc upcase.inc arrow.inc bits.h
+links_SOURCES=af_unix.c auth.c beos.c bfu.c block.c bookmarks.c cache.c charsets.c connect.c cookies.c default.c dip.c directfb.c directfb_cursors.h dither.c dns.c drivers.c error.c file.c finger.c font_include.c framebuffer.c ftp.c gif.c html.c html_gr.c html_r.c html_tbl.c http.c https.c img.c imgcache.c jpeg.c jsint.c kbd.c language.c links_icon.c listedit.c lru.c mailto.c main.c menu.c memory.c objreq.c os_dep.c pmshell.c png.c sched.c select.c session.c smb.c svgalib.c terminal.c tiff.c types.c url.c view.c view_gr.c x.c xbm.c links.h cfg.h os_dep.h os_depx.h setup.h codepage.h language.h codepage.inc entity.inc uni_7b.inc language.inc upcase.inc arrow.inc bits.h sdl.c sdl_data.inc
 
 dist-hook:
 #remove the symlinka:
--- a/sdl.c	1970-01-01 01:00:00.000000000 +0100
+++ b/sdl.c	2010-09-25 18:38:37.887567087 +0200
@@ -0,0 +1,1161 @@
+/*sdl.c
+	-- SDL graphic driver for Links (version 0.2.0)
+
+    Copyright (C) 2004	Samuel Behan <sam(at)frida(dot)fri(dot)utc(dot)sk>
+
+    This driver is free software; you can redistribute it and/or
+    modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; either version 2
+    of the License, or (at your option) any later version.
+
+    This driver is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    ---
+    I've wrote this driver just as a proof of concept for using SDL library. I wanted
+    to use something easy, so i've decided for the world's best web browser :)
+
+    TODO:
+	- keyboard input system doesn't handles all characters, because sdl ignores any
+		system mappings and provides something like `raw keyboard access'
+	- *_strip functions are possibly bad implemented, actualy i don't understand what
+		they should do, or better i'm too lazy to find it out :)
+	- BUGBUG: aa-lib nor caca lib, dont display nicely - they actualy display nothing ;(
+			This needs to be fixed, becase links over aa-lib as that what i've been
+			dreaming of [ try set env SDL_VIDEODRIVER="aalib" ]
+	...and many more, not found yet :)
+*/
+
+
+#include "cfg.h"
+
+#ifdef GRDRV_SDL
+
+#ifdef TEXT
+#undef TEXT
+#endif
+
+#include "links.h"
+#include <signal.h>
+/* #include "arrow.inc" */
+
+/*sdl inclusions*/
+#include <SDL.h>
+/*#include <SDL_gfxPrimitives.h>*/
+
+
+/* ------ some config options -------- */
+/*#define sdl_HAVE_DOUBLEBUF */
+
+
+/* ---------- helper tools ----------- */
+/* FIXME: enabled debug mode */
+#undef DEBUG
+#ifdef DEBUG
+#include <assert.h>
+#define S_ASSERT(code)	assert((code))
+#define S_ON_DEBUG(code)	code
+#define S_ON_DEBUG_TRACE(str)	fprintf(stderr, "[%s:%s:%d] %s\n", __FILE__, __PRETTY_FUNCTION__, __LINE__, str);
+#else
+#define S_ASSERT(code)
+#define S_ON_DEBUG(code)
+#define S_ON_DEBUG_TRACE(str)
+#endif
+
+/* internal types */
+typedef unsigned char 		u_char_t;
+typedef unsigned short int	u_short_t;
+struct graphics_driver sdl_driver;
+
+/* keysyms */
+#include "sdl_data.inc"
+
+static struct t_sdl_driver_data {
+	u_char_t	*video_drv;		/* used video driver name */
+	SDL_VideoInfo	*video_info;		/* video informations */
+	SDL_Cursor	*cursor;		/* cursor */
+	int		event_timer;		/* event timer id */
+	int		input_encoding;		/* input encoding codepage */
+	struct {
+		long  int	flags;		/* video flags */
+		short int	width;
+		short int	height;
+		short int	depth;
+		short int 	bpp;		/* bytes per pixel */
+	} video;
+} sdl_data = {
+	NULL,
+	NULL,
+	NULL,
+	-1,
+	0,
+	{ 0, 0, 0, 0, 0 },
+};
+#define sdl_VIDEO_WIDTH		sdl_DATA.video.width
+#define sdl_VIDEO_HEIGHT	sdl_DATA.video.height
+#define sdl_VIDEO_DEPTH		sdl_DATA.video.depth
+#define sdl_VIDEO_BPP		sdl_DATA.video.bpp
+#define sdl_VIDEO_FLAGS		sdl_DATA.video.flags
+
+/* DRIVER DATA HELPERS */ 
+#define sdl_DATA		sdl_data
+#define sdl_DATA_pfmt		(sdl_DATA.video_info->vfmt)				/* pixel format */
+#define sdl_DATA_FREE()		if(sdl_DATA.video_drv != NULL)	mem_free(sdl_DATA.video_drv);	\
+				if(sdl_DATA.video_info != NULL)	mem_free(sdl_DATA.video_info);
+
+struct t_sdl_device_data {
+	SDL_Surface 		*p_surf;		/* primary surface	*/
+	struct graphics_device	*g_dev;			/* draphic device	*/
+	short			u_pending;		/* update pending	*/
+	SDL_Rect		u_rect;			/* update rectangle	*/
+};
+#define sdl_SURFACE(ptr)	(ptr)->p_surf
+#define sdl_GD(ptr)		(ptr)->g_dev
+#define sdl_URECT(ptr)		(ptr)->u_rect
+#define sdl_UPENDING(ptr)	(ptr)->u_pending
+
+/* HELPER FUNCTIONS */
+#define sdl_COLOR(col)			(((col) << 2) | 0x00)
+
+#define sdl_SETUP_TIMER(dev)		\
+		if (sdl_DATA.event_timer == -1) sdl_DATA.event_timer	= install_timer(20, sdl_catch_event, (dev))
+#define sdl_KILL_TIMER()		\
+		if (sdl_DATA.event_timer != -1) kill_timer(sdl_DATA.event_timer), sdl_DATA.event_timer = -1
+
+/* event catch helpers */
+#define sdl_CATCH_EVENTS_NUM	30
+#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN)
+#define sdl_MOUSE_STATE(var_in, var_out, def)	\
+		if(var_in == SDL_BUTTON(SDL_BUTTON_LEFT))		\
+			var_out	|= B_LEFT;				\
+		else if(var_in == SDL_BUTTON(SDL_BUTTON_RIGHT))		\
+			var_out	|= B_RIGHT;				\
+		else if(var_in == SDL_BUTTON(SDL_BUTTON_MIDDLE))	\
+			var_out	|= B_MIDDLE;				\
+		else if(var_in == SDL_BUTTON(SDL_BUTTON_WHEELUP))	\
+			var_out	|= B_WHEELUP;				\
+		else if(var_in == SDL_BUTTON(SDL_BUTTON_WHEELDOWN))	\
+			var_out	|= B_WHEELDOWN;				\
+		else	var_out	= (def);
+#else
+#define sdl_MOUSE_STATE(var_in, var_out, def)	\
+		if(var_in == SDL_BUTTON(SDL_BUTTON_LEFT))		\
+			var_out	|= B_LEFT;				\
+		else if(var_in == SDL_BUTTON(SDL_BUTTON_RIGHT))		\
+			var_out	|= B_RIGHT;				\
+		else if(var_in == SDL_BUTTON(SDL_BUTTON_MIDDLE))	\
+			var_out	|= B_MIDDLE;				\
+		else	var_out	= (def);
+#endif
+
+
+/* tha event handler */
+static void sdl_catch_event(void *data)
+{
+    register int i	= 0;
+    register int ev_num	= 0;
+    register u_short_t	fl	= 0;
+    register struct t_sdl_device_data *dev	= NULL;
+    SDL_Event events[sdl_CATCH_EVENTS_NUM];
+
+    /* speedup (BUGGY, not thread safe !?!) */
+    static u_short_t o_x = 0, o_y = 0, o_fl = 0;
+
+    sdl_DATA.event_timer = -1;
+
+    SDL_PumpEvents();
+    ev_num	= SDL_PeepEvents(events, sdl_CATCH_EVENTS_NUM, SDL_GETEVENT, SDL_ALLEVENTS);
+
+    S_ASSERT(ev_num != -1);
+    /* get dev data */
+    dev		= (struct t_sdl_device_data *) data;
+    for(i = 0; i < ev_num; i++)
+    {
+#define event events[i]
+	switch (event.type)
+	{
+/*	    case SDL_ACTIVEEVENT:	*/
+	    /* mouse motion */
+            case SDL_MOUSEMOTION:
+		/* mose btn state */
+	        /* S_ON_DEBUG_TRACE("event: mouse motion"); */
+		fl	= B_DRAG;
+		sdl_MOUSE_STATE(event.motion.state, fl, B_MOVE);
+		/* save som calls (SDL generates many similar events)	*/
+		if(event.motion.x == o_x && event.motion.y == o_y && fl == o_fl)
+			break;
+		/* call handler */
+		sdl_GD(dev)->mouse_handler(sdl_GD(dev), event.motion.x, event.motion.y, fl);
+		o_x	= event.motion.x;
+		o_y	= event.motion.y;
+		o_fl	= fl;
+                break;
+	    /* mouse click */
+	    case SDL_MOUSEBUTTONUP:
+            case SDL_MOUSEBUTTONDOWN:
+#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN)
+		if(event.button.button == SDL_BUTTON_WHEELUP)
+			fl	= B_WHEELUP | B_MOVE;
+		else if(event.button.button == SDL_BUTTON_WHEELDOWN)
+			fl	= B_WHEELDOWN | B_MOVE;
+		else
+#endif
+		{
+			if(event.type == SDL_MOUSEBUTTONDOWN)
+				fl	= B_DOWN;
+			else
+				fl	= B_UP;	
+		}
+
+	        /* S_ON_DEBUG_TRACE("event: mouse click"); */
+		/* sdl_MOUSE_STATE(event.button.state, fl, fl);	*/
+		sdl_GD(dev)->mouse_handler(sdl_GD(dev), event.button.x, event.button.y, fl);
+		break;
+
+	    /* keyboard */
+	    case SDL_KEYUP:
+	        /* S_ON_DEBUG_TRACE("event: key up"); */
+		break;
+            case SDL_KEYDOWN:
+	       {	/*translate */
+			int		k	= 0;
+			int		key	= 0;
+/*
+*			//////////////////////////
+*			//FIXME: needs rework !!!
+*			//	-- sdl works at low-level ignoring any system keymappings
+*			//	i've no idea how to do it (easily):(
+*			//////////////////////////
+*/
+			/* S_ON_DEBUG_TRACE("event: key down"); */
+			while(sdl_keysyms[k].sym != event.key.keysym.sym && sdl_keysyms[k].sym != SDLK_LAST)
+				k++;
+			S_ASSERT(sdl_keysyms[k].sym != SDLK_LAST);
+			/* FIXME: hope nobody changes enumeration values in SDL libs */
+			if(sdl_keysyms[k].sym >= SDLK_NUMLOCK && sdl_keysyms[k].sym <= SDLK_COMPOSE) 
+				break;	/* aka ignore modifiers */
+			/* find modifiers */
+			fl	= 0;
+			if(event.key.keysym.mod & KMOD_SHIFT)
+				fl	|=	KBD_SHIFT;
+			if(event.key.keysym.mod & KMOD_ALT)
+				fl	|=	KBD_ALT;
+			if(event.key.keysym.mod & KMOD_CTRL)
+				fl	|=	KBD_CTRL;
+			/* key re-map */
+			key	= sdl_keysyms[k].key;
+			/* upper letters fix (not handled directly by SDL) */
+			if(key >= 97 && key <= 122 && fl & KBD_SHIFT)
+			{	key	-= 32;
+				fl	&= ~KBD_SHIFT;	}
+			/* find modifiers */
+			fl	= 0;
+			if(event.key.keysym.mod & KMOD_SHIFT)
+				fl	|=	KBD_SHIFT;
+			if(event.key.keysym.mod & KMOD_ALT)
+				fl	|=	KBD_ALT;
+			if(event.key.keysym.mod & KMOD_CTRL)
+				fl	|=	KBD_CTRL;
+			/* send keyb */
+			/* S_ON_DEBUG(fprintf(stderr, "KEY(%d) = %c&%d\n", k, key, fl);); */
+			if(fl & KBD_CTRL && sdl_keysyms[k].sym == SDLK_c)
+				sdl_GD(dev)->keyboard_handler(sdl_GD(dev), KBD_CTRL_C, 0);
+			else
+				sdl_GD(dev)->keyboard_handler(sdl_GD(dev), key, fl);
+                }break;
+	    case SDL_VIDEORESIZE:
+		/* new dims */
+		sdl_GD(dev)->size.x2	= event.resize.w;
+		sdl_GD(dev)->size.y2	= event.resize.h;
+		sdl_driver.x		= event.resize.w;
+		sdl_driver.y		= event.resize.h;
+		/* resize */
+		/* 
+		S_ON_DEBUG(fprintf(stderr, "RESIZE(%dx%d)\n", event.resize.w, event.resize.h));
+		*/
+		/* info resize */
+		sdl_GD(dev)->resize_handler(sdl_GD(dev));
+		break;
+/*
+	    case SDL_VIDEOEXPOSE:
+*/
+            case SDL_QUIT:
+                sdl_GD(dev)->keyboard_handler(sdl_GD(dev), KBD_CLOSE, 0);
+                break;
+	    default:
+		/* printf("Unhandled event: %d !\n", event.type); */
+		break;
+	}
+   }
+#undef event
+   sdl_SETUP_TIMER((void *)dev);
+   return;
+}
+
+static void sdl_update_sc(void *data)
+{
+	register struct t_sdl_device_data	*dev;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+	/* assign struct */
+	if(data == NULL)
+		return;
+	dev	= (struct t_sdl_device_data *)data;
+	/* check if update neccesary */
+#ifdef __NOT_DEF
+	if(dev == NULL || sdl_SURFACE(dev) == NULL)
+		return;
+	if(sdl_UPENDING(dev) == 0)
+		return;
+#endif
+
+#ifndef sdl_HAVE_DOUBLEBUF
+	/*update screen*/
+	S_ON_DEBUG(fprintf(stderr, "rel-update(%dx%dX%dx%d)\n", sdl_URECT(dev).x, sdl_URECT(dev).y, sdl_URECT(dev).w, sdl_URECT(dev).h));
+	/* bound check  */
+	if(sdl_URECT(dev).x + sdl_URECT(dev).w > sdl_VIDEO_WIDTH)
+		sdl_URECT(dev).w	= sdl_VIDEO_WIDTH - sdl_URECT(dev).x;
+	if(sdl_URECT(dev).y + sdl_URECT(dev).h > sdl_VIDEO_HEIGHT)
+		sdl_URECT(dev).h	= sdl_VIDEO_HEIGHT - sdl_URECT(dev).y;
+	/* perform screen update */
+	SDL_UpdateRect(sdl_SURFACE(dev), sdl_URECT(dev).x, sdl_URECT(dev).y, sdl_URECT(dev).w, sdl_URECT(dev).h);
+#else
+	SDL_Flip(sdl_SURFACE(dev));
+#endif
+	/* remove pending flag */
+	sdl_UPENDING(dev)	= 0;
+	/* S_ON_DEBUG_TRACE("out"); */
+	return;
+}
+
+
+/* quite stuppit function */
+#define sdl_NORM_UPDATE	0
+#define sdl_FULL_UPDATE 1
+static inline void sdl_register_update(struct t_sdl_device_data *dev, 
+		const int x, const int y, const int w, const int h, const int opt)
+{
+#ifdef __NOT_DEF
+	if (x < 0 || y < 0 || w < 1 || h < 1)
+		return;
+#endif
+#ifndef sdl_HAVE_DOUBLEBUF
+
+	if (sdl_UPENDING(dev))
+	{	
+/*		S_ON_DEBUG(fprintf(stderr, "<<rect-in1(%dx%dX%dx%d)\t[%dx%dX%dx%d]\n", sdl_URECT(dev).x,sdl_URECT(dev).y, sdl_URECT(dev).x + sdl_URECT(dev).w, sdl_URECT(dev).y + sdl_URECT(dev).h,
+							sdl_URECT(dev).x,sdl_URECT(dev).y, sdl_URECT(dev).x, sdl_URECT(dev).y));
+		S_ON_DEBUG(fprintf(stderr, "<<rect-in2(%dx%dX%dx%d)\t[%dx%dX%dx%d]\n", x, y, x + w, y + h, 
+							x, y, w, h));
+*/
+		/* compute correct update rectangle */
+		if(sdl_URECT(dev).w < w)
+				sdl_URECT(dev).w	= w;
+		if(sdl_URECT(dev).h < h)
+				sdl_URECT(dev).h	= h;
+		if(sdl_URECT(dev).x > x)
+		{		sdl_URECT(dev).w	+= sdl_URECT(dev).x - x;
+				sdl_URECT(dev).x	= x;	}
+		if(sdl_URECT(dev).y > y)
+		{		sdl_URECT(dev).h	+= sdl_URECT(dev).y - y;
+				sdl_URECT(dev).y	= y;	}
+		if(x + w > sdl_URECT(dev).w)
+				sdl_URECT(dev).w	= x + w - 1;
+		if(y + h > sdl_URECT(dev).h)
+				sdl_URECT(dev).h	= y + h - 1;
+/*		S_ON_DEBUG(fprintf(stderr, ">>rect-out(%dx%dX%dx%d)\t[%dx%dX%dx%d]\n", sdl_URECT(dev).x,sdl_URECT(dev).y, sdl_URECT(dev).x + sdl_URECT(dev).w, sdl_URECT(dev).y + sdl_URECT(dev).h,
+							sdl_URECT(dev).x,sdl_URECT(dev).y, sdl_URECT(dev).x, sdl_URECT(dev).y));
+*/
+		return;
+	}
+	/* create update rectangle */
+	sdl_URECT(dev).x	= x;
+	sdl_URECT(dev).y	= y;
+	sdl_URECT(dev).w	= w;
+	sdl_URECT(dev).h	= h;
+#else
+	if(sdl_UPENDING(dev))
+		return;
+#endif
+	sdl_UPENDING(dev)	= 1;
+	/* register update */
+	register_bottom_half(sdl_update_sc, dev);
+	return;
+}
+
+/* partialy stolen from documentation :)
+   XXX: we can quite easily add here alpha blending :))) */
+static inline void sdl_putpixel(const SDL_Surface *s, const int x, const int y, const unsigned long pixel)
+{
+     register Uint8 *p;
+
+     /* check our clip rect */
+     if(!((s->clip_rect.x < x && (s->clip_rect.x + s->clip_rect.w) > x) 
+			&& (s->clip_rect.y < y && (s->clip_rect.y + s->clip_rect.h) > y)))
+	return;
+     /* our sanity (fight int overflow :) */
+/*
+     pixel &= (1<<(s->format->BytesPerPixel)) - 1; 
+*/
+     /* our point */
+     p = (Uint8 *)s->pixels + y * s->pitch + x * s->format->BytesPerPixel;
+     switch(s->format->BytesPerPixel) {
+     case 1:
+         *p = pixel;
+         break;
+     case 2:
+         *(Uint16 *)p = pixel;
+         break;
+
+     case 3:
+         if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
+             p[0] = (pixel >> 16) & 0xff;
+             p[1] = (pixel >> 8) & 0xff;
+             p[2] = pixel & 0xff;
+         } else {
+             p[0] = pixel & 0xff;
+             p[1] = (pixel >> 8) & 0xff;
+             p[2] = (pixel >> 16) & 0xff;
+         }
+         break;
+     case 4:
+         *(Uint32 *)p = pixel;
+         break;
+     }
+     return;
+}
+
+
+/* DRIVER FUNCTIONS */
+
+	/* findout avibles video mode */
+static u_char_t *sdl_list_videomodes(void)
+{
+	SDL_Rect **modes;
+
+	modes	=	SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE);
+	/* check if any mode avaible */
+	if(modes == (SDL_Rect **) 0)
+		return stracpy("No modes available!\n");
+	/* any dimenstion possible */
+	else if(modes == (SDL_Rect **) -1)
+		return stracpy("All resolutions available.\n");
+	else	/* list possible modes */
+	{
+		int i;
+	 	printf("Available Modes: \n");
+		for(i = 0; modes[i] != NULL; ++i)
+		printf("\t%dx%d\n", modes[i]->w, modes[i]->h);
+	}
+	return NULL;
+}
+
+#define sdl_DRV_MAXLEN		15
+#define sdl_RES_MAXLEN		5
+#define sdl_DEPTH_MAXLEN	2
+/* init driver */
+static u_char_t *sdl_init_driver(u_char_t *param, u_char_t *display)
+{
+	unsigned long	video_bw_suggest	= 0;
+
+	S_ON_DEBUG_TRACE("in");
+
+	/* determine required video mode (we are going to parse input string -- BE AWARE !!!)
+		LITTLE BIT PARANOID IMPLEMENTATION :) */
+	if(param != NULL)
+	{
+		int	p_pos	= 0;
+		u_char_t *m	= NULL;
+		u_char_t *m2	= NULL;
+		u_char_t *p	= NULL;
+		unsigned long	res_x	= 0;
+		unsigned long	res_y	= 0;
+		unsigned long	res_bw	= 0;
+		u_char_t drv[sdl_DRV_MAXLEN] = "";
+
+		m	= stracpy(param);
+		m2	= m;
+
+		/* S_ON_DEBUG(fprintf(stderr, "parse> input	= %s\n", m)); */
+
+		/* look for driver name to use */
+		p	= strchr(m2, ':');
+		if(p != NULL)
+		{	/* calc length */
+			p_pos	= (int) p - (int) m2;
+			if(p_pos > sdl_DRV_MAXLEN)
+				goto bugbug;
+			strncpy(drv, m2, p_pos);
+			drv[p_pos] = '\0';
+			/* move fwd */
+			m2	= (u_char_t *) (m2 + p_pos + 1);
+		}
+
+		/* find 'x' character (FOR X_RES)*/
+		p	= strchr(m2, 'x');
+		/* calculate length*/
+		if(p != NULL)
+			p_pos	= (int) p - (int) m2;
+		else
+			p_pos	= strlen(m2);
+		/*check max length*/
+		if(p_pos > sdl_RES_MAXLEN)
+			goto bugbug;
+
+		/* S_ON_DEBUG(fprintf(stderr,"parse> input(x)	= %s\n", m2)); */
+		res_x	= atoi(m2);
+		/* S_ON_DEBUG(fprintf(stderr,"parse> res_x	= %d\n", res_x)); */
+		/* move fwd */
+		
+		if(m2[p_pos] == 'x')
+			m2	= (u_char_t *) (m2 + p_pos + 1);
+		else
+			goto bugbug;
+
+		/* find 'x' character (FOR Y_RES)*/
+		p	= strchr(m2, 'x');
+		/* calculate length*/
+		if(p != NULL)
+			p_pos	= (int) p - (int) m2;
+		else
+			p_pos	= strlen(m2);
+		/*check max length*/
+		if(p_pos > sdl_RES_MAXLEN)
+				goto bugbug;
+
+		/* S_ON_DEBUG(fprintf(stderr,"parse> input(y)	= %s\n", m2)); */
+		res_y	= atoi(m2);
+		/* S_ON_DEBUG(fprintf(stderr,"parse> res_y	= %d\n", res_y)); */
+		/* move fwd */
+		if(m2[p_pos] == 'x')
+		{	/* findout bits-per-pixel*/
+			m2	= (u_char_t *) (m2 + p_pos + 1);
+
+			/* S_ON_DEBUG(fprintf(stderr,"parse> input(bw)	= %s\n", m2)); */
+
+			/* check length */
+			if(strlen(m) - (int) (m2 - m) == 0)
+				goto no_bugbug;
+			if(strlen(m) - (int) (m2 - m) > sdl_DEPTH_MAXLEN)
+				goto bugbug;
+
+			res_bw	= atoi(m2);
+		}
+
+		/* S_ON_DEBUG(fprintf(stderr,"parse> depth	= %d\n", res_bw)); */
+		goto no_bugbug;
+
+	bugbug:
+		mem_free(m);
+		return stracpy("ERROR: bad mode given for `-mode' param (use: [<sdl_driver>:]<width>x<height>[x<bpp>])\n");
+	no_bugbug:
+		mem_free(m);
+		/*
+		if(drv[0] != '\0')
+			fprintf(stderr, "VIDEO(%s):\t %ldx%ldx%ldbpp [requested]\n", drv, res_x, res_y, res_bw);
+		else	fprintf(stderr, "VIDEO(auto):\t %ldx%ldx%ldbpp [requested]\n", res_x, res_y, res_bw);
+		*/
+
+		/* set them */
+		sdl_VIDEO_WIDTH		= res_x;
+		sdl_VIDEO_HEIGHT	= res_y;
+		sdl_VIDEO_DEPTH		= res_bw;	/* 0 - means current depth */
+		if(drv[0] != '\0')			/* set driver name to env */
+		{	u_char_t	en[20 + sdl_DRV_MAXLEN];
+
+			sprintf(en, "%s=%s", "SDL_VIDEODRIVER", drv);
+			putenv(en);	}
+	}
+
+	/* pass some opts to sdl via enviroment*/
+	putenv("SDL_VIDEO_CENTERED=1");
+
+	/* init sdl video */
+	if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD) != 0) {
+		u_char_t *u = stracpy((u_char_t *)SDL_GetError());
+		add_to_strn(&u, "\n");
+		return u;
+	}
+	
+	/* fetch current video hw informations */
+	sdl_DATA.video_info		= (SDL_VideoInfo *) mem_alloc(sizeof(SDL_VideoInfo));
+	S_ASSERT(sdl_DATA.video_info != NULL);
+	memcpy(sdl_DATA.video_info, SDL_GetVideoInfo(), (sizeof(SDL_VideoInfo)));
+	/* fetch driver name */
+	sdl_DATA.video_drv		= (u_char_t *)mem_alloc(sizeof(u_char_t) * 11);
+	S_ASSERT(sdl_DATA.video_drv != NULL);
+	SDL_VideoDriverName((char *)sdl_DATA.video_drv, 11);
+
+	/* setup defaults */
+	sdl_VIDEO_FLAGS		|= SDL_HWSURFACE | SDL_HWPALETTE | SDL_RESIZABLE | SDL_RLEACCEL | SDL_ASYNCBLIT;
+#ifdef sdl_HAVE_DOUBLEBUF
+	sdl_VIDEO_FLAGS		|= SDL_DOUBLEBUF;
+#endif
+	if(sdl_VIDEO_WIDTH == 0)
+		sdl_VIDEO_WIDTH	= 800;
+	if(sdl_VIDEO_HEIGHT == 0)
+		sdl_VIDEO_HEIGHT= 600;
+	if(sdl_VIDEO_DEPTH == 0)
+		sdl_VIDEO_DEPTH	= sdl_DATA.video_info->vfmt->BitsPerPixel;
+
+	/* FIXME: not sure if this is correct !!!*/
+	sdl_VIDEO_BPP		= (sdl_VIDEO_DEPTH / 8);
+	if(sdl_VIDEO_DEPTH % 8 != 0)
+		sdl_VIDEO_BPP	+= 1;
+
+	/* set driv config */
+	sdl_driver.x		= sdl_VIDEO_WIDTH;
+	sdl_driver.y		= sdl_VIDEO_HEIGHT;
+/*	sdl_driver.depth	= ((sdl_DATA.video_info->vfmt->BytesPerPixel & 0x7) |
+			(((sdl_DATA.video_info->vfmt->BitsPerPixel > 24 ? 24 : sdl_DATA.video_info->vfmt->BitsPerPixel) & 0x1F) << 3));
+*/
+	sdl_driver.depth	= ((sdl_VIDEO_BPP & 0x7) |
+			(((sdl_VIDEO_DEPTH > 24 ? 24 : sdl_VIDEO_DEPTH) & 0x1F) << 3));
+
+	S_ON_DEBUG(fprintf(stderr, "display = %d@%d [%d] (requested)\n", sdl_VIDEO_DEPTH, sdl_VIDEO_BPP, sdl_driver.depth));
+
+
+	/* check if video mode ok*/
+	video_bw_suggest = SDL_VideoModeOK(sdl_VIDEO_WIDTH, sdl_VIDEO_HEIGHT, sdl_VIDEO_DEPTH, sdl_VIDEO_FLAGS);
+	if(video_bw_suggest == 0)
+	{
+		sdl_list_videomodes();
+		sdl_DATA_FREE();
+		return stracpy("ERROR: Requested video mode not OK !\n");
+	}
+	
+	/* check */
+	if(video_bw_suggest != (unsigned long)sdl_VIDEO_DEPTH)
+		fprintf(stderr, "WARNING: Video driver suggested '%ldbpp' video depth...\n", video_bw_suggest);
+		
+
+	/* endianness (stolen from directfb.c) */
+	if (htons (0x1234) == 0x1234)
+		sdl_driver.depth |= 0x100;
+
+	switch (sdl_driver.depth) {
+		case 33:
+		case 65:
+		case 122:
+		case 130:
+		case 386:
+		case 451:
+		case 195:
+		case 452:
+		case 196:
+		case 708:
+			break;
+		default: 
+			sdl_DATA_FREE();
+			SDL_Quit();
+			return stracpy("ERROR: Unsupported display pixel format\n");
+	}
+
+	/* create cursor :) (need nice one) */
+#ifdef sdl_HAVE_CURSOR
+	if(sdl_DATA.cursor == NULL)
+	{
+		/* sdl_DATA.cursor	= SDL_CreateCursor((void *)arrow, (void *)arrow, 32, 32, 0, 0);
+		*/
+		S_ASSERT(sdl_DATA.cursor != NULL);
+	}
+#endif
+	/* key repeat */
+	SDL_EnableUNICODE(1);
+	SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
+
+
+	sdl_DATA.input_encoding	= -1;
+#if defined(HAVE_NL_LANGINFO) && defined(HAVE_LANGINFO_H) && defined(CODESET)
+	{
+		unsigned char *cp;
+		cp	= nl_langinfo(CODESET);
+		sdl_DATA.input_encoding	= get_cp_index(cp);
+	}
+#endif
+	return NULL;
+}
+
+/* shutdown driver */
+static void sdl_shutdown_driver(void)
+{
+	S_ON_DEBUG_TRACE("in");
+	sdl_KILL_TIMER();
+	sdl_DATA_FREE();
+	SDL_Quit();
+	return;
+}
+
+/* create new graph device */
+static struct graphics_device *sdl_init_device(void)
+{
+	struct graphics_device *dev	= NULL;
+	struct t_sdl_device_data *data	= NULL;
+
+	S_ON_DEBUG_TRACE("in");
+
+	/* device data */
+	data			= (struct t_sdl_device_data *) mem_alloc(sizeof(struct t_sdl_device_data));
+	S_ASSERT(data != NULL);
+	memset(data, 0, sizeof(struct t_sdl_device_data));
+
+	/* init video mode */
+	sdl_SURFACE(data)	= SDL_SetVideoMode(sdl_VIDEO_WIDTH, sdl_VIDEO_HEIGHT, sdl_VIDEO_DEPTH, 
+							sdl_VIDEO_FLAGS);
+
+	if(sdl_SURFACE(data) == NULL)
+		return NULL;
+	/* set display alpha */
+	/* SDL_SetAlpha(sdl_SURFACE(data), SDL_SRCALPHA, 0xff); */
+
+	/* re-updating video mode informations */
+	memcpy(sdl_DATA.video_info, SDL_GetVideoInfo(), (sizeof(SDL_VideoInfo)));
+
+	/* re-update depth (to use the one we realy got from SDL) */
+#ifdef __NOT_DEF
+	sdl_driver.depth	= ((sdl_DATA.video_info->vfmt->BytesPerPixel & 0x7) |
+			(((sdl_DATA.video_info->vfmt->BitsPerPixel > 24 ? 24 : sdl_DATA.video_info->vfmt->BitsPerPixel) & 0x1F) << 3));
+#endif
+	S_ON_DEBUG(fprintf(stderr, "display = %d@%d [%d]\n", sdl_DATA.video_info->vfmt->BitsPerPixel, sdl_DATA.video_info->vfmt->BytesPerPixel, sdl_driver.depth));
+
+	/* alloc gd */
+	dev	= (struct graphics_device *) mem_alloc(sizeof(struct graphics_device));
+	S_ASSERT(dev != NULL);
+
+	/* setup gdS */
+	dev->size.x1		= 0;
+	dev->size.y1		= 0;
+	dev->size.x2		= sdl_VIDEO_WIDTH;
+	dev->size.y2		= sdl_VIDEO_HEIGHT;
+	dev->clip		= dev->size;
+
+	/*driver */
+	sdl_GD(data)		= dev;
+
+	/* input encoding flags */
+	if (sdl_DATA.input_encoding < 0)
+		sdl_driver.flags	|= GD_NEED_CODEPAGE;
+
+	/*driver */
+	dev->drv		= &sdl_driver;
+	dev->driver_data	= (void *) data;
+	dev->user_data		= NULL;
+
+	/*set my cursor */
+	if(sdl_DATA.cursor != NULL)
+		SDL_SetCursor(sdl_DATA.cursor);
+
+	/*init timer */
+	sdl_SETUP_TIMER((void *)data);
+	/* print device video info */
+	/*fprintf(stderr, "VIDEO(%s):\t %dx%dx%dbpp [%d]\n", sdl_DATA.video_drv,
+						sdl_VIDEO_WIDTH, sdl_VIDEO_HEIGHT, sdl_VIDEO_DEPTH, sdl_driver.depth);*/
+
+	S_ON_DEBUG_TRACE("out");
+	return dev;
+}
+
+/* destroy device */
+static void sdl_shutdown_device(struct graphics_device *drv)
+{
+	struct t_sdl_device_data *dev	= NULL;
+
+	S_ON_DEBUG_TRACE("in");
+	dev			= (struct t_sdl_device_data *) drv->driver_data;
+	S_ASSERT(dev != NULL);
+	
+	/* unregister bh */
+	unregister_bottom_half(sdl_update_sc, dev);
+
+	/* deinit video */
+	SDL_FreeSurface(sdl_SURFACE(dev));
+	sdl_SURFACE(dev)	= NULL;
+	mem_free(dev);
+	drv->driver_data	= NULL;
+	mem_free(drv);
+	S_ON_DEBUG_TRACE("out");
+	return;
+}
+
+/* get driver parameters 
+   XXX: what is this fx() for ??? */
+static u_char_t *sdl_get_driver_param(void)
+{
+	S_ON_DEBUG_TRACE("in");
+	S_ASSERT(0);
+	return NULL;
+}
+
+/* GRAPHICS */
+
+/* create empty bitmap */
+static int sdl_get_empty_bitmap(struct bitmap *bmp)
+{
+	SDL_Surface	*s	= NULL;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+
+	/* null */
+	bmp->data	= bmp->flags	= bmp->user	= NULL;
+	bmp->skip	= 0;
+
+	/* alloc surface */
+	/* FIXED: ignoring byteorder here (taking from video info) */
+	s		= (SDL_Surface *)SDL_CreateRGBSurface(sdl_VIDEO_FLAGS, bmp->x, bmp->y, sdl_VIDEO_DEPTH,
+					sdl_DATA.video_info->vfmt->Rmask, sdl_DATA.video_info->vfmt->Gmask, 
+					sdl_DATA.video_info->vfmt->Bmask, sdl_DATA.video_info->vfmt->Amask);
+	S_ASSERT(s != NULL);
+
+	/* copy data */
+	bmp->data	= (void *)s->pixels;
+	bmp->skip	= s->pitch;
+	bmp->flags	= (void *)s;
+
+	/* lock if required */
+	if(SDL_MUSTLOCK(s))
+		SDL_LockSurface(s);
+	/* S_ON_DEBUG_TRACE("out"); */
+	return 0;
+}
+
+/* create filled bitmap */
+/*
+int sdl_get_filled_bitmap(struct bitmap *bmp, long color)
+{
+	S_ASSERT(0);
+	return 0;
+}
+*/
+
+/* register bitmap */
+static void sdl_register_bitmap(struct bitmap *bmp)
+{
+	SDL_Surface	*s	= NULL;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+
+	/* unlock surface */
+	s	= (SDL_Surface *)bmp->flags;
+	if(SDL_MUSTLOCK(s))
+		SDL_UnlockSurface(s);
+	/* hide pixel mem */
+	bmp->data	= NULL;
+	/* S_ON_DEBUG_TRACE("out"); */
+	return;
+}
+
+
+/* prepare strip */
+static void *sdl_prepare_strip(struct bitmap *bmp, int top, int lines)
+{
+	SDL_Surface	*s	= NULL;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+
+	/* unlock surface */
+	s	= (SDL_Surface *)bmp->flags;
+	if(SDL_MUSTLOCK(s))
+		SDL_LockSurface(s);
+	/* S_ON_DEBUG_TRACE("out"); */
+	return (void *)(s->pixels + (top * s->pitch));
+}
+
+/* commit strip */
+static void sdl_commit_strip(struct bitmap *bmp, int top, int lines)
+{
+	SDL_Surface	*s	= NULL;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+
+	/* unlock surface */
+	s	= (SDL_Surface *)bmp->flags;
+	if(SDL_MUSTLOCK(s))
+		SDL_UnlockSurface(s);
+	return;
+}
+
+/* unregister bitmap */
+static void sdl_unregister_bitmap(struct bitmap *bmp)
+{
+	SDL_Surface	*s	= NULL;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+
+	s		= (SDL_Surface *)bmp->flags;
+	S_ASSERT(s != 0);
+	/* delete data */
+	SDL_FreeSurface(s);
+	/* null data */
+	bmp->data	= NULL;
+	bmp->flags	= NULL;
+	/* S_ON_DEBUG_TRACE("out"); */
+	return;
+}
+
+/* draw bmp */
+static void sdl_draw_bitmap(struct graphics_device *drv, struct bitmap *bmp, int x, int y)
+{
+	SDL_Surface		 *s	= NULL;
+	struct t_sdl_device_data *dev	= NULL;
+	SDL_Rect	rect;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+	dev	= (struct t_sdl_device_data *) drv->driver_data;
+	s	= (SDL_Surface *)bmp->flags;
+	memset(&rect, 0, sizeof(SDL_Rect));
+
+	/* blit :) */
+	rect.x	= x;
+	rect.y	= y;
+	SDL_BlitSurface(s, NULL, sdl_SURFACE(dev), &rect);
+	sdl_register_update(dev, rect.x, rect.y, rect.w, rect.h, 0);
+	/* S_ON_DEBUG_TRACE("out"); */
+	return;
+}
+
+/* draw more bmps */
+static void sdl_draw_bitmaps(struct graphics_device *drv, struct bitmap **bmps, int n, int x, int y)
+{
+	int	i = 0;
+
+	struct t_sdl_device_data *dev	= NULL;
+	SDL_Rect rect;
+
+	/* FIXME: this functions seems not to be correct !!! */
+
+	/* S_ON_DEBUG_TRACE("in"); */
+	/* check */
+	if(n < 1)
+		return;
+	dev	= (struct t_sdl_device_data *) drv->driver_data;
+	memset(&rect, 0, sizeof(SDL_Rect));
+
+	/* blit */
+	rect.x	= x;
+	rect.y	= y;
+	for(i = 0; i < n; i++)
+	{	SDL_BlitSurface((SDL_Surface *)bmps[i]->flags, NULL, sdl_SURFACE(dev), &rect);
+		rect.x	+=	bmps[i]->x;	}
+	/* FIXME: this should care about updating area, and possibly not update everythink */
+	sdl_register_update(dev, 0, 0, sdl_VIDEO_WIDTH, sdl_VIDEO_HEIGHT, 0);
+	return;
+}
+
+/* fill some area */
+static void sdl_fill_area(struct graphics_device *drv, int x1, int y1, int x2, int y2, long color)
+{
+	struct t_sdl_device_data *dev = NULL;
+	SDL_Rect rect;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+	dev	= (struct t_sdl_device_data *) drv->driver_data;
+
+
+	rect.x	= x1;
+	rect.y	= y1;
+	rect.w	= x2 - x1;
+	rect.h	= y2 - y1;
+	if(SDL_MUSTLOCK(sdl_SURFACE(dev)))
+		SDL_LockSurface(sdl_SURFACE(dev));
+	SDL_FillRect(sdl_SURFACE(dev), &rect, color);
+	if(SDL_MUSTLOCK(sdl_SURFACE(dev)))
+		SDL_UnlockSurface(sdl_SURFACE(dev));
+	/* S_ON_DEBUG(fprintf(stderr, "sdl_fill_area-update(%dx%dx%dx%d)\n", rect.x, rect.y, rect.w, rect.h)); */
+	sdl_register_update(dev, rect.x, rect.y, rect.w, rect.h, 0);
+	/* S_ON_DEBUG_TRACE("out"); */
+	return;
+}
+
+/* draw horizontal line */
+static void sdl_draw_hline(struct graphics_device *drv, int left, int y, int right, long color)
+{
+	register int	i	= 0;
+	struct t_sdl_device_data *dev = NULL;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+	dev	= (struct t_sdl_device_data *) drv->driver_data;
+	if(SDL_MUSTLOCK(sdl_SURFACE(dev)))
+		SDL_LockSurface(sdl_SURFACE(dev));
+	for(i = left; i <= right; i++)
+		sdl_putpixel(sdl_SURFACE(dev), i, y, color);
+	if(SDL_MUSTLOCK(sdl_SURFACE(dev)))
+		SDL_UnlockSurface(sdl_SURFACE(dev));
+	sdl_register_update(dev, left, y, right - left + 1, 1, 0);
+	/* S_ON_DEBUG_TRACE("out"); */
+	return;
+}
+
+/* draw vertical line */
+static void sdl_draw_vline(struct graphics_device *drv, int x, int top, int bottom, long color)
+{
+	register int i = 0;
+	struct t_sdl_device_data *dev = NULL;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+	/* get ptr */
+	dev	= (struct t_sdl_device_data *) drv->driver_data;
+	if(SDL_MUSTLOCK(sdl_SURFACE(dev)))
+		SDL_LockSurface(sdl_SURFACE(dev));
+	for(i = top; i <= bottom; i++)
+		sdl_putpixel(sdl_SURFACE(dev), x, i, color);
+	if(SDL_MUSTLOCK(sdl_SURFACE(dev)))
+		SDL_UnlockSurface(sdl_SURFACE(dev));
+
+	sdl_register_update(dev, x, top, 1, bottom - top + 1, 0);
+	/* S_ON_DEBUG_TRACE("out"); */
+	return;
+}
+
+/* horizontal scroll */
+static int sdl_hscroll(struct graphics_device *drv, struct rect_set **set, int sc)
+{
+	struct t_sdl_device_data *dev = NULL;
+	SDL_Rect rect1, rect2;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+	dev	= (struct t_sdl_device_data *) drv->driver_data;
+
+	/* rect1 */
+	rect1.x = drv->clip.x1;
+	rect1.y = drv->clip.y1;
+	rect1.w = drv->clip.x2 - rect1.x;
+	rect1.h = drv->clip.y2 - rect1.y;
+
+	/* rect2 */
+	rect2.x = drv->clip.x1 + sc;
+	rect2.y = drv->clip.y1;
+#ifdef __NOT_DEF
+	rect2.w = drv->clip.x2 - rect1.x;
+	rect2.h = drv->clip.y2 - rect1.y;
+#endif
+
+	SDL_BlitSurface(sdl_SURFACE(dev), &rect1, sdl_SURFACE(dev), &rect2);
+	sdl_register_update(dev, rect1.x, rect1.y, rect1.w, rect1.h, 0);
+	/* S_ON_DEBUG_TRACE("out"); */
+	return 1;
+}
+
+/* vertical scroll */
+static int sdl_vscroll(struct graphics_device *drv, struct rect_set **set, int sc)
+{
+	struct t_sdl_device_data *dev = NULL;
+	SDL_Rect rect1, rect2;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+	/* get ptr */
+	dev	= (struct t_sdl_device_data *) drv->driver_data;
+
+	/* rect1 */
+	rect1.x = drv->clip.x1;
+	rect1.y = drv->clip.y1;
+	rect1.w = drv->clip.x2 - rect1.x;
+	rect1.h = drv->clip.y2 - rect1.y;
+
+	/* rect2 */
+	rect2.x = drv->clip.x1;
+	rect2.y = drv->clip.y1 + sc;
+#ifdef __NOT_DEF
+	rect2.w = drv->clip.x2 - rect1.x;
+	rect2.h = drv->clip.y2 - rect1.y;
+#endif
+
+	SDL_BlitSurface(sdl_SURFACE(dev), &rect1, sdl_SURFACE(dev), &rect2);
+	sdl_register_update(dev, rect1.x, rect1.y, rect1.w, rect1.h, 0);
+	/* S_ON_DEBUG_TRACE("out"); */
+	return 1;
+}
+
+/* set cliping area */
+static void sdl_set_clip_area(struct graphics_device *drv, struct rect *r)
+{
+	struct t_sdl_device_data *dev = NULL;
+	SDL_Rect rect;
+
+	/* S_ON_DEBUG_TRACE("in"); */
+	/* get ptr */
+	dev	= (struct t_sdl_device_data *) drv->driver_data;
+	/* set rect */
+	rect.x	= r->x1;
+	rect.y	= r->y1;
+	rect.w	= r->x2 - r->x1;
+	rect.h	= r->y2 - r->y1;
+	/* dev clipp */
+	drv->clip	= *r;
+	/* clipp */
+	SDL_SetClipRect(sdl_SURFACE(dev), &rect);
+	/* S_ON_DEBUG_TRACE("out"); */
+	return;
+}
+
+/* return rgb color */
+static long sdl_get_color(int rgb)
+{
+	/* call depth specific function (going like this enables us to use multiple screens with various depths) [someday] */
+	static	long (*gc)(int rgb)	= NULL;
+
+	if(gc == NULL)
+		gc	= get_color_fn(sdl_driver.depth);
+	/*return rgb specific*/
+	if(gc != NULL)
+		return gc(rgb);
+	else
+		return (rgb);
+}
+
+/* set window title (tittle utf-8 encoded !!!!) */
+static void sdl_set_title(struct graphics_device *drv, u_char_t *title)
+{
+	struct conv_table *ct = get_translation_table(utf8_table, sdl_DATA.input_encoding >= 0 ? sdl_DATA.input_encoding:0);
+	unsigned char	*t;
+
+	/* convert tittle */
+	t	= convert_string(ct, title, strlen(title), NULL);
+
+	/* S_ON_DEBUG_TRACE("in"); */
+	SDL_WM_SetCaption((const char *)t, NULL);
+	mem_free(t);
+	return;
+}
+
+
+
+/* driver definition data */
+struct graphics_driver sdl_driver={
+	"sdl",
+	sdl_init_driver,
+	sdl_init_device,
+	sdl_shutdown_device,
+	sdl_shutdown_driver,
+	sdl_get_driver_param,
+	sdl_get_empty_bitmap,
+	/*sdl_get_filled_bitmap,*/
+	sdl_register_bitmap,
+	sdl_prepare_strip,
+	sdl_commit_strip,
+	sdl_unregister_bitmap,
+	sdl_draw_bitmap,
+	sdl_draw_bitmaps,
+	sdl_get_color,			/* sdl_get_color */
+	sdl_fill_area,
+	sdl_draw_hline,
+	sdl_draw_vline,
+	sdl_hscroll,
+	sdl_vscroll,
+	sdl_set_clip_area,
+	dummy_block,
+	dummy_unblock,
+	sdl_set_title,			/* set_title */
+	NULL, /* exec */
+	0,				/* depth (filled in sdl_init_driver function) */
+	0, 0,				/* size (in X is empty) */
+	GD_ONLY_1_WINDOW | GD_NOAUTO,	/* flags */
+	0,				/* codepage */
+	NULL				/* shell */
+};
+
+
+
+#endif /* GRDRV_SDL */
+
--- a/sdl_data.inc	1970-01-01 01:00:00.000000000 +0100
+++ b/sdl_data.inc	2010-09-25 18:38:37.887567087 +0200
@@ -0,0 +1,276 @@
+/**
+  sdl key syms
+
+  XXX: i'know this is stupit but i'm preparing for some good solution :)
+
+*/
+
+
+#ifndef _SDL_KEYS_INC
+#define _SDL_KEYS_INC
+
+struct t_sdl_keysym
+{
+	unsigned short	sym;
+	int		key;	
+};
+
+/* big mapping SDL->LINKS */
+static struct t_sdl_keysym sdl_keysyms[] =
+{
+	{ SDLK_UNKNOWN		,0 },
+	{ SDLK_FIRST		,0 },
+	{ SDLK_BACKSPACE	,KBD_BS },
+	{ SDLK_TAB		,KBD_TAB },
+	{ SDLK_CLEAR		,12 },
+	{ SDLK_RETURN		,KBD_ENTER },
+	{ SDLK_PAUSE		,19 },
+	{ SDLK_ESCAPE		,KBD_ESC },
+	{ SDLK_SPACE		,32 },
+	{ SDLK_EXCLAIM		,33 },
+	{ SDLK_QUOTEDBL		,34 },
+	{ SDLK_HASH		,35 },
+	{ SDLK_DOLLAR		,36 },
+	{ SDLK_AMPERSAND		,38 },
+	{ SDLK_QUOTE		,39 },
+	{ SDLK_LEFTPAREN		,40 },
+	{ SDLK_RIGHTPAREN		,41 },
+	{ SDLK_ASTERISK		,42 },
+	{ SDLK_PLUS		,43 },
+	{ SDLK_COMMA		,44 },
+	{ SDLK_MINUS		,45 },
+	{ SDLK_PERIOD		,46 },
+	{ SDLK_SLASH		,47 },
+	{ SDLK_0			,48 },
+	{ SDLK_1			,49 },
+	{ SDLK_2			,50 },
+	{ SDLK_3			,51 },
+	{ SDLK_4			,52 },
+	{ SDLK_5			,53 },
+	{ SDLK_6			,54 },
+	{ SDLK_7			,55 },
+	{ SDLK_8			,56 },
+	{ SDLK_9			,57 },
+	{ SDLK_COLON		,58 },
+	{ SDLK_SEMICOLON		,59 },
+	{ SDLK_LESS		,60 },
+	{ SDLK_EQUALS		,61 },
+	{ SDLK_GREATER		,62 },
+	{ SDLK_QUESTION		,63 },
+	{ SDLK_AT			,64 },
+	/* 
+	   Skip uppercase letters
+	 */
+	{ SDLK_LEFTBRACKET	,91 },
+	{ SDLK_BACKSLASH		,92 },
+	{ SDLK_RIGHTBRACKET	,93 },
+	{ SDLK_CARET		,94 },
+	{ SDLK_UNDERSCORE		,95 },
+	{ SDLK_BACKQUOTE		,96 },
+	{ SDLK_a			,97 },
+	{ SDLK_b			,98 },
+	{ SDLK_c			,99 },
+	{ SDLK_d			,100 },
+	{ SDLK_e			,101 },
+	{ SDLK_f			,102 },
+	{ SDLK_g			,103 },
+	{ SDLK_h			,104 },
+	{ SDLK_i			,105 },
+	{ SDLK_j			,106 },
+	{ SDLK_k			,107 },
+	{ SDLK_l			,108 },
+	{ SDLK_m			,109 },
+	{ SDLK_n			,110 },
+	{ SDLK_o			,111 },
+	{ SDLK_p			,112 },
+	{ SDLK_q			,113 },
+	{ SDLK_r			,114 },
+	{ SDLK_s			,115 },
+	{ SDLK_t			,116 },
+	{ SDLK_u			,117 },
+	{ SDLK_v			,118 },
+	{ SDLK_w			,119 },
+	{ SDLK_x			,120 },
+	{ SDLK_y			,121 },
+	{ SDLK_z			,122 },
+	{ SDLK_DELETE		,127 },
+	/* End of ASCII mapped keysyms */
+
+	/* International keyboard syms */
+	{ SDLK_WORLD_0		,160 },		/* 0xA0 */
+	{ SDLK_WORLD_1		,161 },
+	{ SDLK_WORLD_2		,162 },
+	{ SDLK_WORLD_3		,163 },
+	{ SDLK_WORLD_4		,164 },
+	{ SDLK_WORLD_5		,165 },
+	{ SDLK_WORLD_6		,166 },
+	{ SDLK_WORLD_7		,167 },
+	{ SDLK_WORLD_8		,168 },
+	{ SDLK_WORLD_9		,169 },
+	{ SDLK_WORLD_10		,170 },
+	{ SDLK_WORLD_11		,171 },
+	{ SDLK_WORLD_12		,172 },
+	{ SDLK_WORLD_13		,173 },
+	{ SDLK_WORLD_14		,174 },
+	{ SDLK_WORLD_15		,175 },
+	{ SDLK_WORLD_16		,176 },
+	{ SDLK_WORLD_17		,177 },
+	{ SDLK_WORLD_18		,178 },
+	{ SDLK_WORLD_19		,179 },
+	{ SDLK_WORLD_20		,180 },
+	{ SDLK_WORLD_21		,181 },
+	{ SDLK_WORLD_22		,182 },
+	{ SDLK_WORLD_23		,183 },
+	{ SDLK_WORLD_24		,184 },
+	{ SDLK_WORLD_25		,185 },
+	{ SDLK_WORLD_26		,186 },
+	{ SDLK_WORLD_27		,187 },
+	{ SDLK_WORLD_28		,188 },
+	{ SDLK_WORLD_29		,189 },
+	{ SDLK_WORLD_30		,190 },
+	{ SDLK_WORLD_31		,191 },
+	{ SDLK_WORLD_32		,192 },
+	{ SDLK_WORLD_33		,193 },
+	{ SDLK_WORLD_34		,194 },
+	{ SDLK_WORLD_35		,195 },
+	{ SDLK_WORLD_36		,196 },
+	{ SDLK_WORLD_37		,197 },
+	{ SDLK_WORLD_38		,198 },
+	{ SDLK_WORLD_39		,199 },
+	{ SDLK_WORLD_40		,200 },
+	{ SDLK_WORLD_41		,201 },
+	{ SDLK_WORLD_42		,202 },
+	{ SDLK_WORLD_43		,203 },
+	{ SDLK_WORLD_44		,204 },
+	{ SDLK_WORLD_45		,205 },
+	{ SDLK_WORLD_46		,206 },
+	{ SDLK_WORLD_47		,207 },
+	{ SDLK_WORLD_48		,208 },
+	{ SDLK_WORLD_49		,209 },
+	{ SDLK_WORLD_50		,210 },
+	{ SDLK_WORLD_51		,211 },
+	{ SDLK_WORLD_52		,212 },
+	{ SDLK_WORLD_53		,213 },
+	{ SDLK_WORLD_54		,214 },
+	{ SDLK_WORLD_55		,215 },
+	{ SDLK_WORLD_56		,216 },
+	{ SDLK_WORLD_57		,217 },
+	{ SDLK_WORLD_58		,218 },
+	{ SDLK_WORLD_59		,219 },
+	{ SDLK_WORLD_60		,220 },
+	{ SDLK_WORLD_61		,221 },
+	{ SDLK_WORLD_62		,222 },
+	{ SDLK_WORLD_63		,223 },
+	{ SDLK_WORLD_64		,224 },
+	{ SDLK_WORLD_65		,225 },
+	{ SDLK_WORLD_66		,226 },
+	{ SDLK_WORLD_67		,227 },
+	{ SDLK_WORLD_68		,228 },
+	{ SDLK_WORLD_69		,229 },
+	{ SDLK_WORLD_70		,230 },
+	{ SDLK_WORLD_71		,231 },
+	{ SDLK_WORLD_72		,232 },
+	{ SDLK_WORLD_73		,233 },
+	{ SDLK_WORLD_74		,234 },
+	{ SDLK_WORLD_75		,235 },
+	{ SDLK_WORLD_76		,236 },
+	{ SDLK_WORLD_77		,237 },
+	{ SDLK_WORLD_78		,238 },
+	{ SDLK_WORLD_79		,239 },
+	{ SDLK_WORLD_80		,240 },
+	{ SDLK_WORLD_81		,241 },
+	{ SDLK_WORLD_82		,242 },
+	{ SDLK_WORLD_83		,243 },
+	{ SDLK_WORLD_84		,244 },
+	{ SDLK_WORLD_85		,245 },
+	{ SDLK_WORLD_86		,246 },
+	{ SDLK_WORLD_87		,247 },
+	{ SDLK_WORLD_88		,248 },
+	{ SDLK_WORLD_89		,249 },
+	{ SDLK_WORLD_90		,250 },
+	{ SDLK_WORLD_91		,251 },
+	{ SDLK_WORLD_92		,252 },
+	{ SDLK_WORLD_93		,253 },
+	{ SDLK_WORLD_94		,254 },
+	{ SDLK_WORLD_95		,255 },		/* 0xFF */
+
+	/* Numeric keypad */
+	{ SDLK_KP0		,256 },
+	{ SDLK_KP1		,257 },
+	{ SDLK_KP2		,258 },
+	{ SDLK_KP3		,259 },
+	{ SDLK_KP4		,260 },
+	{ SDLK_KP5		,261 },
+	{ SDLK_KP6		,262 },
+	{ SDLK_KP7		,263 },
+	{ SDLK_KP8		,264 },
+	{ SDLK_KP9		,265 },
+	{ SDLK_KP_PERIOD	,266 },
+	{ SDLK_KP_DIVIDE	,267 },
+	{ SDLK_KP_MULTIPLY	,268 },
+	{ SDLK_KP_MINUS		,269 },
+	{ SDLK_KP_PLUS		,270 },
+	{ SDLK_KP_ENTER		,KBD_ENTER },
+	{ SDLK_KP_EQUALS	,272 },
+
+	/* Arrows + Home/End pad */
+	{ SDLK_UP		,KBD_UP },
+	{ SDLK_DOWN		,KBD_DOWN },
+	{ SDLK_RIGHT		,KBD_RIGHT },
+	{ SDLK_LEFT		,KBD_LEFT },
+	{ SDLK_INSERT		,KBD_INS },
+	{ SDLK_HOME		,KBD_HOME },
+	{ SDLK_END		,KBD_END },
+	{ SDLK_PAGEUP		,KBD_PAGE_UP },
+	{ SDLK_PAGEDOWN		,KBD_PAGE_DOWN },
+
+	/* Function keys */
+	{ SDLK_F1		,KBD_F1 },
+	{ SDLK_F2		,KBD_F2 },
+	{ SDLK_F3		,KBD_F3 },
+	{ SDLK_F4		,KBD_F4 },
+	{ SDLK_F5		,KBD_F5 },
+	{ SDLK_F6		,KBD_F6 },
+	{ SDLK_F7		,KBD_F7 },
+	{ SDLK_F8		,KBD_F8 },
+	{ SDLK_F9		,KBD_F9 },
+	{ SDLK_F10		,KBD_F10 },
+	{ SDLK_F11		,KBD_F11 },
+	{ SDLK_F12		,KBD_F12 },
+	{ SDLK_F13		,294 },
+	{ SDLK_F14		,295 },
+	{ SDLK_F15		,296 },
+
+	/* Key state modifier keys */
+	{ SDLK_NUMLOCK		,300 },
+	{ SDLK_CAPSLOCK		,301 },
+	{ SDLK_SCROLLOCK		,302 },
+	{ SDLK_RSHIFT		,303 },
+	{ SDLK_LSHIFT		,304 },
+	{ SDLK_RCTRL		,305 },
+	{ SDLK_LCTRL		,306 },
+	{ SDLK_RALT		,307 },
+	{ SDLK_LALT		,308 },
+	{ SDLK_RMETA		,309 },
+	{ SDLK_LMETA		,310 },
+	{ SDLK_LSUPER		,311 },		/* Left "Windows" key */
+	{ SDLK_RSUPER		,312 },		/* Right "Windows" key */
+	{ SDLK_MODE		,313 },		/* "Alt Gr" key */
+	{ SDLK_COMPOSE		,314 },		/* Multi-key compose key */
+
+	/* Miscellaneous function keys */
+	{ SDLK_HELP		,315 },
+	{ SDLK_PRINT		,316 },
+	{ SDLK_SYSREQ		,317 },
+	{ SDLK_BREAK		,318 },
+	{ SDLK_MENU		,KBD_F9 },
+	{ SDLK_POWER		,320 },		/* Power Macintosh power key */
+	{ SDLK_EURO		,321 },		/* Some european keyboards */
+	{ SDLK_UNDO		,322 },		/* Atari keyboard has Undo */
+
+	/* Add any other keys here */
+
+	{ SDLK_LAST		,0  },
+};
+
+#endif