Simple DirectMedia Layer

Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

#include "SDL_DirectFB_video.h"

#include "SDL_DirectFB_modes.h"

#include "SDL_DirectFB_window.h"

#include "SDL_DirectFB_shape.h"

#if SDL_DIRECTFB_OPENGL

#include "SDL_DirectFB_opengl.h"

#endif

#include "SDL_syswm.h"

#include "../SDL_pixels_c.h"

int

DirectFB_CreateWindow(_THIS, SDL_Window * window)

{

SDL_DFB_DEVICEDATA(_this);

DFBWindowOptions wopts;

DFBWindowDescription desc;

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

#endif

/* FIXME ... ughh, ugly */

if (window->x == -1000 && window->y == -1000)

bshaped = 1;

x = window->x;

y = window->y;

DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_POSX | DWDESC_POSY | DWDESC_SURFACE_CAPS;

if (bshaped) {

desc.flags |= DWDESC_CAPS;

desc.caps |= DWCAPS_ALPHACHANNEL;

}

else

{

desc.flags |= DWDESC_PIXELFORMAT;

}

if (!(window->flags & SDL_WINDOW_BORDERLESS))

desc.caps |= DWCAPS_NODECORATION;

desc.posx = x;

desc.posy = y;

desc.width = windata->size.w;

desc.height = windata->size.h;

desc.pixelformat = dispdata->pixelformat;

desc.surface_caps = DSCAPS_PREMULTIPLIED;

/* explicit rescaling of surface */

wopts |= DWOP_SCALE;

if (window->flags & SDL_WINDOW_RESIZABLE) {

wopts &= ~DWOP_KEEP_SIZE;

}

else {

SDL_DFB_CHECK(windata->dfbwin->SetStackingClass(windata->dfbwin, DWSC_UPPER));

}

if (bshaped) {

wopts |= DWOP_SHAPED | DWOP_ALPHACHANNEL;

wopts &= ~DWOP_OPAQUE_REGION;

SDL_DFB_CHECK(windata->dfbwin->SetOptions(windata->dfbwin, wopts));

/* See what we got */

/* And get a subsurface for rendering */

SDL_DFB_CHECKERR(windata->window_surface->

GetSubSurface(windata->window_surface, &windata->client,

&windata->surface));

SDL_DFB_CHECKERR(windata->dfbwin->CreateEventBuffer(windata->dfbwin,

&windata->

eventbuffer));

SDL_DFB_CHECKERR(windata->dfbwin->

EnableEvents(windata->dfbwin, DWET_ALL));

/* Create a font */

/* FIXME: once during Video_Init */

/* remember parent */

/* Add to list ... */

windata->next = devdata->firstwin;

windata->opacity = 0xFF;

return 0;

error:

SDL_DFB_RELEASE(windata->surface);

SDL_DFB_RELEASE(windata->dfbwin);

return -1;

}

int

DirectFB_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)

{

SDL_Unsupported();

return -1;

}

void

DirectFB_SetWindowTitle(_THIS, SDL_Window * window)

{

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;

if (icon) {

SDL_PixelFormat format;

DFBSurfaceDescription dsc;

Uint32 *dest;

Uint32 *p;

int pitch, i;

/* Convert the icon to ARGB for modern window managers */

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

SDL_FreeSurface(surface);

} else {

SDL_DFB_RELEASE(windata->icon);

}

return;

error:

if (surface)

SDL_FreeSurface(surface);

SDL_DFB_RELEASE(windata->icon);

return;

}

void

DirectFB_SetWindowPosition(_THIS, SDL_Window * window)

{

SDL_DFB_WINDOWDATA(window);

int x, y;

x = window->x;

y = window->y;

}

void

DirectFB_SetWindowSize(_THIS, SDL_Window * window)

{

SDL_DFB_WINDOWDATA(window);

if(SDL_IsShapedWindow(window))

DirectFB_ResizeWindowShape(window);

if (!(window->flags & SDL_WINDOW_FULLSCREEN)) {

int cw;

int ch;

/* Make sure all events are disabled for this operation ! */

DWET_ALL));

