pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

DirectFB cleanups & simple window manager

Browse source 
- 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

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%403485
This commit is contained in:
Couriersud 2009-01-11 23:49:23 +00:00
parent 3e968cec07
commit 2cd9219893
14 changed files with 1172 additions and 515 deletions
Download patch file Download diff file Expand all files Collapse all files

13
README.DirectFB
View file

@ -49,6 +49,19 @@ export SDL_DIRECTFB_YUV_UNDERLAY=1
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
==============

361
src/video/directfb/SDL_DirectFB_WM.c Normal file
View file

@ -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;
}

56
src/video/directfb/SDL_DirectFB_WM.h Normal file
View file

@ -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: */

10
src/video/directfb/SDL_DirectFB_dyn.c
View file

@ -21,8 +21,8 @@
*/
#include "SDL_config.h"
#include "SDL_DirectFB_dyn.h"
#include "SDL_DirectFB_video.h"
#include "SDL_DirectFB_dyn.h"
#ifdef SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC
#include "SDL_name.h"
@ -69,11 +69,11 @@ SDL_DirectFB_LoadLibrary(void)
}
}
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,

5
src/video/directfb/SDL_DirectFB_dyn.h
View file

@ -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);

535
src/video/directfb/SDL_DirectFB_events.c
View file

@ -60,8 +60,8 @@ DirectFB_SetContext(_THIS, SDL_WindowID id)
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 @@ KbdIndex(_THIS, int id)
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 @@ DirectFB_PumpEventsWindow(_THIS)
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 @@ DirectFB_TranslateKey(_THIS, DFBWindowEvent * evt, SDL_keysym * keysym)
{
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 @@ DirectFB_TranslateKey(_THIS, DFBWindowEvent * evt, SDL_keysym * keysym)
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 @@ DirectFB_TranslateKeyInputEvent(_THIS, int index, DFBInputEvent * evt,
{
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 @@ DirectFB_TranslateKeyInputEvent(_THIS, int index, DFBInputEvent * evt,
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 @@ DirectFB_TranslateButton(DFBInputDeviceButtonIdentifier button)
}
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 @@ input_device_cb(DFBInputDeviceID device_id, DFBInputDeviceDescription desc,
}
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 @@ DirectFB_InitKeyboard(_THIS)
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 @@ DirectFB_PumpEvents(_THIS)
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) {

91
src/video/directfb/SDL_DirectFB_modes.c
View file

@ -204,8 +204,8 @@ CheckSetDisplayMode(_THIS, DFB_DisplayData * data, SDL_DisplayMode * mode)
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 @@ CheckSetDisplayMode(_THIS, DFB_DisplayData * data, SDL_DisplayMode * mode)
}
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 @@ DirectFB_InitModes(_THIS)
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 @@ DirectFB_InitModes(_THIS)
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 @@ DirectFB_InitModes(_THIS)
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 @@ DirectFB_GetDisplayModes(_THIS)
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 @@ DirectFB_SetDisplayMode(_THIS, SDL_DisplayMode * mode)
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 @@ DirectFB_SetDisplayMode(_THIS, SDL_DisplayMode * mode)
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 @@ DirectFB_SetDisplayMode(_THIS, SDL_DisplayMode * mode)
#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 @@ DirectFB_SetDisplayMode(_THIS, SDL_DisplayMode * mode)
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 @@ DirectFB_QuitModes(_THIS)
(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);

28
src/video/directfb/SDL_DirectFB_mouse.c
View file

@ -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 void DirectFB_FreeMouse(SDL_Mouse * mouse);
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 @@ DirectFB_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
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 @@ DirectFB_ShowCursor(SDL_Cursor * cursor)
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 @@ DirectFB_ShowCursor(SDL_Cursor * cursor)
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 @@ DirectFB_WarpMouse(SDL_Mouse * mouse, SDL_WindowID windowID, int x, int y)
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;

17
src/video/directfb/SDL_DirectFB_opengl.c
View file

@ -173,8 +173,8 @@ DirectFB_GL_CreateContext(_THIS, SDL_Window * window)
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 @@ DirectFB_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
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 @@ DirectFB_GL_SwapWindow(_THIS, SDL_Window * window)
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)); */
}

189
src/video/directfb/SDL_DirectFB_render.c
View file

