DirectFB cleanups & simple window manager
authorCouriersud <couriersud@arcor.de>
Sun, 11 Jan 2009 23:49:23 +0000
changeset 3023 d72a0dd80e8b
parent 3022 db20dde98dd3
child 3024 1a08749aebce
DirectFB cleanups & simple window manager - use SDL_getenv, not getenv ... - no more support for 0.9.25 - not even mentioned any longer on directfb.org - fix fullscreen issues - add a simple window manager unless the directfb team comes up with a working wm. The driver has support for a very, very basic window manager you may want to use when runnning with "wm=default". Use export SDL_DIRECTFB_WM=1 to enable basic window borders including icon support. In order to have the window title rendered, you need to have the following font installed: /usr/share/fonts/truetype/freefont/FreeSans.ttf
README.DirectFB
src/video/directfb/SDL_DirectFB_WM.c
src/video/directfb/SDL_DirectFB_WM.h
src/video/directfb/SDL_DirectFB_dyn.c
src/video/directfb/SDL_DirectFB_dyn.h
src/video/directfb/SDL_DirectFB_events.c
src/video/directfb/SDL_DirectFB_modes.c
src/video/directfb/SDL_DirectFB_mouse.c
src/video/directfb/SDL_DirectFB_opengl.c
src/video/directfb/SDL_DirectFB_render.c
src/video/directfb/SDL_DirectFB_video.c
src/video/directfb/SDL_DirectFB_video.h
src/video/directfb/SDL_DirectFB_window.c
src/video/directfb/SDL_DirectFB_window.h
--- a/README.DirectFB	Sun Jan 11 23:39:11 2009 +0000
+++ b/README.DirectFB	Sun Jan 11 23:49:23 2009 +0000
@@ -49,6 +49,19 @@
 to make the YUV texture an underlay. This will make the cursor to
 be shown.
 
+Simple Window Manager
+=====================
+
+The driver has support for a very, very basic window manager you may
+want to use when runnning with "wm=default". Use
+
+export SDL_DIRECTFB_WM=1
+
+to enable basic window borders. In order to have the window title rendered,
+you need to have the following font installed:
+
+/usr/share/fonts/truetype/freefont/FreeSans.ttf
+
 OPENGL Support
 ==============
 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/directfb/SDL_DirectFB_WM.c	Sun Jan 11 23:49:23 2009 +0000
