void DirectFB_GetDisplayModes(_THIS, SDL_VideoDisplay * display) { SDL_DFB_DEVICEDATA(_this); DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata; SDL_DisplayMode mode; struct modes_callback_t data; int i; 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)); for (i = 0; i < data.nummodes; ++i) { mode = data.modelist[i]; mode.format = SDL_PIXELFORMAT_ARGB8888; CheckSetDisplayMode(_this, display, dispdata, &mode); mode.format = SDL_PIXELFORMAT_RGB888; CheckSetDisplayMode(_this, display, dispdata, &mode); mode.format = SDL_PIXELFORMAT_RGB24; CheckSetDisplayMode(_this, display, dispdata, &mode); mode.format = SDL_PIXELFORMAT_RGB565; CheckSetDisplayMode(_this, display, dispdata, &mode); mode.format = SDL_PIXELFORMAT_INDEX8; CheckSetDisplayMode(_this, display, dispdata, &mode); } SDL_DFB_FREE(data.modelist); error: return; }
static SDL_keysym * DirectFB_TranslateKeyInputEvent(_THIS, int index, DFBInputEvent * evt, SDL_keysym * keysym) { SDL_DFB_DEVICEDATA(_this); 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 (evt->key_id - DIKI_UNKNOWN < SDL_arraysize(oskeymap)) keysym->scancode = oskeymap[evt->key_id - DIKI_UNKNOWN]; else keysym->scancode = SDL_SCANCODE_UNKNOWN; } 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)) keysym->unicode = evt->key_symbol; return keysym; }
void DirectFB_GL_SwapWindow(_THIS, SDL_Window * window) { SDL_DFB_DEVICEDATA(_this); SDL_DFB_WINDOWDATA(window); int ret; DFBRegion region; region.x1 = 0; region.y1 = 0; region.x2 = window->w; region.y2 = window->h; if (devdata->glFinish) devdata->glFinish(); else if (devdata->glFlush) devdata->glFlush(); 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, ®ion, DSFLIP_ONSYNC)); /* SDL_DFB_CHECKERR(windata->gl_context->context->Lock(windata->gl_context->context)); */ } return; error: return; }
void DirectFB_DestroyWindow(_THIS, SDL_Window * window) { SDL_DFB_DEVICEDATA(_this); SDL_DFB_WINDOWDATA(window); DFB_WindowData *p; 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 ... */ p = devdata->firstwin; while (p && p->next != windata) p = p->next; if (p) p->next = windata->next; else devdata->firstwin = windata->next; SDL_free(windata); return; }
static void LoadFont(_THIS, SDL_Window * window) { SDL_DFB_DEVICEDATA(_this); SDL_DFB_WINDOWDATA(window); if (windata->font != NULL) { SDL_DFB_RELEASE(windata->font); windata->font = NULL; SDL_DFB_CHECK(windata->window_surface->SetFont(windata->window_surface, windata->font)); } if (windata->theme.font != NULL) { DFBFontDescription fdesc; SDL_zero(fdesc); fdesc.flags = DFDESC_HEIGHT; fdesc.height = windata->theme.font_size; SDL_DFB_CHECK(devdata-> dfb->CreateFont(devdata->dfb, windata->theme.font, &fdesc, &windata->font)); SDL_DFB_CHECK(windata->window_surface->SetFont(windata->window_surface, windata->font)); } }
void DirectFB_InitMouse(_THIS) { SDL_DFB_DEVICEDATA(_this); devdata->num_mice = 0; if (devdata->use_linux_input) { /* try non-core devices first */ id_mask = 0xF0; devdata->dfb->EnumInputDevices(devdata->dfb, EnumMice, devdata); if (devdata->num_mice == 0) { /* try core devices */ id_mask = 0x0F; devdata->dfb->EnumInputDevices(devdata->dfb, EnumMice, devdata); } } if (devdata->num_mice == 0) { SDL_Mouse mouse; SDL_zero(mouse); mouse.CreateCursor = DirectFB_CreateCursor; mouse.ShowCursor = DirectFB_ShowCursor; mouse.MoveCursor = DirectFB_MoveCursor; mouse.FreeCursor = DirectFB_FreeCursor; mouse.WarpMouse = DirectFB_WarpMouse; mouse.FreeMouse = DirectFB_FreeMouse; mouse.cursor_shown = 1; SDL_AddMouse(&mouse, "Mouse", 0, 0, 1); devdata->num_mice = 1; } }
void DirectFB_InitKeyboard(_THIS) { SDL_DFB_DEVICEDATA(_this); cb_data cb; DirectFB_InitOSKeymap(_this, &oskeymap[0], SDL_arraysize(oskeymap)); devdata->num_keyboard = 0; cb.devdata = devdata; if (devdata->use_linux_input) { cb.sys_kbd = 0; cb.sys_ids = 0; SDL_DFB_CHECK(devdata->dfb-> EnumInputDevices(devdata->dfb, EnumKeyboards, &cb)); if (devdata->num_keyboard == 0) { cb.sys_ids = 1; SDL_DFB_CHECK(devdata->dfb->EnumInputDevices(devdata->dfb, EnumKeyboards, &cb)); } } else { cb.sys_kbd = 1; SDL_DFB_CHECK(devdata->dfb->EnumInputDevices(devdata->dfb, EnumKeyboards, &cb)); } }
static void CheckSetDisplayMode(_THIS, SDL_VideoDisplay * display, DFB_DisplayData * data, SDL_DisplayMode * mode) { SDL_DFB_DEVICEDATA(_this); DFBDisplayLayerConfig config; DFBDisplayLayerConfigFlags failed; SDL_DFB_CHECKERR(data->layer->SetCooperativeLevel(data->layer, DLSCL_ADMINISTRATIVE)); config.width = mode->w; config.height = mode->h; config.pixelformat = DirectFB_SDLToDFBPixelFormat(mode->format); config.flags = DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT; if (devdata->use_yuv_underlays) { config.flags |= DLCONF_OPTIONS; config.options = DLOP_ALPHACHANNEL; } failed = 0; data->layer->TestConfiguration(data->layer, &config, &failed); SDL_DFB_CHECKERR(data->layer->SetCooperativeLevel(data->layer, DLSCL_SHARED)); if (failed == 0) { SDL_AddDisplayMode(display, mode); SDL_DFB_LOG("Mode %d x %d Added\n", mode->w, mode->h); } else SDL_DFB_ERR("Mode %d x %d not available: %x\n", mode->w, mode->h, failed); return; error: return; }
static int DirectFB_AcquireVidLayer(SDL_Renderer * renderer, SDL_Texture * texture) { //SDL_DFB_RENDERERDATA(renderer); SDL_Window *window = renderer->window; SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window); SDL_DFB_DEVICEDATA(display->device); DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata; DirectFB_TextureData *data = texture->driverdata; DFBDisplayLayerConfig layconf; DFBResult ret; if (devdata->use_yuv_direct && (dispdata->vidID >= 0) && (!dispdata->vidIDinuse) && SDL_ISPIXELFORMAT_FOURCC(data->format)) { layconf.flags = DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT | DLCONF_SURFACE_CAPS; layconf.width = texture->w; layconf.height = texture->h; layconf.pixelformat = DirectFB_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)); 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)); dispdata->vidIDinuse = 1; data->display = display; return 0; } return 1; error: if (dispdata->vidlayer) { SDL_DFB_RELEASE(data->surface); SDL_DFB_CHECKERR(dispdata-> vidlayer->SetCooperativeLevel(dispdata->vidlayer, DLSCL_ADMINISTRATIVE)); SDL_DFB_RELEASE(dispdata->vidlayer); } return 1; }
void DirectFB_QuitMouse(_THIS) { SDL_DFB_DEVICEDATA(_this); if (devdata->use_linux_input) { SDL_MouseQuit(); } else { SDL_DelMouse(0); } }
static int KbdIndex(_THIS, int id) { SDL_DFB_DEVICEDATA(_this); int index; for (index = 0; index < devdata->num_keyboard; index++) { if (devdata->keyboard[index].id == id) return index; } return -1; }
static SDL_Cursor * DirectFB_CreateDefaultCursor(void) { SDL_VideoDevice *dev = SDL_GetVideoDevice(); SDL_DFB_DEVICEDATA(dev); DFB_CursorData *curdata; DFBResult ret; DFBSurfaceDescription dsc; SDL_Cursor *cursor; Uint32 *dest; Uint32 *p; int pitch, i, j; SDL_DFB_ALLOC_CLEAR( cursor, sizeof(*cursor)); SDL_DFB_ALLOC_CLEAR(curdata, sizeof(*curdata)); dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS; dsc.caps = DSCAPS_VIDEOONLY; dsc.width = 32; dsc.height = 32; dsc.pixelformat = DSPF_ARGB; SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc, &curdata->surf)); curdata->hotx = 0; curdata->hoty = 0; cursor->driverdata = curdata; 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. */ for (i = 0; i < 32; i++) { for (j = 0; j < 32; j++) { switch (arrow[i][j]) { case ' ': dest[j] = 0x00000000; break; case '.': dest[j] = 0xffffffff; break; case 'X': dest[j] = 0xff000000; break; } } dest += (pitch >> 2); } curdata->surf->Unlock(curdata->surf); return cursor; error: return NULL; }
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; }
static void FocusAllKeyboards(_THIS, SDL_Window *window) { #if USE_MULTI_API SDL_DFB_DEVICEDATA(_this); int index; for (index = 0; index < devdata->num_keyboard; index++) SDL_SetKeyboardFocus(index, id); #else SDL_SetKeyboardFocus(window); #endif }
static void FocusAllMice(_THIS, SDL_Window *window) { #if USE_MULTI_API SDL_DFB_DEVICEDATA(_this); int index; for (index = 0; index < devdata->num_mice; index++) SDL_SetMouseFocus(devdata->mouse_id[index], id); #else SDL_SetMouseFocus(window); #endif }
static void MotionAllMice(_THIS, int x, int y) { #if USE_MULTI_API SDL_DFB_DEVICEDATA(_this); int index; for (index = 0; index < devdata->num_mice; index++) { SDL_Mouse *mouse = SDL_GetMouse(index); mouse->x = mouse->last_x = x; mouse->y = mouse->last_y = y; //SDL_SendMouseMotion(devdata->mouse_id[index], 0, x, y, 0); } #endif }
int DirectFB_GL_LoadLibrary(_THIS, const char *path) { SDL_DFB_DEVICEDATA(_this); void *handle = NULL; SDL_DFB_DEBUG("Loadlibrary : %s\n", path); if (_this->gl_data->gl_active) { SDL_SetError("OpenGL context already created"); return -1; } if (path == NULL) { path = SDL_getenv("SDL_VIDEO_GL_DRIVER"); if (path == NULL) { path = "libGL.so"; } } handle = GL_LoadObject(path); if (handle == NULL) { SDL_DFB_ERR("Library not found: %s\n", path); /* SDL_LoadObject() will call SDL_SetError() for us. */ return -1; } SDL_DFB_DEBUG("Loaded library: %s\n", path); /* Unload the old driver and reset the pointers */ DirectFB_GL_UnloadLibrary(_this); _this->gl_config.dll_handle = handle; _this->gl_config.driver_loaded = 1; if (path) { SDL_strlcpy(_this->gl_config.driver_path, path, SDL_arraysize(_this->gl_config.driver_path)); } else { *_this->gl_config.driver_path = '\0'; } devdata->glFinish = DirectFB_GL_GetProcAddress(_this, "glFinish"); devdata->glFlush = DirectFB_GL_GetProcAddress(_this, "glFlush"); return 0; }
void DirectFB_DestroyWindow(_THIS, SDL_Window * window) { SDL_DFB_DEVICEDATA(_this); SDL_DFB_WINDOWDATA(window); DFB_WindowData *p; /* Some cleanups */ 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); SDL_DFB_RELEASE(windata->dfbwin); /* 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; }
void DirectFB_InitMouse(_THIS) { SDL_DFB_DEVICEDATA(_this); SDL_Mouse *mouse = SDL_GetMouse(); mouse->CreateCursor = DirectFB_CreateCursor; mouse->ShowCursor = DirectFB_ShowCursor; mouse->WarpMouse = DirectFB_WarpMouse; mouse->FreeCursor = DirectFB_FreeCursor; SDL_SetDefaultCursor(DirectFB_CreateDefaultCursor()); devdata->num_mice = 1; }
/* Create a cursor from a surface */ static SDL_Cursor * DirectFB_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y) { SDL_VideoDevice *dev = SDL_GetVideoDevice(); SDL_DFB_DEVICEDATA(dev); DFB_CursorData *curdata; DFBResult ret; DFBSurfaceDescription dsc; SDL_Cursor *cursor; Uint32 *dest; Uint32 *p; int pitch, i; SDL_assert(surface->format->format == SDL_PIXELFORMAT_ARGB8888); SDL_assert(surface->pitch == surface->w * 4); SDL_DFB_ALLOC_CLEAR( cursor, sizeof(*cursor)); SDL_DFB_ALLOC_CLEAR(curdata, sizeof(*curdata)); 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, &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)); p = surface->pixels; for (i = 0; i < surface->h; i++) memcpy((char *) dest + i * pitch, (char *) p + i * surface->pitch, 4 * surface->w); curdata->surf->Unlock(curdata->surf); return cursor; error: return NULL; }
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; } }
SDL_bool DirectFB_GetWindowWMInfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo * info) { const Uint32 version = ((((Uint32) info->version.major) * 1000000) + (((Uint32) info->version.minor) * 10000) + (((Uint32) info->version.patch))); SDL_DFB_DEVICEDATA(_this); SDL_DFB_WINDOWDATA(window); /* Before 2.0.6, it was possible to build an SDL with DirectFB support (SDL_SysWMinfo will be large enough to hold DirectFB info), but build your app against SDL headers that didn't have DirectFB support (SDL_SysWMinfo could be smaller than DirectFB needs. This would lead to an app properly using SDL_GetWindowWMInfo() but we'd accidentally overflow memory on the stack or heap. To protect against this, we've padded out the struct unconditionally in the headers and DirectFB will just return an error for older apps using this function. Those apps will need to be recompiled against newer headers or not use DirectFB, maybe by forcing SDL_VIDEODRIVER=x11. */ if (version < 2000006) { info->subsystem = SDL_SYSWM_UNKNOWN; SDL_SetError("Version must be 2.0.6 or newer"); return SDL_FALSE; } 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", SDL_MAJOR_VERSION, SDL_MINOR_VERSION); return SDL_FALSE; } }
void DirectFB_SetWindowGrab(_THIS, SDL_Window * window) { SDL_DFB_DEVICEDATA(_this); SDL_DFB_WINDOWDATA(window); DFB_WindowData *gwindata = ((devdata->grabbed_window) ? (DFB_WindowData *) ((devdata->grabbed_window)->driverdata) : NULL); if ((window->flags & SDL_WINDOW_INPUT_GRABBED)) { 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)); devdata->grabbed_window = window; } else { SDL_DFB_CHECK(windata->dfbwin->UngrabPointer(windata->dfbwin)); SDL_DFB_CHECK(windata->dfbwin->UngrabKeyboard(windata->dfbwin)); devdata->grabbed_window = NULL; } }
void DirectFB_SetWindowSize(_THIS, SDL_Window * window) { SDL_DFB_DEVICEDATA(_this); SDL_DFB_WINDOWDATA(window); int ret; if (!(window->flags & SDL_WINDOW_FULLSCREEN)) { 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(DirectFB_WM_GetClientSize(_this, window, &cw, &ch)); 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); } return; error: windata->window->EnableEvents(windata->window, DWET_ALL); return; }
void DirectFB_PumpEventsWindow(_THIS) { SDL_DFB_DEVICEDATA(_this); DFB_WindowData *p; DFBInputEvent ievt; for (p = devdata->firstwin; p != NULL; p = p->next) { DFBWindowEvent evt; SDL_Window *w = p->sdl_window; while (p->eventbuffer->GetEvent(p->eventbuffer, DFB_EVENT(&evt)) == DFB_OK) { 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) { ProcessInputEvent(_this, &ievt); } }
int DirectFB_CreateWindow(_THIS, SDL_Window * window) { SDL_DFB_DEVICEDATA(_this); SDL_DFB_DISPLAYDATA(window); DFB_WindowData *windata = NULL; DFBWindowOptions wopts; DFBWindowDescription desc; int x, y; int bshaped = 0; SDL_DFB_ALLOC_CLEAR(window->driverdata, sizeof(DFB_WindowData)); windata = (DFB_WindowData *) window->driverdata; windata->is_managed = devdata->has_own_wm; #if 1 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; /* Fill the window description. */ x = window->x; y = window->y; DirectFB_WM_AdjustWindowLayout(window, window->flags, window->w, window->h); /* Create Window */ desc.caps = 0; desc.flags = 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; /* Create the window. */ SDL_DFB_CHECKERR(dispdata->layer->CreateWindow(dispdata->layer, &desc, &windata->dfbwin)); /* Set Options */ SDL_DFB_CHECK(windata->dfbwin->GetOptions(windata->dfbwin, &wopts)); /* explicit rescaling of surface */ wopts |= DWOP_SCALE; if (window->flags & SDL_WINDOW_RESIZABLE) { wopts &= ~DWOP_KEEP_SIZE; } else { wopts |= DWOP_KEEP_SIZE; } if (window->flags & SDL_WINDOW_FULLSCREEN) { wopts |= DWOP_KEEP_POSITION | DWOP_KEEP_STACKING | DWOP_KEEP_SIZE; 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 */ SDL_DFB_CHECK(DirectFB_WM_GetClientSize (_this, window, &window->w, &window->h)); /* Get the window's surface. */ SDL_DFB_CHECKERR(windata->dfbwin->GetSurface(windata->dfbwin, &windata->window_surface)); /* And get a subsurface for rendering */ SDL_DFB_CHECKERR(windata->window_surface-> GetSubSurface(windata->window_surface, &windata->client, &windata->surface)); SDL_DFB_CHECK(windata->dfbwin->SetOpacity(windata->dfbwin, 0xFF)); /* Create Eventbuffer */ 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 */ windata->font = NULL; /* Make it the top most window. */ SDL_DFB_CHECK(windata->dfbwin->RaiseToTop(windata->dfbwin)); /* remember parent */ //windata->sdlwin = window; /* Add to list ... */ windata->next = devdata->firstwin; windata->opacity = 0xFF; devdata->firstwin = window; /* Draw Frame */ DirectFB_WM_RedrawLayout(_this, window); return 0; error: SDL_DFB_RELEASE(windata->surface); SDL_DFB_RELEASE(windata->dfbwin); return -1; }
int DirectFB_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode) { /* * FIXME: video mode switch is currently broken for 1.2.0 * */ SDL_DFB_DEVICEDATA(_this); DFB_DisplayData *data = (DFB_DisplayData *) display->driverdata; DFBDisplayLayerConfig config, rconfig; DFBDisplayLayerConfigFlags fail = 0; 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; if (mode->format != SDL_PIXELFORMAT_UNKNOWN) { config.flags |= DLCONF_PIXELFORMAT; config.pixelformat = DirectFB_SDLToDFBPixelFormat(mode->format); data->pixelformat = config.pixelformat; } config.width = mode->w; config.height = mode->h; if (devdata->use_yuv_underlays) { config.flags |= DLCONF_OPTIONS; config.options = DLOP_ALPHACHANNEL; } data->layer->TestConfiguration(data->layer, &config, &fail); if (fail & (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; } config.flags &= ~fail; SDL_DFB_CHECKERR(data->layer->SetConfiguration(data->layer, &config)); #if (DFB_VERSION_ATLEAST(1,2,0)) /* Need to call this twice ! */ SDL_DFB_CHECKERR(data->layer->SetConfiguration(data->layer, &config)); #endif /* Double check */ SDL_DFB_CHECKERR(data->layer->GetConfiguration(data->layer, &rconfig)); 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))) { SDL_DFB_ERR("Error setting mode %dx%d-%x\n", mode->w, mode->h, mode->format); return -1; } data->pixelformat = rconfig.pixelformat; data->cw = config.width; data->ch = config.height; display->current_mode = *mode; return 0; error: return -1; }
int DirectFB_SetWindowShape(SDL_WindowShaper *shaper,SDL_Surface *shape,SDL_WindowShapeMode *shape_mode) { if(shaper == NULL || shape == NULL || shaper->driverdata == NULL) return -1; if(shape->format->Amask == 0 && SDL_SHAPEMODEALPHA(shape_mode->mode)) return -2; if(shape->w != shaper->window->w || shape->h != shaper->window->h) return -3; { SDL_VideoDisplay *display = SDL_GetDisplayForWindow(shaper->window); SDL_DFB_DEVICEDATA(display->device); Uint32 *pixels; Sint32 pitch; Uint32 h,w; Uint8 *src, *bitmap; DFBSurfaceDescription dsc; SDL_ShapeData *data = shaper->driverdata; SDL_DFB_RELEASE(data->surface); dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS; dsc.width = shape->w; dsc.height = shape->h; dsc.caps = DSCAPS_PREMULTIPLIED; dsc.pixelformat = DSPF_ARGB; SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc, &data->surface)); /* Assume that shaper->alphacutoff already has a value, because SDL_SetWindowShape() should have given it one. */ SDL_DFB_ALLOC_CLEAR(bitmap, shape->w * shape->h); SDL_CalculateShapeBitmap(shaper->mode,shape,bitmap,1); src = bitmap; SDL_DFB_CHECK(data->surface->Lock(data->surface, DSLF_WRITE | DSLF_READ, (void **) &pixels, &pitch)); h = shaper->window->h; while (h--) { for (w = 0; w < shaper->window->w; w++) { if (*src) pixels[w] = 0xFFFFFFFF; else pixels[w] = 0; src++; } pixels += (pitch >> 2); } SDL_DFB_CHECK(data->surface->Unlock(data->surface)); SDL_DFB_FREE(bitmap); /* FIXME: Need to call this here - Big ?? */ DirectFB_WM_RedrawLayout(SDL_GetDisplayForWindow(shaper->window)->device, shaper->window); } return 0; error: return -1; }
int DirectFB_WM_ProcessEvent(_THIS, SDL_Window * window, DFBWindowEvent * evt) { SDL_DFB_DEVICEDATA(_this); SDL_DFB_WINDOWDATA(window); DFB_WindowData *gwindata = ((devdata->grabbed_window) ? (DFB_WindowData *) ((devdata->grabbed_window)->driverdata) : NULL); IDirectFBWindow *dfbwin = windata->dfbwin; DFBWindowOptions wopts; if (!windata->is_managed) return 0; SDL_DFB_CHECK(dfbwin->GetOptions(dfbwin, &wopts)); 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: windata->wm_grab = WM_POS_NONE; SDL_SendWindowEvent(window, SDL_WINDOWEVENT_CLOSE, 0, 0); return 1; case WM_POS_MAX: windata->wm_grab = WM_POS_NONE; if (window->flags & SDL_WINDOW_MAXIMIZED) { SDL_RestoreWindow(window); } else { SDL_MaximizeWindow(window); } return 1; case WM_POS_CAPTION: if (!(wopts & DWOP_KEEP_STACKING)) { DirectFB_RaiseWindow(_this, window); } if (window->flags & SDL_WINDOW_MAXIMIZED) return 1; /* fall through */ default: windata->wm_grab = pos; if (gwindata != NULL) SDL_DFB_CHECK(gwindata->dfbwin->UngrabPointer(gwindata->dfbwin)); SDL_DFB_CHECK(dfbwin->GrabPointer(dfbwin)); windata->wm_lastx = evt->cx; windata->wm_lasty = evt->cy; } } return 1; case DWET_BUTTONUP: if (!windata->wm_grab) return 0; if (!(evt->buttons & DIBM_LEFT)) { if (windata->wm_grab & (WM_POS_RIGHT | WM_POS_BOTTOM)) { int dx = evt->cx - windata->wm_lastx; int dy = evt->cy - windata->wm_lasty; if (!(wopts & DWOP_KEEP_SIZE)) { int cw, ch; if ((windata->wm_grab & (WM_POS_BOTTOM | WM_POS_RIGHT)) == WM_POS_BOTTOM) dx = 0; else if ((windata->wm_grab & (WM_POS_BOTTOM | WM_POS_RIGHT)) == WM_POS_RIGHT) dy = 0; SDL_DFB_CHECK(dfbwin->GetSize(dfbwin, &cw, &ch)); /* necessary to trigger an event - ugly */ SDL_DFB_CHECK(dfbwin->DisableEvents(dfbwin, DWET_ALL)); SDL_DFB_CHECK(dfbwin->Resize(dfbwin, cw + dx + 1, ch + dy)); SDL_DFB_CHECK(dfbwin->EnableEvents(dfbwin, DWET_ALL)); SDL_DFB_CHECK(dfbwin->Resize(dfbwin, cw + dx, ch + dy)); } } SDL_DFB_CHECK(dfbwin->UngrabPointer(dfbwin)); if (gwindata != NULL) SDL_DFB_CHECK(gwindata->dfbwin->GrabPointer(gwindata->dfbwin)); windata->wm_grab = WM_POS_NONE; return 1; } break; case DWET_MOTION: if (!windata->wm_grab) return 0; if (evt->buttons & DIBM_LEFT) { int dx = evt->cx - windata->wm_lastx; int dy = evt->cy - windata->wm_lasty; if (windata->wm_grab & WM_POS_CAPTION) { if (!(wopts & DWOP_KEEP_POSITION)) SDL_DFB_CHECK(dfbwin->Move(dfbwin, dx, dy)); } if (windata->wm_grab & (WM_POS_RIGHT | WM_POS_BOTTOM)) { if (!(wopts & DWOP_KEEP_SIZE)) { int cw, ch; /* Make sure all events are disabled for this operation ! */ SDL_DFB_CHECK(dfbwin->DisableEvents(dfbwin, DWET_ALL)); if ((windata->wm_grab & (WM_POS_BOTTOM | WM_POS_RIGHT)) == WM_POS_BOTTOM) dx = 0; else if ((windata->wm_grab & (WM_POS_BOTTOM | WM_POS_RIGHT)) == WM_POS_RIGHT) dy = 0; SDL_DFB_CHECK(dfbwin->GetSize(dfbwin, &cw, &ch)); SDL_DFB_CHECK(dfbwin->Resize(dfbwin, cw + dx, ch + dy)); SDL_DFB_CHECK(dfbwin->EnableEvents(dfbwin, DWET_ALL)); } } windata->wm_lastx = evt->cx; windata->wm_lasty = evt->cy; return 1; } break; case DWET_KEYDOWN: break; case DWET_KEYUP: break; default: ; } return 0; }
static int DirectFB_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) { SDL_Window *window = renderer->window; SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window); SDL_DFB_DEVICEDATA(display->device); DirectFB_TextureData *data; DFBSurfaceDescription dsc; DFBSurfacePixelFormat pixelformat; DirectFB_ActivateRenderer(renderer); SDL_DFB_ALLOC_CLEAR(data, sizeof(*data)); texture->driverdata = data; /* find the right pixelformat */ pixelformat = DirectFB_SDLToDFBPixelFormat(texture->format); if (pixelformat == DSPF_UNKNOWN) { SDL_SetError("Unknown pixel format %d\n", data->format); goto error; } data->format = texture->format; data->pitch = texture->w * DFB_BYTES_PER_PIXEL(pixelformat); if (DirectFB_AcquireVidLayer(renderer, texture) != 0) { /* fill surface description */ dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS; dsc.width = texture->w; dsc.height = texture->h; if(texture->format == SDL_PIXELFORMAT_YV12 || texture->format == SDL_PIXELFORMAT_IYUV) { /* dfb has problems with odd sizes -make them even internally */ dsc.width += (dsc.width % 2); dsc.height += (dsc.height % 2); } /* <1.2 Never use DSCAPS_VIDEOONLY here. It kills performance * No DSCAPS_SYSTEMONLY either - let dfb decide * 1.2: DSCAPS_SYSTEMONLY boosts performance by factor ~8 * Depends on other settings as well. Let dfb decide. */ dsc.caps = DSCAPS_PREMULTIPLIED; #if 0 if (texture->access == SDL_TEXTUREACCESS_STREAMING) dsc.caps |= DSCAPS_SYSTEMONLY; else dsc.caps |= DSCAPS_VIDEOONLY; #endif dsc.pixelformat = pixelformat; data->pixels = NULL; /* Create the surface */ SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc, &data->surface)); if (SDL_ISPIXELFORMAT_INDEXED(data->format) && !SDL_ISPIXELFORMAT_FOURCC(data->format)) { #if 1 SDL_DFB_CHECKERR(data->surface->GetPalette(data->surface, &data->palette)); #else /* DFB has issues with blitting LUT8 surfaces. * Creating a new palette does not help. */ DFBPaletteDescription pal_desc; pal_desc.flags = DPDESC_SIZE; /* | DPDESC_ENTRIES */ pal_desc.size = 256; SDL_DFB_CHECKERR(devdata->dfb->CreatePalette(devdata->dfb, &pal_desc,&data->palette)); SDL_DFB_CHECKERR(data->surface->SetPalette(data->surface, data->palette)); #endif } } #if (DFB_VERSION_ATLEAST(1,2,0)) data->render_options = DSRO_NONE; #endif if (texture->access == SDL_TEXTUREACCESS_STREAMING) { /* 3 plane YUVs return 1 bpp, but we need more space for other planes */ if(texture->format == SDL_PIXELFORMAT_YV12 || texture->format == SDL_PIXELFORMAT_IYUV) { SDL_DFB_ALLOC_CLEAR(data->pixels, (texture->h * data->pitch + ((texture->h + texture->h % 2) * (data->pitch + data->pitch % 2) * 2) / 4)); } else { SDL_DFB_ALLOC_CLEAR(data->pixels, texture->h * data->pitch); } } return 0; error: SDL_DFB_RELEASE(data->palette); SDL_DFB_RELEASE(data->surface); SDL_DFB_FREE(texture->driverdata); return -1; }