@ -41,16 +41,16 @@ static int DirectFB_ActivateRenderer(SDL_Renderer * renderer);
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 @@ static int DirectFB_SetTextureScaleMode(SDL_Renderer * renderer,
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 @@ static int DirectFB_RenderLine(SDL_Renderer * renderer, int x1, int y1,
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_RenderDriver DirectFB_RenderDriver = {
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 @@ DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags)
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 @@ DirectFB_ActivateRenderer(SDL_Renderer * renderer)
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 @@ DirectFB_AcquireVidLayer(SDL_Renderer * renderer, SDL_Texture * texture)
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 @@ DirectFB_AcquireVidLayer(SDL_Renderer * renderer, SDL_Texture * texture)
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 @@ DirectFB_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
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 @@ DirectFB_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
}
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 @@ DirectFB_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
}
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 @@ DirectFB_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
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 @@ DirectFB_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
}
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 @@ DirectFB_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
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 @@ DirectFB_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
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 @@ PrepareDraw(SDL_Renderer * renderer)
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 @@ DirectFB_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect)
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 @@ DirectFB_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
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 @@ DirectFB_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
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 @@ DirectFB_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
#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_RenderPresent(SDL_Renderer * renderer)
{
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 @@ DirectFB_RenderPresent(SDL_Renderer * renderer)
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

82
src/video/directfb/SDL_DirectFB_video.c
View file

@ -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 void DirectFB_VideoQuit(_THIS);
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 @@ DirectFB_CreateDevice(int devindex)
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 @@ DirectFB_CreateDevice(int devindex)
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 @@ DirectFB_VideoInit(_THIS)
/* 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 @@ DirectFB_VideoInit(_THIS)
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_VideoInit(_THIS)
DirectFB_InitMouse(_this);
DirectFB_InitKeyboard(_this);
return 0;
@ -245,6 +301,7 @@ DirectFB_VideoQuit(_THIS)
devdata->initialized = 0;
}
#if 0
static int
DirectFB_SetDisplayGammaRamp(_THIS, Uint16 * ramp)
{
@ -256,3 +313,4 @@ DirectFB_GetDisplayGammaRamp(_THIS, Uint16 * ramp)
{
return -1;
}
#endif

11
src/video/directfb/SDL_DirectFB_video.h
View file

@ -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 @@ struct _DFB_DeviceData
int use_yuv_underlays;
int use_linux_input;
int has_own_wm;
/* OpenGL */
void (*glFinish) (void);

270
src/video/directfb/SDL_DirectFB_window.c
View file

@ -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 @@ DirectFB_CreateWindow(_THIS, SDL_Window * window)
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->SetOptions(windata->window, wopts);
/* Get the window's surface. */
SDL_DFB_CHECKERR(windata->window->
GetSurface(windata->window, &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));
if (window->flags & SDL_WINDOW_FULLSCREEN)
windata->window->SetStackingClass(windata->window, DWSC_UPPER);
}
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->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);
/* Create Eventbuffer */
SDL_DFB_CHECKERR(windata->window->CreateEventBuffer(windata->window,
&windata->eventbuffer));
SDL_DFB_CHECKERR(windata->
window->EnableEvents(windata->window, DWET_ALL));
/* 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 @@ DirectFB_CreateWindow(_THIS, SDL_Window * window)
windata->opacity = 0xFF;
devdata->firstwin = windata;
/* Draw Frame */
DirectFB_WM_RedrawLayout(window);
return 0;
error:
SDL_DFB_RELEASE(windata->window);
@ -163,7 +166,65 @@ DirectFB_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)
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 @@ DirectFB_SetWindowPosition(_THIS, SDL_Window * window)
x = 0;
y = 0;
}
DirectFB_WM_AdjustWindowLayout(window);
windata->window->MoveTo(windata->window, x, y);
}
void
DirectFB_SetWindowSize(_THIS, SDL_Window * window)
{
int ret;
SDL_DFB_DEVICEDATA(_this);
SDL_DFB_WINDOWDATA(window);
int ret;
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(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));
SDL_DFB_CHECKERR(DirectFB_WM_GetClientSize(_this, window, &cw, &ch));
#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 */
if (cw != window->w || ch != window->h) {
DirectFB_WM_AdjustWindowLayout(window);
SDL_DFB_CHECKERR(windata->window->Resize(windata->window,
windata->size.w,
windata->size.h));
}
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 @@ DirectFB_RaiseWindow(_THIS, SDL_Window * window)
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 @@ DirectFB_MinimizeWindow(_THIS, SDL_Window * window)
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 @@ DirectFB_SetWindowGrab(_THIS, SDL_Window * window)
{
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 @@ DirectFB_DestroyWindow(_THIS, SDL_Window * window)
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 @@ DirectFB_GetWindowWMInfo(_THIS, SDL_Window * window,
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;
}

19
src/video/directfb/SDL_DirectFB_window.h
View file

@ -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 void DirectFB_DestroyWindow(_THIS, SDL_Window * window);
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: */