@@ -0,0 +1,361 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+//#include "SDL_syswm.h"
+//#include "../SDL_sysvideo.h"
+//#include "../../events/SDL_keyboard_c.h"
+
+#include "SDL_DirectFB_video.h"
+
+#define COLOR_EXPAND(col) col.r, col.g, col.b, col.a
+
+static DFB_Theme theme_std = {
+    4, 4, 8, 8,
+    {255, 200, 200, 200},
+    24,
+    {255, 0, 0, 255},
+    16,
+    {255, 255, 255, 255},
+    "/usr/share/fonts/truetype/freefont/FreeSans.ttf",
+    {255, 255, 0, 0},
+    {255, 255, 255, 0},
+};
+
+static DFB_Theme theme_none = {
+    0, 0, 0, 0,
+    {0, 0, 0, 0},
+    0,
+    {0, 0, 0, 0},
+    0,
+    {0, 0, 0, 0},
+    NULL
+};
+
+static void
+DrTriangle(IDirectFBSurface * s, int down, int x, int y, int w)
+{
+    int x1, x2, x3;
+    int y1, y2, y3;
+
+    if (down) {
+        x1 = x + w / 2;
+        x2 = x;
+        x3 = x + w;
+        y1 = y + w;
+        y2 = y;
+        y3 = y;
+    } else {
+        x1 = x + w / 2;
+        x2 = x;
+        x3 = x + w;
+        y1 = y;
+        y2 = y + w;
+        y3 = y + w;
+    }
+    s->FillTriangle(s, x1, y1, x2, y2, x3, y3);
+}
+
+static void
+DrCaption(IDirectFBSurface * s, int x, int y, char *text)
+{
+    DFBSurfaceTextFlags flags;
+
+    flags = DSTF_CENTER | DSTF_TOP;
+
+    s->DrawString(s, text, -1, x, y, flags);
+}
+
+void
+DirectFB_WM_RedrawLayout(SDL_Window * window)
+{
+    SDL_DFB_WINDOWDATA(window);
+    IDirectFBSurface *s = windata->window_surface;
+    DFB_Theme *t = &windata->theme;
+    int i;
+    int d = (t->caption_size - t->font_size) / 2;
+    int x, y, w;
+
+
+    if (!windata->is_managed || (window->flags & SDL_WINDOW_FULLSCREEN))
+        return;
+
+    //s->SetDrawingFlags(s, DSDRAW_BLEND);
+    s->SetColor(s, COLOR_EXPAND(t->frame_color));
+    /* top */
+    for (i = 0; i < t->top_size; i++)
+        s->DrawLine(s, 0, i, windata->size.w, i);
+    /* bottom */
+    for (i = windata->size.h - t->bottom_size; i < windata->size.h; i++)
+        s->DrawLine(s, 0, i, windata->size.w, i);
+    /* left */
+    for (i = 0; i < t->left_size; i++)
+        s->DrawLine(s, i, 0, i, windata->size.h);
+    /* right */
+    for (i = windata->size.w - t->right_size; i < windata->size.w; i++)
+        s->DrawLine(s, i, 0, i, windata->size.h);
+    /* Caption */
+    s->SetColor(s, COLOR_EXPAND(t->caption_color));
+    s->FillRectangle(s, t->left_size, t->top_size, windata->client.w,
+                     t->caption_size);
+    /* Close Button */
+    w = t->caption_size;
+    x = windata->size.w - t->right_size - w + d;
+    y = t->top_size + d;
+    s->SetColor(s, COLOR_EXPAND(t->close_color));
+    DrTriangle(s, 1, x, y, w - 2 * d);
+    /* Max Button */
+    s->SetColor(s, COLOR_EXPAND(t->max_color));
+    DrTriangle(s, window->flags & SDL_WINDOW_MAXIMIZED ? 1 : 0, x - w,
+               y, w - 2 * d);
+
+    /* Caption */
+    if (window->title) {
+        s->SetColor(s, COLOR_EXPAND(t->font_color));
+        DrCaption(s, (x - w) / 2, t->top_size + d, window->title);
+    }
+    /* Icon */
+    if (windata->icon) {
+        DFBRectangle dr;
+
+        dr.x = t->left_size + d;
+        dr.y = t->top_size + d;
+        dr.w = w - 2 * d;
+        dr.h = w - 2 * d;
+        s->SetBlittingFlags(s, DSBLIT_BLEND_ALPHACHANNEL);
+
+        s->StretchBlit(s, windata->icon, NULL, &dr);
+    }
+    windata->wm_needs_redraw = 0;
+}
+
+DFBResult
+DirectFB_WM_GetClientSize(_THIS, SDL_Window * window, int *cw, int *ch)
+{
+    SDL_DFB_WINDOWDATA(window);
+    DFBResult ret;
+
+    ret = windata->window->GetSize(windata->window, cw, ch);
+    *cw -= windata->theme.left_size + windata->theme.right_size;
+    *ch -=
+        windata->theme.top_size + windata->theme.caption_size +
+        windata->theme.bottom_size;
+    return ret;
+}
+
+void
+DirectFB_WM_AdjustWindowLayout(SDL_Window * window)
+{
+    SDL_DFB_WINDOWDATA(window);
+
+    if (!windata->is_managed)
+        windata->theme = theme_none;
+    else if (window->flags & SDL_WINDOW_FULLSCREEN) {
+        windata->theme = theme_none;
+    } else if (window->flags & SDL_WINDOW_MAXIMIZED) {
+        windata->theme = theme_std;
+        windata->theme.left_size = 0;
+        windata->theme.right_size = 0;
+        windata->theme.top_size = 0;
+        windata->theme.bottom_size = 0;
+    } else {
+        windata->theme = theme_std;
+    }
+
+    windata->client.x = windata->theme.left_size;
+    windata->client.y = windata->theme.top_size + windata->theme.caption_size;
+    windata->client.w = window->w;
+    windata->client.h = window->h;
+    windata->size.w =
+        window->w + windata->theme.left_size + windata->theme.right_size;
+    windata->size.h =
+        window->h + windata->theme.top_size +
+        windata->theme.caption_size + windata->theme.bottom_size;
+}
+
+void
+DirectFB_WM_MaximizeWindow(_THIS, SDL_Window * window)
+{
+    SDL_DFB_WINDOWDATA(window);
+    SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+
+    windata->window->GetPosition(windata->window,
+                                     &windata->restore.x,
+                                     &windata->restore.y);
+    windata->window->GetSize(windata->window, &windata->restore.w,
+                                 &windata->restore.h);
+
+    /* Do this already here */
+    window->flags |= SDL_WINDOW_MAXIMIZED;
+    DirectFB_WM_AdjustWindowLayout(window);
+
+    windata->window->MoveTo(windata->window, 0, 0);
+    windata->window->Resize(windata->window,
+                            display->current_mode.w,
+                            display->current_mode.h);
+    SDL_SendWindowEvent(windata->sdl_id, SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
+}
+
+void
+DirectFB_WM_RestoreWindow(_THIS, SDL_Window * window)
+{
+    SDL_DFB_WINDOWDATA(window);
+
+    /* Do this already here */
+    //window->flags &= ~(SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED);
+
+    DirectFB_WM_AdjustWindowLayout(window);
+    windata->window->MoveTo(windata->window, windata->restore.x,
+                            windata->restore.y);
+    windata->window->Resize(windata->window, windata->restore.w,
+                            windata->restore.h);
+    SDL_SendWindowEvent(windata->sdl_id, SDL_WINDOWEVENT_RESTORED, 0, 0);
+}
+
+enum
+{
+    WM_POS_NONE = 0x00,
+    WM_POS_CAPTION = 0x01,
+    WM_POS_CLOSE = 0x02,
+    WM_POS_MAX = 0x04,
+    WM_POS_LEFT = 0x08,
+    WM_POS_RIGHT = 0x10,
+    WM_POS_TOP = 0x20,
+    WM_POS_BOTTOM = 0x40,
+};
+
+static int
+WMIsClient(DFB_WindowData * p, int x, int y)
+{
+    x -= p->client.x;
+    y -= p->client.y;
+    if (x < 0 || y < 0)
+        return 0;
+    if (x >= p->client.w || y >= p->client.h)
+        return 0;
+    return 1;
+}
+
+static int
+WMPos(DFB_WindowData * p, int x, int y)
+{
+    int pos = WM_POS_NONE;
+
+    if (!WMIsClient(p, x, y)) {
+        if (y < p->theme.top_size) {
+            pos |= WM_POS_TOP;
+        } else if (y < p->client.y) {
+            if (x <
+                p->size.w - p->theme.right_size - 2 * p->theme.caption_size) {
+                pos |= WM_POS_CAPTION;
+            } else if (x <
+                       p->size.w - p->theme.right_size -
+                       p->theme.caption_size) {
+                pos |= WM_POS_MAX;
+            } else {
+                pos |= WM_POS_CLOSE;
+            }
+        } else if (y >= p->size.h - p->theme.bottom_size) {
+            pos |= WM_POS_BOTTOM;
+        }
+        if (x < p->theme.left_size) {
+            pos |= WM_POS_LEFT;
+        } else if (x >= p->size.w - p->theme.right_size) {
+            pos |= WM_POS_RIGHT;
+        }
+    }
+    return pos;
+}
+
+static int wm_grab;
+static int wm_lastx;
+static int wm_lasty;
+
+int
+DirectFB_WM_ProcessEvent(_THIS, SDL_Window *window, DFBWindowEvent * evt)
+{
+    SDL_DFB_WINDOWDATA(window);
+
+    if (!windata->is_managed)
+        return 0;
+
+    switch (evt->type) {
+    case DWET_BUTTONDOWN:
+        if (evt->buttons & DIBM_LEFT) {
+            int pos = WMPos(windata, evt->x, evt->y);
+            switch (pos) {
+            case WM_POS_NONE:
+                return 0;
+            case WM_POS_CLOSE:
+                SDL_SendWindowEvent(windata->sdl_id, SDL_WINDOWEVENT_CLOSE, 0, 0);
+                return 1;
+            case WM_POS_MAX:
+                if (window->flags & SDL_WINDOW_MAXIMIZED) {
+                    DirectFB_WM_RestoreWindow(_this, window);
+                } else {
+                	DirectFB_WM_MaximizeWindow(_this, window);
+                }
+                return 1;
+            default:
+                wm_grab = pos;
+                windata->window->GrabPointer(windata->window);
+                wm_lastx = evt->cx;
+                wm_lasty = evt->cy;
+            }
+        }
+        return 1;
+    case DWET_BUTTONUP:
+        break;
+    case DWET_MOTION:
+        if (!wm_grab)
+            return 0;
+        if (evt->buttons & DIBM_LEFT) {
+            int dx = evt->cx - wm_lastx;
+            int dy = evt->cy - wm_lasty;
+            int cw, ch;
+
+            if (wm_grab & WM_POS_CAPTION)
+                windata->window->Move(windata->window, dx, dy);
+            if (wm_grab & WM_POS_RIGHT) {
+                windata->window->GetSize(windata->window, &cw, &ch);
+                windata->window->Resize(windata->window, cw + dx, ch);
+            }
+            if (wm_grab & WM_POS_BOTTOM) {
+                windata->window->GetSize(windata->window, &cw, &ch);
+                windata->window->Resize(windata->window, cw, ch + dy);
+            }
+            wm_lastx = evt->cx;
+            wm_lasty = evt->cy;
+            return 1;
+        }
+        windata->window->UngrabPointer(windata->window);
+        wm_grab = WM_POS_NONE;
+        break;
+    case DWET_KEYDOWN:
+        break;
+    case DWET_KEYUP:
+        break;
+    default:
+        ;
+    }
+    return 0;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/directfb/SDL_DirectFB_WM.h	Sun Jan 11 23:49:23 2009 +0000
@@ -0,0 +1,56 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifndef _SDL_directfb_wm_h
+#define _SDL_directfb_wm_h
+
+typedef struct _DFB_Theme DFB_Theme;
+struct _DFB_Theme
+{
+    int left_size;
+    int right_size;
+    int top_size;
+    int bottom_size;
+    DFBColor frame_color;
+    int caption_size;
+    DFBColor caption_color;
+    int font_size;
+    DFBColor font_color;
+    char *font;
+    DFBColor close_color;
+    DFBColor max_color;
+};
+
+extern void DirectFB_WM_AdjustWindowLayout(SDL_Window * window);
+extern void DirectFB_WM_MaximizeWindow(_THIS, SDL_Window * window);
+extern void DirectFB_WM_RestoreWindow(_THIS, SDL_Window * window);
+extern void DirectFB_WM_RedrawLayout(SDL_Window * window);
+
+extern int DirectFB_WM_ProcessEvent(_THIS, SDL_Window *window, DFBWindowEvent * evt);
+
+extern DFBResult DirectFB_WM_GetClientSize(_THIS, SDL_Window * window, int *cw, int *ch);
+
+
+#endif /* _SDL_directfb_wm_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/directfb/SDL_DirectFB_dyn.c	Sun Jan 11 23:39:11 2009 +0000
+++ b/src/video/directfb/SDL_DirectFB_dyn.c	Sun Jan 11 23:49:23 2009 +0000
@@ -21,8 +21,8 @@
 */
 #include "SDL_config.h"
 
+#include "SDL_DirectFB_video.h"
 #include "SDL_DirectFB_dyn.h"
-#include "SDL_DirectFB_video.h"
 
 #ifdef SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC
 #include "SDL_name.h"
@@ -69,11 +69,11 @@
         }
     }
     if (retval) {
+        const char *stemp = DirectFBCheckVersion(DIRECTFB_MAJOR_VERSION,
+                                                 DIRECTFB_MINOR_VERSION,
+                                                 DIRECTFB_MICRO_VERSION);
         /* Version Check */
-        if ((*SDL_DirectFB_Symbols.directfb_major_version !=
-             DIRECTFB_MAJOR_VERSION)
-            || (*SDL_DirectFB_Symbols.directfb_minor_version !=
-                DIRECTFB_MINOR_VERSION)) {
+        if (stemp != NULL) {
             fprintf(stderr,
                     "DirectFB Lib: Version mismatch. Compiled: %d.%d.%d Library %d.%d.%d\n",
                     DIRECTFB_MAJOR_VERSION, DIRECTFB_MINOR_VERSION,
--- a/src/video/directfb/SDL_DirectFB_dyn.h	Sun Jan 11 23:39:11 2009 +0000
+++ b/src/video/directfb/SDL_DirectFB_dyn.h	Sun Jan 11 23:49:23 2009 +0000
@@ -30,8 +30,9 @@
 	DFB_SYM(const char *, DirectFBUsageString, ( void ), (), return) \
 	DFB_SYM(DFBResult, DirectFBInit, (int *argc, char *(*argv[]) ), (argc, argv), return) \
 	DFB_SYM(DFBResult, DirectFBSetOption, (const char *name, const char *value), (name, value), return) \
-	DFB_SYM(DFBResult, DirectFBCreate, (IDirectFB **interface), (interface), return)
-
+	DFB_SYM(DFBResult, DirectFBCreate, (IDirectFB **interface), (interface), return) \
+	DFB_SYM(const char *, DirectFBCheckVersion, (unsigned int required_major, unsigned int required_minor, unsigned int required_micro), \
+				(required_major, required_minor, required_micro), return)
 // #define SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC "/usr/lib/libdirectfb-1.2.so.0"
 
 int SDL_DirectFB_LoadLibrary(void);
--- a/src/video/directfb/SDL_DirectFB_events.c	Sun Jan 11 23:39:11 2009 +0000
+++ b/src/video/directfb/SDL_DirectFB_events.c	Sun Jan 11 23:49:23 2009 +0000
@@ -60,8 +60,8 @@
     int ret;
 
     if (dispdata->vidIDinuse)
-        SDL_DFB_CHECKERR(dispdata->vidlayer->
-                         SwitchContext(dispdata->vidlayer, DFB_TRUE));
+        SDL_DFB_CHECKERR(dispdata->vidlayer->SwitchContext(dispdata->vidlayer,
+                                                           DFB_TRUE));
 
   error:
     return;
@@ -117,6 +117,254 @@
     return -1;
 }
 
+static int
+ClientXY(DFB_WindowData * p, int *x, int *y)
+{
+    int cx, cy;
+
+    cx = *x;
+    cy = *y;
+
+    cx -= p->client.x;
+    cy -= p->client.y;
+
+    if (cx < 0 || cy < 0)
+        return 0;
+    if (cx >= p->client.w || cy >= p->client.h)
+        return 0;
+    *x = cx;
+    *y = cy;
+    return 1;
+}
+
+static void
+ProcessWindowEvent(_THIS, DFB_WindowData * p, Uint32 flags,
+                   DFBWindowEvent * evt)
+{
+    SDL_DFB_DEVICEDATA(_this);
+    SDL_keysym keysym;
+    char text[5];
+
+    if (evt->clazz == DFEC_WINDOW) {
+        switch (evt->type) {
+        case DWET_BUTTONDOWN:
+            if (ClientXY(p, &evt->x, &evt->y)) {
+                if (!devdata->use_linux_input) {
+                    SDL_SendMouseMotion(devdata->mouse_id[0], 0, evt->x,
+                                        evt->y, 0);
+                    SDL_SendMouseButton(devdata->mouse_id[0],
+                                        SDL_PRESSED,
+                                        DirectFB_TranslateButton
+                                        (evt->button));
+                } else {
+                    MotionAllMice(_this, evt->x, evt->y);
+                }
+            }
+            break;
+        case DWET_BUTTONUP:
+            if (ClientXY(p, &evt->x, &evt->y)) {
+                if (!devdata->use_linux_input) {
+                    SDL_SendMouseMotion(devdata->mouse_id[0], 0, evt->x,
+                                        evt->y, 0);
+                    SDL_SendMouseButton(devdata->mouse_id[0],
+                                        SDL_RELEASED,
+                                        DirectFB_TranslateButton
+                                        (evt->button));
+                } else {
+                    MotionAllMice(_this, evt->x, evt->y);
+                }
+            }
+            break;
+        case DWET_MOTION:
+            if (ClientXY(p, &evt->x, &evt->y)) {
+            	SDL_Window *window = SDL_GetWindowFromID(p->sdl_id);
+                if (!devdata->use_linux_input) {
+                    if (!(flags & SDL_WINDOW_INPUT_GRABBED))
+                        SDL_SendMouseMotion(devdata->mouse_id[0], 0,
+                                            evt->x, evt->y, 0);
+                } else {
+                    /* relative movements are not exact! 
+                     * This code should limit the number of events sent.
+                     * However it kills MAME axis recognition ... */
+                    static int cnt = 0;
+                    if (1 && ++cnt > 20) {
+                        MotionAllMice(_this, evt->x, evt->y);
+                        cnt = 0;
+                    }
+                }
+                if (!(window->flags & SDL_WINDOW_MOUSE_FOCUS))
+                    SDL_SendWindowEvent(p->sdl_id, SDL_WINDOWEVENT_ENTER, 0, 0);
+            }
+            break;
+        case DWET_KEYDOWN:
+            if (!devdata->use_linux_input) {
+                DirectFB_TranslateKey(_this, evt, &keysym);
+                SDL_SendKeyboardKey(0, SDL_PRESSED, keysym.scancode);
+                if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
+                    SDL_memcpy(text, &keysym.unicode, 4);
+                    text[4] = 0;
+                    if (*text) {
+                        SDL_SendKeyboardText(0, text);
+                    }
+                }
+            }
+            break;
+        case DWET_KEYUP:
+            if (!devdata->use_linux_input) {
+                DirectFB_TranslateKey(_this, evt, &keysym);
+                SDL_SendKeyboardKey(0, SDL_RELEASED, keysym.scancode);
+            }
+            break;
+        case DWET_POSITION:
+            if (ClientXY(p, &evt->x, &evt->y)) {
+                SDL_SendWindowEvent(p->sdl_id, SDL_WINDOWEVENT_MOVED,
+                                    evt->x, evt->y);
+            }
+            break;
+        case DWET_POSITION_SIZE:
+            if (ClientXY(p, &evt->x, &evt->y)) {
+                SDL_SendWindowEvent(p->sdl_id, SDL_WINDOWEVENT_MOVED,
+                                    evt->x, evt->y);
+            }
+            /* fall throught */
+        case DWET_SIZE:
+            // FIXME: what about < 0
+            evt->w -= (p->theme.right_size + p->theme.left_size);
+            evt->h -=
+                (p->theme.top_size + p->theme.bottom_size +
+                 p->theme.caption_size);
+            SDL_SendWindowEvent(p->sdl_id, SDL_WINDOWEVENT_RESIZED,
+                                evt->w, evt->h);
+            break;
+        case DWET_CLOSE:
+            SDL_SendWindowEvent(p->sdl_id, SDL_WINDOWEVENT_CLOSE, 0, 0);
+            break;
+        case DWET_GOTFOCUS:
+            DirectFB_SetContext(_this, p->sdl_id);
+            FocusAllKeyboards(_this, p->sdl_id);
+            SDL_SendWindowEvent(p->sdl_id, SDL_WINDOWEVENT_FOCUS_GAINED,
+                                0, 0);
+            break;
+        case DWET_LOSTFOCUS:
+            SDL_SendWindowEvent(p->sdl_id, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);
+            FocusAllKeyboards(_this, 0);
+            break;
+        case DWET_ENTER:
+            /* SDL_DirectFB_ReshowCursor(_this, 0); */
+            FocusAllMice(_this, p->sdl_id);
+            // FIXME: when do we really enter ?
+            if (ClientXY(p, &evt->x, &evt->y))
+                MotionAllMice(_this, evt->x, evt->y);
+            SDL_SendWindowEvent(p->sdl_id, SDL_WINDOWEVENT_ENTER, 0, 0);
+            break;
+        case DWET_LEAVE:
+            SDL_SendWindowEvent(p->sdl_id, SDL_WINDOWEVENT_LEAVE, 0, 0);
+            FocusAllMice(_this, 0);
+            /* SDL_DirectFB_ReshowCursor(_this, 1); */
+            break;
+        default:
+            ;
+        }
+    } else
+        printf("Event Clazz %d\n", evt->clazz);
+}
+
+static void
+ProcessInputEvent(_THIS, Sint32 grabbed_window, DFBInputEvent * ievt)
+{
+    SDL_DFB_DEVICEDATA(_this);
+    SDL_keysym keysym;
+    int kbd_idx;
+    char text[5];
+
+    if (!devdata->use_linux_input) {
+        if (ievt->type == DIET_AXISMOTION) {
+            if ((grabbed_window >= 0) && (ievt->flags & DIEF_AXISREL)) {
+                if (ievt->axis == DIAI_X)
+                    SDL_SendMouseMotion(ievt->device_id, 1,
+                                        ievt->axisrel, 0, 0);
+                else if (ievt->axis == DIAI_Y)
+                    SDL_SendMouseMotion(ievt->device_id, 1, 0,
+                                        ievt->axisrel, 0);
+            }
+        }
+    } else {
+        static int last_x, last_y;
+
+        switch (ievt->type) {
+        case DIET_AXISMOTION:
+            if (ievt->flags & DIEF_AXISABS) {
+                if (ievt->axis == DIAI_X)
+                    last_x = ievt->axisabs;
+                else if (ievt->axis == DIAI_Y)
+                    last_y = ievt->axisabs;
+                if (!(ievt->flags & DIEF_FOLLOW)) {
+                    SDL_Mouse *mouse = SDL_GetMouse(ievt->device_id);
+                    SDL_Window *window = SDL_GetWindowFromID(mouse->focus);
+                    if (window) {
+                        DFB_WindowData *windata =
+                            (DFB_WindowData *) window->driverdata;
+                        int x, y;
+
+                        windata->window->GetPosition(windata->window, &x, &y);
+                        SDL_SendMouseMotion(ievt->device_id, 0,
+                                            last_x - (x +
+                                                      windata->client.x),
+                                            last_y - (y +
+                                                      windata->client.y), 0);
+                    } else {
+                        SDL_SendMouseMotion(ievt->device_id, 0, last_x,
+                                            last_y, 0);
+                    }
+                }
+            } else if (ievt->flags & DIEF_AXISREL) {
+                if (ievt->axis == DIAI_X)
+                    SDL_SendMouseMotion(ievt->device_id, 1,
+                                        ievt->axisrel, 0, 0);
+                else if (ievt->axis == DIAI_Y)
+                    SDL_SendMouseMotion(ievt->device_id, 1, 0,
+                                        ievt->axisrel, 0);
+            }
+            break;
+        case DIET_KEYPRESS:
+            kbd_idx = KbdIndex(_this, ievt->device_id);
+            DirectFB_TranslateKeyInputEvent(_this, kbd_idx, ievt, &keysym);
+            SDL_SendKeyboardKey(kbd_idx, SDL_PRESSED, keysym.scancode);
+            if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
+                SDL_memcpy(text, &keysym.unicode, 4);
+                text[4] = 0;
+                if (*text) {
+                    SDL_SendKeyboardText(kbd_idx, text);
+                }
+            }
+            break;
+        case DIET_KEYRELEASE:
+            kbd_idx = KbdIndex(_this, ievt->device_id);
+            DirectFB_TranslateKeyInputEvent(_this, kbd_idx, ievt, &keysym);
+            SDL_SendKeyboardKey(kbd_idx, SDL_RELEASED, keysym.scancode);
+            break;
+        case DIET_BUTTONPRESS:
+            if (ievt->buttons & DIBM_LEFT)
+                SDL_SendMouseButton(ievt->device_id, SDL_PRESSED, 1);
+            if (ievt->buttons & DIBM_MIDDLE)
+                SDL_SendMouseButton(ievt->device_id, SDL_PRESSED, 2);
+            if (ievt->buttons & DIBM_RIGHT)
+                SDL_SendMouseButton(ievt->device_id, SDL_PRESSED, 3);
+            break;
+        case DIET_BUTTONRELEASE:
+            if (!(ievt->buttons & DIBM_LEFT))
+                SDL_SendMouseButton(ievt->device_id, SDL_RELEASED, 1);
+            if (!(ievt->buttons & DIBM_MIDDLE))
+                SDL_SendMouseButton(ievt->device_id, SDL_RELEASED, 2);
+            if (!(ievt->buttons & DIBM_RIGHT))
+                SDL_SendMouseButton(ievt->device_id, SDL_RELEASED, 3);
+            break;
+        default:
+            break;              /* please gcc */
+        }
+    }
+}
+
 void
 DirectFB_PumpEventsWindow(_THIS)
 {
@@ -124,216 +372,28 @@
     DFB_WindowData *p;
     DFBInputEvent ievt;
     Sint32 /* SDL_WindowID */ grabbed_window;
-    char text[5];
-    int kbd_idx;
 
     grabbed_window = -1;
 
     for (p = devdata->firstwin; p != NULL; p = p->next) {
         DFBWindowEvent evt;
-        SDL_Window *w = SDL_GetWindowFromID(p->id);
+        SDL_Window *w = SDL_GetWindowFromID(p->sdl_id);
 
         if (w->flags & SDL_WINDOW_INPUT_GRABBED) {
-            grabbed_window = p->id;
+            grabbed_window = p->sdl_id;
         }
 
         while (p->eventbuffer->GetEvent(p->eventbuffer,
                                         DFB_EVENT(&evt)) == DFB_OK) {
-            SDL_keysym keysym;
-
-            if (evt.clazz == DFEC_WINDOW) {
-                switch (evt.type) {
-                case DWET_BUTTONDOWN:
-                    if (!devdata->use_linux_input) {
-                        SDL_SendMouseMotion(devdata->mouse_id[0], 0, evt.cx,
-                                            evt.cy, 0);
-                        SDL_SendMouseButton(devdata->mouse_id[0], SDL_PRESSED,
-                                            DirectFB_TranslateButton(evt.
-                                                                     button));
-                    } else {
-                        MotionAllMice(_this, evt.x, evt.y);
-                    }
-                    break;
-                case DWET_BUTTONUP:
-                    if (!devdata->use_linux_input) {
-                        SDL_SendMouseMotion(devdata->mouse_id[0], 0, evt.cx,
-                                            evt.cy, 0);
-                        SDL_SendMouseButton(devdata->mouse_id[0],
-                                            SDL_RELEASED,
-                                            DirectFB_TranslateButton(evt.
-                                                                     button));
-                    } else {
-                        MotionAllMice(_this, evt.x, evt.y);
-                    }
-                    break;
-                case DWET_MOTION:
-                    if (!devdata->use_linux_input) {
-                        if (!(w->flags & SDL_WINDOW_INPUT_GRABBED))
-                            SDL_SendMouseMotion(devdata->mouse_id[0], 0,
-                                                evt.cx, evt.cy, 0);
-                    } else {
-                        /* relative movements are not exact! 
-                         * This code should limit the number of events sent.
-                         * However it kills MAME axis recognition ... */
-                        static int cnt = 0;
-                        if (1 && ++cnt > 20) {
-                            MotionAllMice(_this, evt.x, evt.y);
-                            cnt = 0;
-                        }
-                    }
-                    break;
-                case DWET_KEYDOWN:
-                    if (!devdata->use_linux_input) {
-                        DirectFB_TranslateKey(_this, &evt, &keysym);
-                        SDL_SendKeyboardKey(0, SDL_PRESSED, keysym.scancode);
-                        if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
-                            SDL_memcpy(text, &keysym.unicode, 4);
-                            text[4] = 0;
-                            if (*text) {
-                                SDL_SendKeyboardText(0, text);
-                            }
-                        }
-                    }
-                    break;
-                case DWET_KEYUP:
-                    if (!devdata->use_linux_input) {
-                        DirectFB_TranslateKey(_this, &evt, &keysym);
-                        SDL_SendKeyboardKey(0, SDL_RELEASED, keysym.scancode);
-                    }
-                    break;
-                case DWET_POSITION_SIZE:
-                    if (evt.x != w->x || evt.y != w->y)
-                        SDL_SendWindowEvent(p->id, SDL_WINDOWEVENT_MOVED,
-                                            evt.x, evt.y);
-                    if (evt.w != w->w || evt.h != w->h)
-                        SDL_SendWindowEvent(p->id, SDL_WINDOWEVENT_RESIZED,
-                                            evt.w, evt.h);
-                    break;
-                case DWET_POSITION:
-                    if (evt.x != w->x || evt.y != w->y)
-                        SDL_SendWindowEvent(p->id, SDL_WINDOWEVENT_MOVED,
-                                            evt.x, evt.y);
-                    break;
-                case DWET_SIZE:
-                    if (evt.w != w->w || evt.h != w->h)
-                        SDL_SendWindowEvent(p->id, SDL_WINDOWEVENT_RESIZED,
-                                            evt.w, evt.h);
-                    break;
-                case DWET_CLOSE:
-                    SDL_SendWindowEvent(p->id, SDL_WINDOWEVENT_CLOSE, 0, 0);
-                    break;
-                case DWET_GOTFOCUS:
-                    DirectFB_SetContext(_this, p->id);
-                    FocusAllKeyboards(_this, p->id);
-                    SDL_SendWindowEvent(p->id, SDL_WINDOWEVENT_FOCUS_GAINED,
-                                        0, 0);
-                    break;
-                case DWET_LOSTFOCUS:
-                    SDL_SendWindowEvent(p->id, SDL_WINDOWEVENT_FOCUS_LOST, 0,
-                                        0);
-                    FocusAllKeyboards(_this, 0);
-                    break;
-                case DWET_ENTER:
-                    /* SDL_DirectFB_ReshowCursor(_this, 0); */
-                    FocusAllMice(_this, p->id);
-                    MotionAllMice(_this, evt.x, evt.y);
-                    SDL_SendWindowEvent(p->id, SDL_WINDOWEVENT_ENTER, 0, 0);
-                    break;
-                case DWET_LEAVE:
-                    SDL_SendWindowEvent(p->id, SDL_WINDOWEVENT_LEAVE, 0, 0);
-                    FocusAllMice(_this, 0);
-                    /* SDL_DirectFB_ReshowCursor(_this, 1); */
-                    break;
-                default:
-                    ;
-                }
-            } else
-                printf("Event Clazz %d\n", evt.clazz);
-
+            if (!DirectFB_WM_ProcessEvent(_this, w, &evt))
+                ProcessWindowEvent(_this, p, w->flags, &evt);
         }
     }
 
     /* Now get relative events in case we need them */
     while (devdata->events->GetEvent(devdata->events,
                                      DFB_EVENT(&ievt)) == DFB_OK) {
-        SDL_keysym keysym;
-
-        switch (ievt.type) {
-        case DIET_AXISMOTION:
-            if (!devdata->use_linux_input) {
-                if ((grabbed_window >= 0) && (ievt.flags & DIEF_AXISREL)) {
-                    printf("rel devid %d\n", ievt.device_id);
-                    if (ievt.axis == DIAI_X)
-                        SDL_SendMouseMotion(ievt.device_id, 1, ievt.axisrel,
-                                            0, 0);
-                    else if (ievt.axis == DIAI_Y)
-                        SDL_SendMouseMotion(ievt.device_id, 1, 0,
-                                            ievt.axisrel, 0);
-                }
-            }
-            break;
-        }
-        if (devdata->use_linux_input) {
-            IDirectFBInputDevice *idev;
-            static int last_x, last_y;
-
-            switch (ievt.type) {
-            case DIET_AXISMOTION:
-                if (ievt.flags & DIEF_AXISABS) {
-                    if (ievt.axis == DIAI_X)
-                        last_x = ievt.axisabs;
-                    else if (ievt.axis == DIAI_Y)
-                        last_y = ievt.axisabs;
-                    if (!(ievt.flags & DIEF_FOLLOW))
-                        SDL_SendMouseMotion(ievt.device_id, 0, last_x, last_y,
-                                            0);
-                } else if (ievt.flags & DIEF_AXISREL) {
-                    //printf("rel %d %d\n", ievt.device_id, ievt.axisrel);
-                    if (ievt.axis == DIAI_X)
-                        SDL_SendMouseMotion(ievt.device_id, 1, ievt.axisrel,
-                                            0, 0);
-                    else if (ievt.axis == DIAI_Y)
-                        SDL_SendMouseMotion(ievt.device_id, 1, 0,
-                                            ievt.axisrel, 0);
-                }
-                break;
-            case DIET_KEYPRESS:
-                kbd_idx = KbdIndex(_this, ievt.device_id);
-                DirectFB_TranslateKeyInputEvent(_this, kbd_idx, &ievt,
-                                                &keysym);
-                SDL_SendKeyboardKey(kbd_idx, SDL_PRESSED, keysym.scancode);
-                if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
-                    SDL_memcpy(text, &keysym.unicode, 4);
-                    text[4] = 0;
-                    if (*text) {
-                        SDL_SendKeyboardText(kbd_idx, text);
-                    }
-                }
-                break;
-            case DIET_KEYRELEASE:
-                kbd_idx = KbdIndex(_this, ievt.device_id);
-                DirectFB_TranslateKeyInputEvent(_this, kbd_idx, &ievt,
-                                                &keysym);
-                SDL_SendKeyboardKey(kbd_idx, SDL_RELEASED, keysym.scancode);
-                break;
-            case DIET_BUTTONPRESS:
-                if (ievt.buttons & DIBM_LEFT)
-                    SDL_SendMouseButton(ievt.device_id, SDL_PRESSED, 1);
-                if (ievt.buttons & DIBM_MIDDLE)
-                    SDL_SendMouseButton(ievt.device_id, SDL_PRESSED, 2);
-                if (ievt.buttons & DIBM_RIGHT)
-                    SDL_SendMouseButton(ievt.device_id, SDL_PRESSED, 3);
-                break;
-            case DIET_BUTTONRELEASE:
-                if (!(ievt.buttons & DIBM_LEFT))
-                    SDL_SendMouseButton(ievt.device_id, SDL_RELEASED, 1);
-                if (!(ievt.buttons & DIBM_MIDDLE))
-                    SDL_SendMouseButton(ievt.device_id, SDL_RELEASED, 2);
-                if (!(ievt.buttons & DIBM_RIGHT))
-                    SDL_SendMouseButton(ievt.device_id, SDL_RELEASED, 3);
-                break;
-            }
-        }
+        ProcessInputEvent(_this, grabbed_window, &ievt);
     }
 }
 