SDL_DFB_CHECKERR(DirectFB_WM_GetClientSize(_this, window, &cw, &ch));

if (cw != window->w || ch != window->h) {

windata->size.w,

windata->size.h));

}

SDL_DFB_CHECKERR(DirectFB_WM_GetClientSize

(_this, window, &window->w, &window->h));

DWET_ALL));

}

return;

error:

return;

}

void

DirectFB_ShowWindow(_THIS, SDL_Window * window)

{

SDL_DFB_WINDOWDATA(window);

}

void

DirectFB_HideWindow(_THIS, SDL_Window * window)

{

SDL_DFB_WINDOWDATA(window);

SDL_DFB_CHECK(windata->dfbwin->GetOpacity(windata->dfbwin, &windata->opacity));

SDL_DFB_CHECK(windata->dfbwin->SetOpacity(windata->dfbwin, 0));

}

void

DirectFB_RaiseWindow(_THIS, SDL_Window * window)

{

SDL_DFB_WINDOWDATA(window);

SDL_DFB_CHECK(windata->dfbwin->RaiseToTop(windata->dfbwin));

SDL_DFB_CHECK(windata->dfbwin->RequestFocus(windata->dfbwin));

}

void

DirectFB_MaximizeWindow(_THIS, SDL_Window * window)

{

SDL_DFB_CHECK(windata->dfbwin->GetPosition(windata->dfbwin,

&windata->restore.x, &windata->restore.y));

SDL_DFB_CHECK(windata->dfbwin->GetSize(windata->dfbwin, &windata->restore.w,

&windata->restore.h));

DirectFB_WM_AdjustWindowLayout(window, window->flags | SDL_WINDOW_MAXIMIZED, display->current_mode.w, display->current_mode.h) ;

SDL_DFB_CHECK(windata->dfbwin->MoveTo(windata->dfbwin, 0, 0));

SDL_DFB_CHECK(windata->dfbwin->Resize(windata->dfbwin,

display->current_mode.w, display->current_mode.h));

/* Set Options */

SDL_DFB_CHECK(windata->dfbwin->GetOptions(windata->dfbwin, &wopts));

wopts |= DWOP_KEEP_SIZE | DWOP_KEEP_POSITION;

SDL_DFB_CHECK(windata->dfbwin->SetOptions(windata->dfbwin, wopts));

}

void

DirectFB_MinimizeWindow(_THIS, SDL_Window * window)

{

/* FIXME: Size to 32x32 ? */

SDL_Unsupported();

}

void

DirectFB_RestoreWindow(_THIS, SDL_Window * window)

{

DFBWindowOptions wopts;

/* Set Options */

SDL_DFB_CHECK(windata->dfbwin->GetOptions(windata->dfbwin, &wopts));

wopts &= ~(DWOP_KEEP_SIZE | DWOP_KEEP_POSITION);

SDL_DFB_CHECK(windata->dfbwin->SetOptions(windata->dfbwin, wopts));

/* Window layout */

DirectFB_WM_AdjustWindowLayout(window, window->flags & ~(SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED),

windata->restore.w, windata->restore.h);

SDL_DFB_CHECK(windata->dfbwin->Resize(windata->dfbwin, windata->restore.w,

windata->restore.h));

SDL_DFB_CHECK(windata->dfbwin->MoveTo(windata->dfbwin, windata->restore.x,

windata->restore.y));

if (!(window->flags & SDL_WINDOW_RESIZABLE))

wopts |= DWOP_KEEP_SIZE;

if (window->flags & SDL_WINDOW_FULLSCREEN)

wopts |= DWOP_KEEP_POSITION | DWOP_KEEP_SIZE;

SDL_DFB_CHECK(windata->dfbwin->SetOptions(windata->dfbwin, wopts));

}

void

DirectFB_SetWindowGrab(_THIS, SDL_Window * window)