@@ -470,14 +530,14 @@
 {
     SDL_DFB_DEVICEDATA(_this);
 
-    if (evt->key_code >= 0
-        && evt->key_code < SDL_arraysize(linux_scancode_table))
+    if (evt->key_code >= 0 &&
+        evt->key_code < SDL_arraysize(linux_scancode_table))
         keysym->scancode = linux_scancode_table[evt->key_code];
     else
         keysym->scancode = SDL_SCANCODE_UNKNOWN;
 
-    if (keysym->scancode == SDL_SCANCODE_UNKNOWN
-        || devdata->keyboard[0].is_generic) {
+    if (keysym->scancode == SDL_SCANCODE_UNKNOWN ||
+        devdata->keyboard[0].is_generic) {
         if (evt->key_id - DIKI_UNKNOWN < SDL_arraysize(oskeymap))
             keysym->scancode = oskeymap[evt->key_id - DIKI_UNKNOWN];
         else
@@ -486,8 +546,8 @@
 
     keysym->unicode =
         (DFB_KEY_TYPE(evt->key_symbol) == DIKT_UNICODE) ? evt->key_symbol : 0;
-    if (keysym->unicode == 0
-        && (evt->key_symbol > 0 && evt->key_symbol < 255))
+    if (keysym->unicode == 0 &&
+        (evt->key_symbol > 0 && evt->key_symbol < 255))
         keysym->unicode = evt->key_symbol;
 
     return keysym;
@@ -499,14 +559,14 @@
 {
     SDL_DFB_DEVICEDATA(_this);
 
-    if (evt->key_code >= 0
-        && evt->key_code < SDL_arraysize(linux_scancode_table))
+    if (evt->key_code >= 0 &&
+        evt->key_code < SDL_arraysize(linux_scancode_table))
         keysym->scancode = linux_scancode_table[evt->key_code];
     else
         keysym->scancode = SDL_SCANCODE_UNKNOWN;
 
-    if (keysym->scancode == SDL_SCANCODE_UNKNOWN
-        || devdata->keyboard[index].is_generic) {
+    if (keysym->scancode == SDL_SCANCODE_UNKNOWN ||
+        devdata->keyboard[index].is_generic) {
         if (evt->key_id - DIKI_UNKNOWN < SDL_arraysize(oskeymap))
             keysym->scancode = oskeymap[evt->key_id - DIKI_UNKNOWN];
         else
@@ -515,12 +575,13 @@
 
     keysym->unicode =
         (DFB_KEY_TYPE(evt->key_symbol) == DIKT_UNICODE) ? evt->key_symbol : 0;
-    if (keysym->unicode == 0
-        && (evt->key_symbol > 0 && evt->key_symbol < 255))
+    if (keysym->unicode == 0 &&
+        (evt->key_symbol > 0 && evt->key_symbol < 255))
         keysym->unicode = evt->key_symbol;
 
     return keysym;
 }
+
 static int
 DirectFB_TranslateButton(DFBInputDeviceButtonIdentifier button)
 {
@@ -537,8 +598,8 @@
 }
 
 static DFBEnumerationResult
-input_device_cb(DFBInputDeviceID device_id, DFBInputDeviceDescription desc,
-                void *callbackdata)
+input_device_cb(DFBInputDeviceID device_id,
+                DFBInputDeviceDescription desc, void *callbackdata)
 {
     DFB_DeviceData *devdata = callbackdata;
     SDL_Keyboard keyboard;
@@ -562,8 +623,8 @@
 }
 
 static DFBEnumerationResult
-EnumKeyboards(DFBInputDeviceID device_id, DFBInputDeviceDescription desc,
-              void *callbackdata)
+EnumKeyboards(DFBInputDeviceID device_id,
+              DFBInputDeviceDescription desc, void *callbackdata)
 {
     DFB_DeviceData *devdata = callbackdata;
     SDL_Keyboard keyboard;
@@ -606,14 +667,14 @@
                       EnumInputDevices(devdata->dfb, EnumKeyboards, devdata));
         if (devdata->num_keyboard == 0) {
             sys_ids = 1;
-            SDL_DFB_CHECK(devdata->dfb->
-                          EnumInputDevices(devdata->dfb, EnumKeyboards,
-                                           devdata));
+            SDL_DFB_CHECK(devdata->dfb->EnumInputDevices(devdata->dfb,
+                                                         EnumKeyboards,
+                                                         devdata));
         }
     } else {
-        SDL_DFB_CHECK(devdata->dfb->
-                      EnumInputDevices(devdata->dfb, input_device_cb,
-                                       devdata));
+        SDL_DFB_CHECK(devdata->dfb->EnumInputDevices(devdata->dfb,
+                                                     input_device_cb,
+                                                     devdata));
     }
 }
 
@@ -649,34 +710,30 @@
 
             switch (evt.type) {
             case DIET_BUTTONPRESS:
-                posted += SDL_PrivateMouseButton(SDL_PRESSED,
-                                                 DirectFB_TranslateButton(evt.
-                                                                          button),
-                                                 0, 0);
+                posted +=
+                    SDL_PrivateMouseButton(SDL_PRESSED,
+                                           DirectFB_TranslateButton
+                                           (evt.button), 0, 0);
                 break;
             case DIET_BUTTONRELEASE:
-                posted += SDL_PrivateMouseButton(SDL_RELEASED,
-                                                 DirectFB_TranslateButton(evt.
-                                                                          button),
-                                                 0, 0);
+                posted +=
+                    SDL_PrivateMouseButton(SDL_RELEASED,
+                                           DirectFB_TranslateButton
+                                           (evt.button), 0, 0);
                 break;
             case DIET_KEYPRESS:
-                posted += SDL_PrivateKeyboard(SDL_PRESSED,
-                                              DirectFB_TranslateKey(evt.
-                                                                    key_id,
-                                                                    evt.
-                                                                    key_symbol,
-                                                                    mod,
-                                                                    &keysym));
+                posted +=
+                    SDL_PrivateKeyboard(SDL_PRESSED,
+                                        DirectFB_TranslateKey
+                                        (evt.key_id, evt.key_symbol,
+                                         mod, &keysym));
                 break;
             case DIET_KEYRELEASE:
-                posted += SDL_PrivateKeyboard(SDL_RELEASED,
-                                              DirectFB_TranslateKey(evt.
-                                                                    key_id,
-                                                                    evt.
-                                                                    key_symbol,
-                                                                    mod,
-                                                                    &keysym));
+                posted +=
+                    SDL_PrivateKeyboard(SDL_RELEASED,
+                                        DirectFB_TranslateKey
+                                        (evt.key_id, evt.key_symbol,
+                                         mod, &keysym));
                 break;
             case DIET_AXISMOTION:
                 if (evt.flags & DIEF_AXISREL) {
--- a/src/video/directfb/SDL_DirectFB_modes.c	Sun Jan 11 23:39:11 2009 +0000
+++ b/src/video/directfb/SDL_DirectFB_modes.c	Sun Jan 11 23:49:23 2009 +0000
@@ -204,8 +204,8 @@
     DFBDisplayLayerConfigFlags failed;
     int ret;
 
-    SDL_DFB_CHECKERR(data->layer->
-                     SetCooperativeLevel(data->layer, DLSCL_ADMINISTRATIVE));
+    SDL_DFB_CHECKERR(data->layer->SetCooperativeLevel(data->layer,
+                                                      DLSCL_ADMINISTRATIVE));
     config.width = mode->w;
     config.height = mode->h;
     config.pixelformat = SDLToDFBPixelFormat(mode->format);
@@ -216,13 +216,13 @@
     }
     failed = 0;
     data->layer->TestConfiguration(data->layer, &config, &failed);
-    SDL_DFB_CHECKERR(data->layer->
-                     SetCooperativeLevel(data->layer, DLSCL_SHARED));
+    SDL_DFB_CHECKERR(data->layer->SetCooperativeLevel(data->layer,
+                                                      DLSCL_SHARED));
     if (failed == 0)
         SDL_AddDisplayMode(_this->current_display, mode);
     else
-        SDL_DFB_DEBUG("Mode %d x %d not available: %x\n", mode->w, mode->h,
-                      failed);
+        SDL_DFB_DEBUG("Mode %d x %d not available: %x\n", mode->w,
+                      mode->h, failed);
 
     return;
   error:
@@ -235,13 +235,9 @@
     SDL_DFB_DEVICEDATA(_this);
     IDirectFBDisplayLayer *layer = NULL;
     SDL_VideoDisplay display;
-    DFB_DisplayData *dispdata;
+    DFB_DisplayData *dispdata = NULL;
     SDL_DisplayMode mode;
-#if (DIRECTFB_MAJOR_VERSION == 0) && (DIRECTFB_MINOR_VERSION == 9) && (DIRECTFB_MICRO_VERSION < 23)
-    DFBCardCapabilities caps;
-#else
     DFBGraphicsDeviceDescription caps;
-#endif
     DFBDisplayLayerConfig dlc;
     struct scn_callback_t *screencbdata;
 
@@ -259,28 +255,20 @@
         screencbdata->vidlayer[i] = -1;
     }
 
-    SDL_DFB_CHECKERR(devdata->dfb->
-                     EnumScreens(devdata->dfb, &cbScreens, screencbdata));
+    SDL_DFB_CHECKERR(devdata->dfb->EnumScreens(devdata->dfb, &cbScreens,
+                                               screencbdata));
 
     for (i = 0; i < screencbdata->numscreens; i++) {
         IDirectFBScreen *screen;
 
-        SDL_DFB_CHECKERR(devdata->dfb->
-                         GetScreen(devdata->dfb, screencbdata->screenid[i],
-                                   &screen));
+        SDL_DFB_CHECKERR(devdata->dfb->GetScreen(devdata->dfb,
+                                                 screencbdata->screenid
+                                                 [i], &screen));
 
         screencbdata->aux = i;
-        SDL_DFB_CHECKERR(screen->
-                         EnumDisplayLayers(screen, &cbLayers, screencbdata));
-#if (DIRECTFB_MAJOR_VERSION >= 1)
+        SDL_DFB_CHECKERR(screen->EnumDisplayLayers(screen, &cbLayers,
+                                                   screencbdata));
         screen->GetSize(screen, &tcw[i], &tch[i]);
-#else
-        /* FIXME: this is only used to center windows
-         *        Should be done otherwise, e.g. get surface from layer
-         */
-        tcw[i] = 800;
-        tch[i] = 600;
-#endif
         screen->Release(screen);
     }
 
@@ -293,12 +281,12 @@
     SDL_DFB_DEBUG("Found %d screens\n", screencbdata->numscreens);
 
     for (i = 0; i < screencbdata->numscreens; i++) {
-        SDL_DFB_CHECKERR(devdata->dfb->
-                         GetDisplayLayer(devdata->dfb,
-                                         screencbdata->gralayer[i], &layer));
+        SDL_DFB_CHECKERR(devdata->dfb->GetDisplayLayer(devdata->dfb,
+                                                       screencbdata->gralayer
+                                                       [i], &layer));
 
-        SDL_DFB_CHECKERR(layer->
-                         SetCooperativeLevel(layer, DLSCL_ADMINISTRATIVE));
+        SDL_DFB_CHECKERR(layer->SetCooperativeLevel(layer,
+                                                    DLSCL_ADMINISTRATIVE));
         layer->EnableCursor(layer, 1);
         SDL_DFB_CHECKERR(layer->SetCursorOpacity(layer, 0xC0));
 
@@ -381,8 +369,8 @@
     data.nummodes = 0;
     /* Enumerate the available fullscreen modes */
     SDL_DFB_CALLOC(data.modelist, DFB_MAX_MODES, sizeof(SDL_DisplayMode));
-    SDL_DFB_CHECKERR(devdata->dfb->
-                     EnumVideoModes(devdata->dfb, EnumModesCallback, &data));
+    SDL_DFB_CHECKERR(devdata->dfb->EnumVideoModes(devdata->dfb,
+                                                  EnumModesCallback, &data));
 
     for (i = 0; i < data.nummodes; ++i) {
         mode = data.modelist[i];
@@ -419,8 +407,8 @@
     DFBDisplayLayerConfigFlags fail = 0;
     DFBResult ret;
 
-    SDL_DFB_CHECKERR(data->layer->
-                     SetCooperativeLevel(data->layer, DLSCL_ADMINISTRATIVE));
+    SDL_DFB_CHECKERR(data->layer->SetCooperativeLevel(data->layer,
+                                                      DLSCL_ADMINISTRATIVE));
 
     SDL_DFB_CHECKERR(data->layer->GetConfiguration(data->layer, &config));
     config.flags = DLCONF_WIDTH | DLCONF_HEIGHT;
@@ -440,8 +428,8 @@
     data->layer->TestConfiguration(data->layer, &config, &fail);
 
     if (fail &
-        (DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT | DLCONF_OPTIONS))
-    {
+        (DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT |
+         DLCONF_OPTIONS)) {
         SDL_DFB_ERR("Error setting mode %dx%d-%x\n", mode->w, mode->h,
                     mode->format);
         return -1;
@@ -453,18 +441,16 @@
 #if (DIRECTFB_MAJOR_VERSION == 1) && (DIRECTFB_MINOR_VERSION >= 2)
     /* Need to call this twice ! */
     SDL_DFB_CHECKERR(data->layer->SetConfiguration(data->layer, &config));
-    //SDL_DFB_CHECKERR(data->layer->SetSourceRectangle(data->layer, 0, 0, config.width, config.height));
 #endif
 
     /* Double check */
     SDL_DFB_CHECKERR(data->layer->GetConfiguration(data->layer, &rconfig));
-    SDL_DFB_CHECKERR(data->layer->
-                     SetCooperativeLevel(data->layer, DLSCL_SHARED));
+    SDL_DFB_CHECKERR(data->
+                     layer->SetCooperativeLevel(data->layer, DLSCL_SHARED));
 
-    if ((config.width != rconfig.width) ||
-        (config.height != rconfig.height) ||
-        ((mode->format != SDL_PIXELFORMAT_UNKNOWN)
-         && (config.pixelformat != rconfig.pixelformat))) {
+    if ((config.width != rconfig.width) || (config.height != rconfig.height)
+        || ((mode->format != SDL_PIXELFORMAT_UNKNOWN)
+            && (config.pixelformat != rconfig.pixelformat))) {
         SDL_DFB_ERR("Error setting mode %dx%d-%x\n", mode->w, mode->h,
                     mode->format);
         return -1;
@@ -483,7 +469,7 @@
 void
 DirectFB_QuitModes(_THIS)
 {
-    DFB_DeviceData *devdata = (DFB_DeviceData *) _this->driverdata;
+    //DFB_DeviceData *devdata = (DFB_DeviceData *) _this->driverdata;
     SDL_DisplayMode tmode;
     DFBResult ret;
     int i;
@@ -502,13 +488,14 @@
             (DFB_DisplayData *) _this->displays[i].driverdata;
 
         if (dispdata->layer) {
-            SDL_DFB_CHECK(dispdata->layer->
-                          SetCooperativeLevel(dispdata->layer,
-                                              DLSCL_ADMINISTRATIVE));
-            SDL_DFB_CHECK(dispdata->layer->
-                          SetCursorOpacity(dispdata->layer, 0x00));
-            SDL_DFB_CHECK(dispdata->layer->
-                          SetCooperativeLevel(dispdata->layer, DLSCL_SHARED));
+            SDL_DFB_CHECK(dispdata->
+                          layer->SetCooperativeLevel(dispdata->layer,
+                                                     DLSCL_ADMINISTRATIVE));
+            SDL_DFB_CHECK(dispdata->
+                          layer->SetCursorOpacity(dispdata->layer, 0x00));
+            SDL_DFB_CHECK(dispdata->
+                          layer->SetCooperativeLevel(dispdata->layer,
+                                                     DLSCL_SHARED));
         }
 
         SDL_DFB_RELEASE(dispdata->layer);
--- a/src/video/directfb/SDL_DirectFB_mouse.c	Sun Jan 11 23:39:11 2009 +0000
+++ b/src/video/directfb/SDL_DirectFB_mouse.c	Sun Jan 11 23:49:23 2009 +0000
@@ -26,8 +26,8 @@
 #include "../SDL_sysvideo.h"
 #include "../../events/SDL_mouse_c.h"
 
-static SDL_Cursor *DirectFB_CreateCursor(SDL_Surface * surface, int hot_x,
-                                         int hot_y);
+static SDL_Cursor *DirectFB_CreateCursor(SDL_Surface * surface,
+                                         int hot_x, int hot_y);
 static int DirectFB_ShowCursor(SDL_Cursor * cursor);
 static void DirectFB_MoveCursor(SDL_Cursor * cursor);
 static void DirectFB_FreeCursor(SDL_Cursor * cursor);
@@ -38,8 +38,8 @@
 static int id_mask;
 
 static DFBEnumerationResult
-EnumMice(DFBInputDeviceID device_id,
-         DFBInputDeviceDescription desc, void *callbackdata)
+EnumMice(DFBInputDeviceID device_id, DFBInputDeviceDescription desc,
+         void *callbackdata)
 {
     DFB_DeviceData *devdata = callbackdata;
 
@@ -132,20 +132,20 @@
     dsc.height = surface->h;
     dsc.pixelformat = DSPF_ARGB;
 
-    SDL_DFB_CHECKERR(devdata->dfb->
-                     CreateSurface(devdata->dfb, &dsc, &curdata->surf));
+    SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc,
+                                                 &curdata->surf));
     curdata->hotx = hot_x;
     curdata->hoty = hot_y;
     cursor->driverdata = curdata;
 
-    SDL_DFB_CHECKERR(curdata->surf->
-                     Lock(curdata->surf, DSLF_WRITE, (void *) &dest, &pitch));
+    SDL_DFB_CHECKERR(curdata->surf->Lock(curdata->surf, DSLF_WRITE,
+                                         (void *) &dest, &pitch));
 
     /* Relies on the fact that this is only called with ARGB surface. */
     p = surface->pixels;
     for (i = 0; i < surface->h; i++)
-        memcpy((char *) dest + i * pitch, (char *) p + i * surface->pitch,
-               4 * surface->w);
+        memcpy((char *) dest + i * pitch,
+               (char *) p + i * surface->pitch, 4 * surface->w);
 
     curdata->surf->Unlock(curdata->surf);
     return cursor;
@@ -162,7 +162,7 @@
     SDL_WindowID wid;
 
     wid = SDL_GetFocusWindow();
-    if (wid < 0)
+    if (wid <= 0)
         return -1;
     else {
         SDL_Window *window = SDL_GetWindowFromID(wid);
@@ -179,7 +179,6 @@
                                                 curdata->surf, curdata->hotx,
                                                 curdata->hoty));
 
-            /* fprintf(stdout, "Cursor is %s\n", cursor ? "on" : "off"); */
             SDL_DFB_CHECKERR(dispdata->layer->
                              SetCooperativeLevel(dispdata->layer,
                                                  DLSCL_ADMINISTRATIVE));
@@ -227,8 +226,9 @@
     int cx, cy;
 
     SDL_DFB_CHECKERR(windata->window->GetPosition(windata->window, &cx, &cy));
-    SDL_DFB_CHECKERR(dispdata->layer->
-                     WarpCursor(dispdata->layer, cx + x, cy + y));
+    SDL_DFB_CHECKERR(dispdata->layer->WarpCursor(dispdata->layer,
+                                                 cx + x + windata->client.x,
+                                                 cy + y + windata->client.y));
 
   error:
     return;
--- a/src/video/directfb/SDL_DirectFB_opengl.c	Sun Jan 11 23:39:11 2009 +0000
+++ b/src/video/directfb/SDL_DirectFB_opengl.c	Sun Jan 11 23:49:23 2009 +0000
@@ -173,8 +173,8 @@
 
     SDL_DFB_CALLOC(context, 1, sizeof(*context));
 
-    SDL_DFB_CHECKERR(windata->surface->
-                     GetGL(windata->surface, &context->context));
+    SDL_DFB_CHECKERR(windata->surface->GetGL(windata->surface,
+                                             &context->context));
 
     if (!context->context)
         return NULL;
@@ -208,16 +208,9 @@
         p->context->Unlock(p->context);
 
     if (windata) {
-        int cw, ch;
-
         windata->gl_context = NULL;
         /* Everything is unlocked, check for a resize */
-        SDL_DFB_CHECKERR(windata->surface->
-                         GetSize(windata->surface, &cw, &ch));
-        if (cw != window->w || ch != window->h)
-            SDL_DFB_CHECKERR(windata->window->
-                             ResizeSurface(windata->window, window->w,
-                                           window->h));
+        DirectFB_AdjustWindowSurface(window);
     }
 
     if (ctx != NULL) {
@@ -266,8 +259,8 @@
 
     if (1 || windata->gl_context) {
         /* SDL_DFB_CHECKERR(windata->gl_context->context->Unlock(windata->gl_context->context)); */
-        SDL_DFB_CHECKERR(windata->surface->
-                         Flip(windata->surface, &region, DSFLIP_ONSYNC));
+        SDL_DFB_CHECKERR(windata->surface->Flip(windata->surface, &region,
+                                                DSFLIP_ONSYNC));
         /* SDL_DFB_CHECKERR(windata->gl_context->context->Lock(windata->gl_context->context)); */
 
     }
--- a/src/video/directfb/SDL_DirectFB_render.c	Sun Jan 11 23:39:11 2009 +0000
+++ b/src/video/directfb/SDL_DirectFB_render.c	Sun Jan 11 23:49:23 2009 +0000
@@ -41,16 +41,16 @@
 static int DirectFB_CreateTexture(SDL_Renderer * renderer,
                                   SDL_Texture * texture);
 static int DirectFB_QueryTexturePixels(SDL_Renderer * renderer,
-                                       SDL_Texture * texture, void **pixels,
-                                       int *pitch);
+                                       SDL_Texture * texture,
+                                       void **pixels, int *pitch);
 static int DirectFB_SetTexturePalette(SDL_Renderer * renderer,
                                       SDL_Texture * texture,
                                       const SDL_Color * colors,
                                       int firstcolor, int ncolors);
 static int DirectFB_GetTexturePalette(SDL_Renderer * renderer,
                                       SDL_Texture * texture,
-                                      SDL_Color * colors, int firstcolor,
-                                      int ncolors);
+                                      SDL_Color * colors,
+                                      int firstcolor, int ncolors);
 static int DirectFB_SetTextureAlphaMod(SDL_Renderer * renderer,
                                        SDL_Texture * texture);
 static int DirectFB_SetTextureColorMod(SDL_Renderer * renderer,
@@ -61,11 +61,12 @@
                                         SDL_Texture * texture);
 static int DirectFB_UpdateTexture(SDL_Renderer * renderer,
                                   SDL_Texture * texture,
-                                  const SDL_Rect * rect, const void *pixels,
-                                  int pitch);
+                                  const SDL_Rect * rect,
+                                  const void *pixels, int pitch);
 static int DirectFB_LockTexture(SDL_Renderer * renderer,
-                                SDL_Texture * texture, const SDL_Rect * rect,
-                                int markDirty, void **pixels, int *pitch);
+                                SDL_Texture * texture,
+                                const SDL_Rect * rect, int markDirty,
+                                void **pixels, int *pitch);
 static void DirectFB_UnlockTexture(SDL_Renderer * renderer,
                                    SDL_Texture * texture);
 static void DirectFB_DirtyTexture(SDL_Renderer * renderer,
@@ -76,7 +77,8 @@
                                int x2, int y2);
 static int DirectFB_RenderFill(SDL_Renderer * renderer,
                                const SDL_Rect * rect);
-static int DirectFB_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
+static int DirectFB_RenderCopy(SDL_Renderer * renderer,
+                               SDL_Texture * texture,
                                const SDL_Rect * srcrect,
                                const SDL_Rect * dstrect);
 static void DirectFB_RenderPresent(SDL_Renderer * renderer);
@@ -94,8 +96,8 @@
       SDL_RENDERER_ACCELERATED),
      (SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
       SDL_TEXTUREMODULATE_ALPHA),
-     (SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK |
-      SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),
+     (SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK | SDL_BLENDMODE_BLEND |
+      SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),
      (SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_FAST |
       SDL_TEXTURESCALEMODE_SLOW | SDL_TEXTURESCALEMODE_BEST),
      14,
@@ -327,7 +329,7 @@
         renderer->info.flags |= SDL_RENDERER_SINGLEBUFFER;
 
     data->isyuvdirect = 0;      /* default is off! */
-    p = getenv(DFBENV_USE_YUV_DIRECT);
+    p = SDL_getenv(DFBENV_USE_YUV_DIRECT);
     if (p)
         data->isyuvdirect = atoi(p);
 
@@ -414,20 +416,10 @@
     SDL_Window *window = SDL_GetWindowFromID(renderer->window);
     SDL_DFB_WINDOWDATA(window);
 
-    if (renddata->size_changed) {
-        int cw, ch;
-        int ret;
-
-        SDL_DFB_CHECKERR(windata->surface->
-                         GetSize(windata->surface, &cw, &ch));
-        if (cw != window->w || ch != window->h)
-            SDL_DFB_CHECKERR(windata->window->
-                             ResizeSurface(windata->window, window->w,
-                                           window->h));
+    if (renddata->size_changed || windata->wm_needs_redraw) {
+        DirectFB_AdjustWindowSurface(window);
     }
     return 0;
-  error:
-    return -1;
 }
 
 static int
@@ -462,22 +454,24 @@
         layconf.pixelformat = SDLToDFBPixelFormat(data->format);
         layconf.surface_caps = DSCAPS_VIDEOONLY | DSCAPS_DOUBLE;
 
-        SDL_DFB_CHECKERR(devdata->dfb->
-                         GetDisplayLayer(devdata->dfb, dispdata->vidID,
-                                         &dispdata->vidlayer));
-        SDL_DFB_CHECKERR(dispdata->vidlayer->
-                         SetCooperativeLevel(dispdata->vidlayer,
-                                             DLSCL_EXCLUSIVE));
+        SDL_DFB_CHECKERR(devdata->dfb->GetDisplayLayer(devdata->dfb,
+                                                       dispdata->vidID,
+                                                       &dispdata->vidlayer));
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->SetCooperativeLevel(dispdata->vidlayer,
+                                                       DLSCL_EXCLUSIVE));
 
         if (devdata->use_yuv_underlays) {
             ret = dispdata->vidlayer->SetLevel(dispdata->vidlayer, -1);
             if (ret != DFB_OK)
                 SDL_DFB_DEBUG("Underlay Setlevel not supported\n");
         }
-        SDL_DFB_CHECKERR(dispdata->vidlayer->
-                         SetConfiguration(dispdata->vidlayer, &layconf));
-        SDL_DFB_CHECKERR(dispdata->vidlayer->
-                         GetSurface(dispdata->vidlayer, &data->surface));
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->SetConfiguration(dispdata->vidlayer,
+                                                    &layconf));
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->GetSurface(dispdata->vidlayer,
+                                              &data->surface));
         dispdata->vidIDinuse = 1;
         data->display = display;
         return 0;
@@ -486,9 +480,9 @@
   error:
     if (dispdata->vidlayer) {
         SDL_DFB_RELEASE(data->surface);
-        SDL_DFB_CHECKERR(dispdata->vidlayer->
-                         SetCooperativeLevel(dispdata->vidlayer,
-                                             DLSCL_ADMINISTRATIVE));
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->SetCooperativeLevel(dispdata->vidlayer,
+                                                       DLSCL_ADMINISTRATIVE));
         SDL_DFB_RELEASE(dispdata->vidlayer);
     }
     return 1;
@@ -540,12 +534,12 @@
         data->pixels = NULL;
 
         /* Create the surface */
-        SDL_DFB_CHECKERR(devdata->dfb->
-                         CreateSurface(devdata->dfb, &dsc, &data->surface));
+        SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc,
+                                                     &data->surface));
         if (SDL_ISPIXELFORMAT_INDEXED(data->format)
             && !SDL_ISPIXELFORMAT_FOURCC(data->format)) {
-            SDL_DFB_CHECKERR(data->surface->
-                             GetPalette(data->surface, &data->palette));
+            SDL_DFB_CHECKERR(data->surface->GetPalette(data->surface,
+                                                       &data->palette));
         }
 
     }
@@ -568,8 +562,8 @@
 }
 
 static int