{

if (gwindata != NULL)

{

SDL_DFB_CHECK(gwindata->dfbwin->UngrabPointer(gwindata->dfbwin));

SDL_DFB_CHECK(gwindata->dfbwin->UngrabKeyboard(gwindata->dfbwin));

SDL_DFB_CHECK(windata->dfbwin->GrabPointer(windata->dfbwin));

SDL_DFB_CHECK(windata->dfbwin->GrabKeyboard(windata->dfbwin));

SDL_DFB_CHECK(windata->dfbwin->UngrabPointer(windata->dfbwin));

SDL_DFB_CHECK(windata->dfbwin->UngrabKeyboard(windata->dfbwin));

}

}

void

DirectFB_DestroyWindow(_THIS, SDL_Window * window)

{

SDL_DFB_DEVICEDATA(_this);

SDL_DFB_WINDOWDATA(window);

DFB_WindowData *p;

SDL_DFB_CHECK(windata->dfbwin->UngrabPointer(windata->dfbwin));

SDL_DFB_CHECK(windata->dfbwin->UngrabKeyboard(windata->dfbwin));

#if SDL_DIRECTFB_OPENGL

DirectFB_GL_DestroyWindowContexts(_this, window);

#endif

if (window->shaper)

{

SDL_ShapeData *data = window->shaper->driverdata;

SDL_DFB_CHECK(data->surface->ReleaseSource(data->surface));

SDL_DFB_RELEASE(data->surface);

SDL_DFB_FREE(data);

SDL_DFB_FREE(window->shaper);

}

SDL_DFB_CHECK(windata->window_surface->SetFont(windata->window_surface, NULL));

SDL_DFB_CHECK(windata->surface->ReleaseSource(windata->surface));

SDL_DFB_CHECK(windata->window_surface->ReleaseSource(windata->window_surface));

SDL_DFB_RELEASE(windata->icon);

SDL_DFB_RELEASE(windata->font);

SDL_DFB_RELEASE(windata->eventbuffer);

SDL_DFB_RELEASE(windata->surface);

SDL_DFB_RELEASE(windata->window_surface);

/* Remove from list ... */

p = devdata->firstwin->driverdata;

while (p && p->next != window)

p = (p->next ? p->next->driverdata : NULL);

if (p)

p->next = windata->next;

else

devdata->firstwin = windata->next;

SDL_free(windata);

return;

}

SDL_bool

DirectFB_GetWindowWMInfo(_THIS, SDL_Window * window,

struct SDL_SysWMinfo * info)

{

SDL_DFB_DEVICEDATA(_this);

SDL_DFB_WINDOWDATA(window);

if (info->version.major == SDL_MAJOR_VERSION &&

info->version.minor == SDL_MINOR_VERSION) {

info->subsystem = SDL_SYSWM_DIRECTFB;

info->info.dfb.dfb = devdata->dfb;

info->info.dfb.window = windata->dfbwin;

info->info.dfb.surface = windata->surface;

return SDL_TRUE;

} else {

SDL_SetError("Application not compiled with SDL %d.%d\n",

SDL_MAJOR_VERSION, SDL_MINOR_VERSION);

return SDL_FALSE;

}

void

DirectFB_AdjustWindowSurface(SDL_Window * window)

{

SDL_DFB_WINDOWDATA(window);

int adjust = windata->wm_needs_redraw;

int cw, ch;

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) {

#endif

#if (DFB_VERSION_ATLEAST(1,2,1))

SDL_DFB_CHECKERR(windata->dfbwin->ResizeSurface(windata->dfbwin,

windata->size.w,

windata->size.h));

windata->

window_surface,

&windata->client));

DFBWindowOptions opts;

/* recreate subsurface */

SDL_DFB_RELEASE(windata->surface);

if (opts & DWOP_SCALE)

windata->size.w,

windata->size.h));

SDL_DFB_CHECKERR(windata->window_surface->

GetSubSurface(windata->window_surface,

&windata->client, &windata->surface));

#if SDL_DIRECTFB_OPENGL

#endif

}

error:

return;

}