-DirectFB_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
-                            void **pixels, int *pitch)
+DirectFB_QueryTexturePixels(SDL_Renderer * renderer,
+                            SDL_Texture * texture, void **pixels, int *pitch)
 {
     DirectFB_TextureData *texturedata =
         (DirectFB_TextureData *) texture->driverdata;
@@ -584,7 +578,8 @@
 }
 
 static int
-DirectFB_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
+DirectFB_SetTexturePalette(SDL_Renderer * renderer,
+                           SDL_Texture * texture,
                            const SDL_Color * colors, int firstcolor,
                            int ncolors)
 {
@@ -602,9 +597,9 @@
             entries[i].b = colors[i].b;
             entries[i].a = 0xFF;
         }
-        SDL_DFB_CHECKERR(data->palette->
-                         SetEntries(data->palette, entries, ncolors,
-                                    firstcolor));
+        SDL_DFB_CHECKERR(data->
+                         palette->SetEntries(data->palette, entries, ncolors,
+                                             firstcolor));
         return 0;
     } else {
         SDL_SetError("YUV textures don't have a palette");
@@ -615,8 +610,9 @@
 }
 
 static int
-DirectFB_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
-                           SDL_Color * colors, int firstcolor, int ncolors)
+DirectFB_GetTexturePalette(SDL_Renderer * renderer,
+                           SDL_Texture * texture, SDL_Color * colors,
+                           int firstcolor, int ncolors)
 {
     DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
     DFBResult ret;
@@ -626,9 +622,9 @@
         DFBColor entries[256];
         int i;
 
-        SDL_DFB_CHECKERR(data->palette->
-                         GetEntries(data->palette, entries, ncolors,
-                                    firstcolor));
+        SDL_DFB_CHECKERR(data->
+                         palette->GetEntries(data->palette, entries, ncolors,
+                                             firstcolor));
 
         for (i = 0; i < ncolors; ++i) {
             colors[i].r = entries[i].r;
@@ -737,8 +733,8 @@
 
 static int
 DirectFB_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
-                     const SDL_Rect * rect, int markDirty, void **pixels,
-                     int *pitch)
+                     const SDL_Rect * rect, int markDirty,
+                     void **pixels, int *pitch)
 {
     DirectFB_TextureData *texturedata =
         (DirectFB_TextureData *) texture->driverdata;
@@ -807,8 +803,8 @@
     a = renderer->a;
 
     SetBlendMode(data, renderer->blendMode, NULL);
-    SDL_DFB_CHECKERR(data->surface->
-                     SetDrawingFlags(data->surface, data->drawFlags));
+    SDL_DFB_CHECKERR(data->surface->SetDrawingFlags(data->surface,
+                                                    data->drawFlags));
 
     switch (renderer->blendMode) {
     case SDL_BLENDMODE_NONE:
@@ -868,9 +864,9 @@
     DFBResult ret;
 
     PrepareDraw(renderer);
-    SDL_DFB_CHECKERR(data->surface->
-                     FillRectangle(data->surface, rect->x, rect->y, rect->w,
-                                   rect->h));
+    SDL_DFB_CHECKERR(data->
+                     surface->FillRectangle(data->surface, rect->x, rect->y,
+                                            rect->w, rect->h));
 
     return 0;
   error:
@@ -894,15 +890,20 @@
         SDL_VideoDisplay *display = texturedata->display;
         DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata;
 
-        SDL_DFB_CHECKERR(dispdata->vidlayer->
-                         SetSourceRectangle(dispdata->vidlayer, srcrect->x,
-                                            srcrect->y, srcrect->w,
-                                            srcrect->h));
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->SetSourceRectangle(dispdata->vidlayer,
+                                                      srcrect->x, srcrect->y,
+                                                      srcrect->w,
+                                                      srcrect->h));
         windata->window->GetPosition(windata->window, &px, &py);
-        SDL_DFB_CHECKERR(dispdata->vidlayer->
-                         SetScreenRectangle(dispdata->vidlayer,
-                                            px + dstrect->x, py + dstrect->y,
-                                            dstrect->w, dstrect->h));
+        px += windata->client.x;
+        py += windata->client.y;
+        SDL_DFB_CHECKERR(dispdata->
+                         vidlayer->SetScreenRectangle(dispdata->vidlayer,
+                                                      px + dstrect->x,
+                                                      py + dstrect->y,
+                                                      dstrect->w,
+                                                      dstrect->h));
     } else {
         DFBRectangle sr, dr;
         DFBSurfaceBlittingFlags flags = 0;
@@ -928,34 +929,37 @@
         SDLtoDFBRect(srcrect, &sr);
         SDLtoDFBRect(dstrect, &dr);
 
-        SDL_DFB_CHECKERR(data->surface->SetColor(data->surface, 0xFF,
-                                                 0xFF, 0xFF, 0xFF));
-        if (texture->
-            modMode & (SDL_TEXTUREMODULATE_COLOR | SDL_TEXTUREMODULATE_ALPHA))
-        {
+        SDL_DFB_CHECKERR(data->
+                         surface->SetColor(data->surface, 0xFF, 0xFF, 0xFF,
+                                           0xFF));
+        if (texture->modMode &
+            (SDL_TEXTUREMODULATE_COLOR | SDL_TEXTUREMODULATE_ALPHA)) {
             if (texture->modMode & SDL_TEXTUREMODULATE_ALPHA) {
                 alpha = texture->a;
-                SDL_DFB_CHECKERR(data->surface->SetColor(data->surface, 0xFF,
-                                                         0xFF, 0xFF, alpha));
+                SDL_DFB_CHECKERR(data->
+                                 surface->SetColor(data->surface, 0xFF, 0xFF,
+                                                   0xFF, alpha));
             }
             if (texture->modMode & SDL_TEXTUREMODULATE_COLOR) {
 
-                SDL_DFB_CHECKERR(data->surface->
-                                 SetColor(data->surface, texture->r,
-                                          texture->g, texture->b, alpha));
+                SDL_DFB_CHECKERR(data->surface->SetColor(data->surface,
+                                                         texture->r,
+                                                         texture->g,
+                                                         texture->b, alpha));
                 flags |= DSBLIT_COLORIZE;
             }
             if (alpha < 0xFF)
                 flags |= DSBLIT_SRC_PREMULTCOLOR;
         } else
-            SDL_DFB_CHECKERR(data->surface->SetColor(data->surface, 0xFF,
-                                                     0xFF, 0xFF, 0xFF));
+            SDL_DFB_CHECKERR(data->
+                             surface->SetColor(data->surface, 0xFF, 0xFF,
+                                               0xFF, 0xFF));
 
         SetBlendMode(data, texture->blendMode, texturedata);
 
-        SDL_DFB_CHECKERR(data->surface->
-                         SetBlittingFlags(data->surface,
-                                          data->blitFlags | flags));
+        SDL_DFB_CHECKERR(data->surface->SetBlittingFlags(data->surface,
+                                                         data->blitFlags
+                                                         | flags));
 
 #if (DIRECTFB_MAJOR_VERSION == 1) && (DIRECTFB_MINOR_VERSION >= 2)
         SDL_DFB_CHECKERR(data->surface->SetRenderOptions(data->surface,
@@ -964,13 +968,13 @@
 #endif
 
         if (srcrect->w == dstrect->w && srcrect->h == dstrect->h) {
-            SDL_DFB_CHECKERR(data->surface->
-                             Blit(data->surface, texturedata->surface,
-                                  &sr, dr.x, dr.y));
+            SDL_DFB_CHECKERR(data->surface->Blit(data->surface,
+                                                 texturedata->surface,
+                                                 &sr, dr.x, dr.y));
         } else {
-            SDL_DFB_CHECKERR(data->surface->
-                             StretchBlit(data->surface, texturedata->surface,
-                                         &sr, &dr));
+            SDL_DFB_CHECKERR(data->surface->StretchBlit(data->surface,
+                                                        texturedata->surface,
+                                                        &sr, &dr));
         }
     }
     return 0;
@@ -983,6 +987,7 @@
 {
     DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
     SDL_Window *window = SDL_GetWindowFromID(renderer->window);
+    SDL_DFB_WINDOWDATA(window);
 
     DFBRectangle sr;
     DFBResult ret;
@@ -993,12 +998,8 @@
     sr.h = window->h;
 
     /* Send the data to the display */
-    SDL_DFB_CHECKERR(data->surface->
-                     Flip(data->surface, NULL, data->flipflags));
-
-    return;
-  error:
-    return;
+    SDL_DFB_CHECK(windata->window_surface->Flip(windata->window_surface, NULL,
+                                                data->flipflags));
 }
 
 static void
--- a/src/video/directfb/SDL_DirectFB_video.c	Sun Jan 11 23:39:11 2009 +0000
+++ b/src/video/directfb/SDL_DirectFB_video.c	Sun Jan 11 23:49:23 2009 +0000
@@ -35,6 +35,7 @@
 
 #include <directfb.h>
 #include <directfb_version.h>
+#include <directfb_strings.h>
 
 #include "SDL_video.h"
 #include "SDL_mouse.h"
@@ -55,8 +56,10 @@
 static int DirectFB_Available(void);
 static SDL_VideoDevice *DirectFB_CreateDevice(int devindex);
 
+#if 0
 static int DirectFB_SetDisplayGammaRamp(_THIS, Uint16 * ramp);
 static int DirectFB_GetDisplayGammaRamp(_THIS, Uint16 * ramp);
+#endif
 
 VideoBootStrap DirectFB_bootstrap = {
     "directfb", "DirectFB",
@@ -111,6 +114,7 @@
     device->CreateWindow = DirectFB_CreateWindow;
     device->CreateWindowFrom = DirectFB_CreateWindowFrom;
     device->SetWindowTitle = DirectFB_SetWindowTitle;
+    device->SetWindowIcon = DirectFB_SetWindowIcon;
     device->SetWindowPosition = DirectFB_SetWindowPosition;
     device->SetWindowSize = DirectFB_SetWindowSize;
     device->ShowWindow = DirectFB_ShowWindow;
@@ -145,6 +149,50 @@
     return (0);
 }
 
+static const DirectFBSurfaceDrawingFlagsNames(drawing_flags);
+static const DirectFBSurfaceBlittingFlagsNames(blitting_flags);
+static const DirectFBAccelerationMaskNames(acceleration_mask);
+
+static void
+DirectFB_DeviceInformation(IDirectFB * dfb)
+{
+    DFBGraphicsDeviceDescription desc;
+    int n;
+
+    dfb->GetDeviceDescription(dfb, &desc);
+
+    fprintf(LOG_CHANNEL, "DirectFB Device Information\n");
+    fprintf(LOG_CHANNEL, "===========================\n");
+    fprintf(LOG_CHANNEL, "Name:           %s\n", desc.name);
+    fprintf(LOG_CHANNEL, "Vendor:         %s\n", desc.vendor);
+    fprintf(LOG_CHANNEL, "Driver Name:    %s\n", desc.driver.name);
+    fprintf(LOG_CHANNEL, "Driver Vendor:  %s\n", desc.driver.vendor);
+    fprintf(LOG_CHANNEL, "Driver Version: %d.%d\n", desc.driver.major,
+            desc.driver.minor);
+
+    fprintf(LOG_CHANNEL, "\nVideo memoory:  %d\n", desc.video_memory);
+
+    fprintf(LOG_CHANNEL, "\nBlitting flags:\n");
+    for (n = 0; blitting_flags[n].flag; n++) {
+        if (desc.blitting_flags & blitting_flags[n].flag)
+            printf("    %s\n", blitting_flags[n].name);
+    }
+
+    fprintf(LOG_CHANNEL, "\nDrawing flags:\n");
+    for (n = 0; drawing_flags[n].flag; n++) {
+        if (desc.drawing_flags & drawing_flags[n].flag)
+            printf("    %s\n", drawing_flags[n].name);
+    }
+
+    fprintf(LOG_CHANNEL, "\nAcceleration flags:\n");
+    for (n = 0; acceleration_mask[n].mask; n++) {
+        if (desc.acceleration_mask & acceleration_mask[n].mask)
+            printf("    %s\n", acceleration_mask[n].name);
+    }
+
+
+}
+
 static int
 DirectFB_VideoInit(_THIS)
 {
@@ -159,21 +207,21 @@
 
     /* avoid switching to the framebuffer when we
      * are running X11 */
-    stemp = getenv(DFBENV_USE_X11_CHECK);
+    stemp = SDL_getenv(DFBENV_USE_X11_CHECK);
     if (stemp)
         ret = atoi(stemp);
     else
         ret = 1;
 
     if (ret) {
-        if (getenv("DISPLAY"))
+        if (SDL_getenv("DISPLAY"))
             DirectFBSetOption("system", "x11");
         else
             DirectFBSetOption("disable-module", "x11input");
     }
 
     devdata->use_linux_input = 1;       /* default: on */
-    stemp = getenv(DFBENV_USE_LINUX_INPUT);
+    stemp = SDL_getenv(DFBENV_USE_LINUX_INPUT);
     if (stemp)
         devdata->use_linux_input = atoi(stemp);
 
@@ -182,25 +230,34 @@
 
     SDL_DFB_CHECKERR(DirectFBCreate(&dfb));
 
+    DirectFB_DeviceInformation(dfb);
     devdata->use_yuv_underlays = 0;     /* default: off */
-    stemp = getenv(DFBENV_USE_YUV_UNDERLAY);
+    stemp = SDL_getenv(DFBENV_USE_YUV_UNDERLAY);
     if (stemp)
         devdata->use_yuv_underlays = atoi(stemp);
 
 
     /* Create global Eventbuffer for axis events */
     if (devdata->use_linux_input) {
-        SDL_DFB_CHECKERR(dfb->
-                         CreateInputEventBuffer(dfb, DICAPS_ALL,
-                                                DFB_TRUE, &devdata->events));
+        SDL_DFB_CHECKERR(dfb->CreateInputEventBuffer(dfb, DICAPS_ALL,
+                                                     DFB_TRUE,
+                                                     &devdata->events));
     } else {
-        SDL_DFB_CHECKERR(dfb->
-                         CreateInputEventBuffer(dfb,
-                                                DICAPS_AXES /*DICAPS_ALL */ ,
-                                                DFB_TRUE, &devdata->events));
+        SDL_DFB_CHECKERR(dfb->CreateInputEventBuffer(dfb, DICAPS_AXES
+                                                     /*DICAPS_ALL */ ,
+                                                     DFB_TRUE,
+                                                     &devdata->events));
     }
 
     devdata->initialized = 1;
+
+    /* simple window manager support */
+    stemp = SDL_getenv(DFBENV_USE_WM);
+    if (stemp)
+    	devdata->has_own_wm = atoi(stemp);
+    else
+    	devdata->has_own_wm = 0;
+
     devdata->dfb = dfb;
     devdata->firstwin = NULL;
 
@@ -216,7 +273,6 @@
     DirectFB_InitMouse(_this);
     DirectFB_InitKeyboard(_this);
 
-
     return 0;
 
 
@@ -245,6 +301,7 @@
     devdata->initialized = 0;
 }
 
+#if 0
 static int
 DirectFB_SetDisplayGammaRamp(_THIS, Uint16 * ramp)
 {
@@ -256,3 +313,4 @@
 {
     return -1;
 }
+#endif
--- a/src/video/directfb/SDL_DirectFB_video.h	Sun Jan 11 23:39:11 2009 +0000
+++ b/src/video/directfb/SDL_DirectFB_video.h	Sun Jan 11 23:49:23 2009 +0000
@@ -34,8 +34,8 @@
 #define DEBUG 0
 #define LOG_CHANNEL 	stdout
 
-#if (DIRECTFB_MAJOR_VERSION == 0) && (DIRECTFB_MINOR_VERSION == 9) && (DIRECTFB_MICRO_VERSION < 23)
-#error "SDL_DIRECTFB: Please compile against libdirectfb version >=0.9.24"
+#if (DIRECTFB_MAJOR_VERSION < 1)
+#error "SDL_DIRECTFB: Please compile against libdirectfb version >= 1.0.0"
 #endif
 
 #if (DIRECTFB_MAJOR_VERSION >= 1) && (DIRECTFB_MINOR_VERSION >= 0) && (DIRECTFB_MICRO_VERSION >= 0 )
@@ -56,11 +56,13 @@
 #include "SDL_DirectFB_mouse.h"
 #include "SDL_DirectFB_opengl.h"
 #include "SDL_DirectFB_window.h"
+#include "SDL_DirectFB_WM.h"
 
 #define DFBENV_USE_YUV_UNDERLAY 	"SDL_DIRECTFB_YUV_UNDERLAY"     /* Default: off */
 #define DFBENV_USE_YUV_DIRECT   	"SDL_DIRECTFB_YUV_DIRECT"       /* Default: off */
 #define DFBENV_USE_X11_CHECK		"SDL_DIRECTFB_X11_CHECK"        /* Default: on  */
 #define DFBENV_USE_LINUX_INPUT		"SDL_DIRECTFB_LINUX_INPUT"      /* Default: on  */
+#define DFBENV_USE_WM				"SDL_DIRECTFB_WM"		      	/* Default: off  */
 
 #define SDL_DFB_RELEASE(x) do { if ( x ) { x->Release(x); x = NULL; } } while (0)
 #define SDL_DFB_FREE(x) do { if ( x ) { SDL_free(x); x = NULL; } } while (0)
@@ -88,6 +90,8 @@
           ret = x;                                                    \
           if (ret != DFB_OK) {                                        \
                fprintf(LOG_CHANNEL, "%s <%d>:\n\t", __FILE__, __LINE__ ); 	      \
+               fprintf(LOG_CHANNEL, "\t%s\n", #x ); \
+               fprintf(LOG_CHANNEL, "\t%s\n", DirectFBErrorString (ret) ); \
                SDL_SetError( #x, DirectFBErrorString (ret) );         \
           }                                                           \
      } while (0)
@@ -116,7 +120,7 @@
 
 /* Private display data */
 
-#define SDL_DFB_DEVICEDATA(dev)  DFB_DeviceData *devdata = (DFB_DeviceData *) ((dev)->driverdata)
+#define SDL_DFB_DEVICEDATA(dev)  DFB_DeviceData *devdata = (dev ? (DFB_DeviceData *) ((dev)->driverdata) : NULL)
 
 #define DFB_MAX_SCREENS 10
 
@@ -138,6 +142,7 @@
 
     int use_yuv_underlays;
     int use_linux_input;
+    int has_own_wm;
 
     /* OpenGL */
     void (*glFinish) (void);
--- a/src/video/directfb/SDL_DirectFB_window.c	Sun Jan 11 23:39:11 2009 +0000
+++ b/src/video/directfb/SDL_DirectFB_window.c	Sun Jan 11 23:49:23 2009 +0000
@@ -27,27 +27,27 @@
 
 #include "SDL_DirectFB_video.h"
 
+
 int
 DirectFB_CreateWindow(_THIS, SDL_Window * window)
 {
     SDL_DFB_DEVICEDATA(_this);
     SDL_DFB_DISPLAYDATA(_this, window);
-    DFB_WindowData *windata;
+    DFB_WindowData *windata = NULL;
     DFBWindowOptions wopts;
     DFBWindowDescription desc;
+    IDirectFBFont *font;
     int ret, x, y;
 
-    SDL_DFB_DEBUG("Trace x %d y %d w %d h %d\n", window->x, window->y,
-                  window->w, window->h);
-    window->driverdata = NULL;
     SDL_DFB_CALLOC(window->driverdata, 1, sizeof(DFB_WindowData));
     windata = (DFB_WindowData *) window->driverdata;
 
-    SDL_DFB_CHECKERR(devdata->dfb->
-                     SetCooperativeLevel(devdata->dfb, DFSCL_NORMAL));
-    SDL_DFB_CHECKERR(dispdata->layer->
-                     SetCooperativeLevel(dispdata->layer,
-                                         DLSCL_ADMINISTRATIVE));
+    windata->is_managed = devdata->has_own_wm;
+
+    SDL_DFB_CHECKERR(devdata->dfb->SetCooperativeLevel(devdata->dfb,
+                                                       DFSCL_NORMAL));
+    SDL_DFB_CHECKERR(dispdata->layer->SetCooperativeLevel(dispdata->layer,
+                                                          DLSCL_ADMINISTRATIVE));
 
     /* Fill the window description. */
     if (window->x == SDL_WINDOWPOS_CENTERED) {
@@ -69,76 +69,76 @@
         y = 0;
     }
 
-    desc.flags = DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_PIXELFORMAT;
-    /*| DWDESC_CAPS | DWDESC_SURFACE_CAPS */
+    DirectFB_WM_AdjustWindowLayout(window);
 
-#if (DIRECTFB_MAJOR_VERSION == 1) && (DIRECTFB_MINOR_VERSION >= 0)
-    /* Needed for 1.2 */
-    desc.flags |= DWDESC_POSX | DWDESC_POSY | DWDESC_SURFACE_CAPS;
+    /* Create Window */
+    desc.flags =
+        DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_PIXELFORMAT | DWDESC_POSX
+        | DWDESC_POSY | DWDESC_SURFACE_CAPS;
     desc.posx = x;
     desc.posy = y;
-#else
-    if (!(window->flags & SDL_WINDOW_FULLSCREEN)
-        && window->x != SDL_WINDOWPOS_UNDEFINED
-        && window->y != SDL_WINDOWPOS_UNDEFINED) {
-        desc.flags |= DWDESC_POSX | DWDESC_POSY;
-        desc.posx = x;
-        desc.posy = y;
-    }
-#endif
-
-    desc.width = window->w;
-    desc.height = window->h;
+    desc.width = windata->size.w;
+    desc.height = windata->size.h;
     desc.pixelformat = dispdata->pixelformat;
-#if 0
-    desc.caps = 0;
-    desc.surface_caps =
-        DSCAPS_DOUBLE | DSCAPS_TRIPLE | DSCAPS_PREMULTIPLIED |
-        DSCAPS_VIDEOONLY;
-#endif
     desc.surface_caps = DSCAPS_PREMULTIPLIED;
-    /* DSCAPS_VIDEOONLY has negative impact on performance */
 
     /* Create the window. */
-    SDL_DFB_CHECKERR(dispdata->layer->
-                     CreateWindow(dispdata->layer, &desc, &windata->window));
+    SDL_DFB_CHECKERR(dispdata->layer->CreateWindow(dispdata->layer, &desc,
+                                                   &windata->window));
 
+    /* Set Options */
     windata->window->GetOptions(windata->window, &wopts);
-#if (DIRECTFB_MAJOR_VERSION == 1) && (DIRECTFB_MINOR_VERSION >= 0)
 
     if (window->flags & SDL_WINDOW_RESIZABLE)
         wopts |= DWOP_SCALE;
     else
         wopts |= DWOP_KEEP_SIZE;
-#else
-    wopts |= DWOP_KEEP_SIZE;    /* if not we will crash ... */
-#endif
 
-    if (window->flags & SDL_WINDOW_FULLSCREEN)
+    if (window->flags & SDL_WINDOW_FULLSCREEN) {
         wopts |= DWOP_KEEP_POSITION | DWOP_KEEP_STACKING | DWOP_KEEP_SIZE;
+        windata->window->SetStackingClass(windata->window, DWSC_UPPER);
+    }
+    windata->window->SetOptions(windata->window, wopts);
 
-    windata->window->SetOptions(windata->window, wopts);
+    /* See what we got */
+    SDL_DFB_CHECKERR(DirectFB_WM_GetClientSize(_this, window, &window->w, &window->h));
+
     /* Get the window's surface. */
-    SDL_DFB_CHECKERR(windata->window->
-                     GetSurface(windata->window, &windata->surface));
+    SDL_DFB_CHECKERR(windata->window->GetSurface(windata->window,
+                                                 &windata->window_surface));
+    /* And get a subsurface for rendering */
+    SDL_DFB_CHECKERR(windata->window_surface->
+                     GetSubSurface(windata->window_surface, &windata->client,
+                                   &windata->surface));
+
     windata->window->SetOpacity(windata->window, 0xFF);
-    SDL_DFB_CHECKERR(windata->window->
-                     CreateEventBuffer(windata->window,
-                                       &(windata->eventbuffer)));
-    SDL_DFB_CHECKERR(windata->window->
-                     EnableEvents(windata->window, DWET_ALL));
+
+    /* Create Eventbuffer */
+    SDL_DFB_CHECKERR(windata->window->CreateEventBuffer(windata->window,
+                                                        &windata->eventbuffer));
+    SDL_DFB_CHECKERR(windata->
+                     window->EnableEvents(windata->window, DWET_ALL));
 
-    if (window->flags & SDL_WINDOW_FULLSCREEN)
-        windata->window->SetStackingClass(windata->window, DWSC_UPPER);
+    /* Create a font */
+    /* FIXME: once during Video_Init */
+    if (windata->is_managed) {
+        DFBFontDescription fdesc;
+
+        fdesc.flags = DFDESC_HEIGHT;
+        fdesc.height = windata->theme.font_size;
+        font = NULL;
+        SDL_DFB_CHECK(devdata->
+                      dfb->CreateFont(devdata->dfb, windata->theme.font,
+                                      &fdesc, &font));
+        windata->window_surface->SetFont(windata->window_surface, font);
+        SDL_DFB_RELEASE(font);
+    }
+
     /* Make it the top most window. */
     windata->window->RaiseToTop(windata->window);
 
-    windata->window->GetID(windata->window, &windata->windowID);
-
-    windata->window->GetSize(windata->window, &window->w, &window->h);
-
     /* remember parent */
-    windata->id = window->id;
+    windata->sdl_id = window->id;
 
     /* Add to list ... */
 
@@ -146,6 +146,9 @@
     windata->opacity = 0xFF;
     devdata->firstwin = windata;
 
+    /* Draw Frame */
+    DirectFB_WM_RedrawLayout(window);
+
     return 0;
   error:
     SDL_DFB_RELEASE(windata->window);
@@ -163,7 +166,65 @@
 void
 DirectFB_SetWindowTitle(_THIS, SDL_Window * window)
 {
-    SDL_Unsupported();
+    SDL_DFB_WINDOWDATA(window);
+
+    if (windata->is_managed) {
+        windata->wm_needs_redraw = 1;
+    } else
+        SDL_Unsupported();
+}
+
+void
+DirectFB_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)
+{
+    SDL_DFB_DEVICEDATA(_this);
+    SDL_DFB_WINDOWDATA(window);
+    SDL_Surface *surface = NULL;
+    DFBResult ret;
+
+    if (icon) {
+        SDL_PixelFormat format;
+        DFBSurfaceDescription dsc;
+        Uint32 *dest;
+        Uint32 *p;
+        int pitch, i;
+
+        /* Convert the icon to ARGB for modern window managers */
+        SDL_InitFormat(&format, 32, 0x00FF0000, 0x0000FF00, 0x000000FF,
+                       0xFF000000);
+        surface = SDL_ConvertSurface(icon, &format, 0);
+        if (!surface) {
+            return;
+        }
+        dsc.flags =
+            DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS;
+        dsc.caps = DSCAPS_VIDEOONLY;
+        dsc.width = surface->w;
+        dsc.height = surface->h;
+        dsc.pixelformat = DSPF_ARGB;
+
+        SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc,
+                                                     &windata->icon));
+
+        SDL_DFB_CHECKERR(windata->icon->Lock(windata->icon, DSLF_WRITE,
+                                             (void *) &dest, &pitch));
+
+        p = surface->pixels;
+        for (i = 0; i < surface->h; i++)
+            memcpy((char *) dest + i * pitch,
+                   (char *) p + i * surface->pitch, 4 * surface->w);
+
+        windata->icon->Unlock(windata->icon);
+        SDL_FreeSurface(surface);
+    } else {
+        SDL_DFB_RELEASE(windata->icon);
+    }
+    return;
+  error:
+    if (surface)
+        SDL_FreeSurface(surface);
+    SDL_DFB_RELEASE(windata->icon);
+    return;
 }
 
 void
@@ -186,37 +247,39 @@
         x = 0;
         y = 0;
     }
-
+    DirectFB_WM_AdjustWindowLayout(window);
     windata->window->MoveTo(windata->window, x, y);
 }
 
 void
 DirectFB_SetWindowSize(_THIS, SDL_Window * window)
 {
+    SDL_DFB_DEVICEDATA(_this);
+    SDL_DFB_WINDOWDATA(window);
     int ret;
-    SDL_DFB_WINDOWDATA(window);
 
     if (!(window->flags & SDL_WINDOW_FULLSCREEN)) {
-#if (DIRECTFB_MAJOR_VERSION == 1) && (DIRECTFB_MINOR_VERSION >= 0)
         int cw;
         int ch;
 
         /* Make sure all events are disabled for this operation ! */
-        SDL_DFB_CHECKERR(windata->window->
-                         DisableEvents(windata->window, DWET_ALL));
+        SDL_DFB_CHECKERR(windata->window->DisableEvents(windata->window,
+                                                        DWET_ALL));
+
+        SDL_DFB_CHECKERR(DirectFB_WM_GetClientSize(_this, window, &cw, &ch));
+
+        if (cw != window->w || ch != window->h) {
 
-        SDL_DFB_CHECKERR(windata->window->GetSize(windata->window, &cw, &ch));
-        if (cw != window->w || ch != window->h)
-            SDL_DFB_CHECKERR(windata->window->
-                             Resize(windata->window, window->w, window->h));
-        SDL_DFB_CHECKERR(windata->window->
-                         EnableEvents(windata->window, DWET_ALL));
+            DirectFB_WM_AdjustWindowLayout(window);
+            SDL_DFB_CHECKERR(windata->window->Resize(windata->window,
+                                                     windata->size.w,
+                                                     windata->size.h));
+        }
 
-#else
-        SDL_DFB_CHECKERR(windata->window->
-                         Resize(windata->window, window->w, window->h));
-#endif
-        SDL_DFB_CHECKERR(windata->window->GetSize(windata->window, &window->w, &window->h));    /* if a window manager should have decided otherwise */
+        SDL_DFB_CHECKERR(windata->window->EnableEvents(windata->window,
+                                                       DWET_ALL));
+
+        SDL_DFB_CHECKERR(DirectFB_WM_GetClientSize(_this, window, &window->w, &window->h));
 
         SDL_OnWindowResized(window);
     }
@@ -256,9 +319,12 @@
 void
 DirectFB_MaximizeWindow(_THIS, SDL_Window * window)
 {
-    /* FIXME: Size to Desktop ? */
+    SDL_DFB_WINDOWDATA(window);
 
-    SDL_Unsupported();
+    if (windata->is_managed) {
+    	DirectFB_WM_MaximizeWindow(_this, window);
+    } else
+        SDL_Unsupported();
 }
 
 void
@@ -272,7 +338,12 @@
 void
 DirectFB_RestoreWindow(_THIS, SDL_Window * window)
 {
-    SDL_Unsupported();
+    SDL_DFB_WINDOWDATA(window);
+
+    if (windata->is_managed) {
+    	DirectFB_WM_RestoreWindow(_this, window);
+    } else
+        SDL_Unsupported();
 }
 
 void
@@ -280,8 +351,7 @@
 {
     SDL_DFB_WINDOWDATA(window);
 
-    if ((window->flags & SDL_WINDOW_INPUT_GRABBED) &&
-        (window->flags & SDL_WINDOW_INPUT_FOCUS)) {
+    if ((window->flags & SDL_WINDOW_INPUT_GRABBED)) {
         windata->window->GrabPointer(windata->window);
         windata->window->GrabKeyboard(windata->window);
     } else {
@@ -299,8 +369,16 @@
 
     SDL_DFB_DEBUG("Trace\n");
 
+    /* Some cleanups */
+    windata->window->UngrabPointer(windata->window);
+    windata->window->UngrabKeyboard(windata->window);
+
+    windata->window_surface->SetFont(windata->window_surface, NULL);
+    SDL_DFB_RELEASE(windata->icon);
     SDL_DFB_RELEASE(windata->eventbuffer);
     SDL_DFB_RELEASE(windata->surface);
+    SDL_DFB_RELEASE(windata->window_surface);
+
     SDL_DFB_RELEASE(windata->window);
 
     /* Remove from list ... */
@@ -323,3 +401,35 @@
     SDL_Unsupported();
     return SDL_FALSE;
 }
+
+void
+DirectFB_AdjustWindowSurface(SDL_Window * window)
+{
+    SDL_DFB_WINDOWDATA(window);
+    int adjust = windata->wm_needs_redraw;
+    int cw, ch;
+    int ret;
+
+    DirectFB_WM_AdjustWindowLayout(window);
+
+    SDL_DFB_CHECKERR(windata->
+                     window_surface->GetSize(windata->window_surface, &cw,
+                                             &ch));
+    if (cw != windata->size.w || ch != windata->size.h) {
+        adjust = 1;
+    }
+
+    if (adjust) {
+        SDL_DFB_CHECKERR(windata->window->ResizeSurface(windata->window,
+                                                        windata->size.w,
+                                                        windata->size.h));
+        SDL_DFB_CHECKERR(windata->surface->MakeSubSurface(windata->surface,
+                                                          windata->
+                                                          window_surface,
+                                                          &windata->client));
+        DirectFB_WM_RedrawLayout(window);
+    }
+  error:
+    return;
+}
+
--- a/src/video/directfb/SDL_DirectFB_window.h	Sun Jan 11 23:39:11 2009 +0000
+++ b/src/video/directfb/SDL_DirectFB_window.h	Sun Jan 11 23:49:23 2009 +0000
@@ -24,25 +24,38 @@
 #ifndef _SDL_directfb_window_h
 #define _SDL_directfb_window_h
 
+#include "SDL_DirectFB_WM.h"
+
 #define SDL_DFB_WINDOWDATA(win)  DFB_WindowData *windata = ((win) ? (DFB_WindowData *) ((win)->driverdata) : NULL)
 
 typedef struct _DFB_WindowData DFB_WindowData;
 struct _DFB_WindowData
 {
     IDirectFBSurface *surface;
+    IDirectFBSurface *window_surface;   /* only used with has_own_wm */
     IDirectFBWindow *window;
     DirectFB_GLContext *gl_context;
     IDirectFBEventBuffer *eventbuffer;
-    DFBWindowID windowID;
+    SDL_WindowID sdl_id;
     DFB_WindowData *next;
     Uint8 opacity;
-    SDL_WindowID id;
+    DFBRectangle client;
+    DFBDimension size;
+    /* WM extras */
+    DFBRectangle restore;
+    int is_managed;
+    int wm_needs_redraw;
+    IDirectFBSurface *icon;
+    DFB_Theme theme;
 };
 
 extern int DirectFB_CreateWindow(_THIS, SDL_Window * window);
 extern int DirectFB_CreateWindowFrom(_THIS, SDL_Window * window,
                                      const void *data);
 extern void DirectFB_SetWindowTitle(_THIS, SDL_Window * window);
+extern void DirectFB_SetWindowIcon(_THIS, SDL_Window * window,
+                                   SDL_Surface * icon);
+
 extern void DirectFB_SetWindowPosition(_THIS, SDL_Window * window);
 extern void DirectFB_SetWindowSize(_THIS, SDL_Window * window);
 extern void DirectFB_ShowWindow(_THIS, SDL_Window * window);
@@ -56,6 +69,8 @@
 extern SDL_bool DirectFB_GetWindowWMInfo(_THIS, SDL_Window * window,
                                          struct SDL_SysWMinfo *info);
 
+extern void DirectFB_AdjustWindowSurface(SDL_Window * window);
+
 #endif /* _SDL_directfb_window_h */
 
 /* vi: set ts=4 sw=4 expandtab: */