GSoC/sdl-2.30.3-kolibri
2
0
Fork 1
mirror of https://github.com/arnavbhatt288/sdl-2.30.3-kolibri.git synced 2025-09-21 02:50:08 +02:00
Code Issues 3 Activity

add video subsystem

Browse Source 
Signed-off-by: Arnav Bhatt <arnav@ghativega.in>
This commit is contained in:
Arnav Bhatt
2024-06-17 04:56:51 +05:30
parent fac5afe2f6
commit 7608f7ba6d
14 changed files with 958 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Makefile
View File

@@ -80,8 +80,9 @@ video_OBJS = src/video/SDL_blit_0.o src/video/SDL_blit_1.o src/video/SDL_blit_A.
src/video/SDL_shape.o src/video/SDL_stretch.o src/video/SDL_surface.o \
src/video/SDL_video.o src/video/SDL_yuv.o src/video/yuv2rgb/yuv_rgb_lsx.o \
src/video/yuv2rgb/yuv_rgb_sse.o src/video/yuv2rgb/yuv_rgb_std.o \
src/video/dummy/SDL_nullevents.o src/video/dummy/SDL_nullframebuffer.o \
src/video/dummy/SDL_nullvideo.o
src/video/kolibri/SDL_kolibrievents.o src/video/kolibri/SDL_kolibriframebuffer.o \
src/video/kolibri/SDL_kolibrivideo.o src/video/kolibri/SDL_kolibriwindow.o \
src/video/kolibri/SDL_kolibrimouse.o
curr_OBJS = src/SDL_assert.o src/SDL_dataqueue.o src/SDL_error.o src/SDL_guid.o \
src/SDL_hints.o src/SDL_list.o src/SDL_log.o src/SDL_utils.o src/SDL.o

89
include/SDL_config_kolibri.h
View File

@@ -46,49 +46,48 @@
#define HAVE_TAN 1
#define HAVE_MALLOC 1
#define LACKS_SYS_MMAN_H 1
#define HAVE_MALLOC 1
#define HAVE_CALLOC 1
#define HAVE_REALLOC 1
#define HAVE_FREE 1
#define HAVE_ALLOCA 1
#define HAVE_QSORT 1
#define HAVE_BSEARCH 1
#define HAVE_ABS 1
#define HAVE_BCOPY 1
#define HAVE_MEMCPY 1
#define HAVE_STRTOL 1
#define HAVE_STRTOUL 1
#define HAVE_STRTOLL 1
#define HAVE_STRTOULL 1
#define HAVE_ATOI 1
#define HAVE_ATOF 1
#define HAVE_VSSCANF 1
#define HAVE_VSNPRINTF 1
#define HAVE_M_PI 1
#define HAVE_CEIL 1
#define HAVE_COPYSIGN 1
#define HAVE_COS 1
#define HAVE_COSF 1
#define HAVE_EXP 1
#define HAVE_FABS 1
#define HAVE_FLOOR 1
#define HAVE_LOG 1
#define HAVE_LOG10 1
#define HAVE_LROUND 1
#define HAVE_LROUNDF 1
#define HAVE_ROUND 1
#define HAVE_ROUNDF 1
#define HAVE_SCALBN 1
#define HAVE_SIN 1
#define HAVE_SINF 1
#define HAVE_SQRT 1
#define HAVE_SQRTF 1
#define HAVE_TAN 1
#define HAVE_TANF 1
#define HAVE_TRUNC 1
#define HAVE_TRUNCF 1
#define HAVE_SETJMP 1
#define HAVE_MALLOC 1
#define HAVE_CALLOC 1
#define HAVE_REALLOC 1
#define HAVE_FREE 1
#define HAVE_ALLOCA 1
#define HAVE_QSORT 1
#define HAVE_BSEARCH 1
#define HAVE_ABS 1
#define HAVE_BCOPY 1
#define HAVE_MEMCPY 1
#define HAVE_STRTOL 1
#define HAVE_STRTOUL 1
#define HAVE_STRTOLL 1
#define HAVE_STRTOULL 1
#define HAVE_ATOI 1
#define HAVE_ATOF 1
#define HAVE_VSSCANF 1
#define HAVE_VSNPRINTF 1
#define HAVE_M_PI 1
#define HAVE_CEIL 1
#define HAVE_COPYSIGN 1
#define HAVE_COS 1
#define HAVE_COSF 1
#define HAVE_EXP 1
#define HAVE_FABS 1
#define HAVE_FLOOR 1
#define HAVE_LOG 1
#define HAVE_LOG10 1
#define HAVE_LROUND 1
#define HAVE_LROUNDF 1
#define HAVE_ROUND 1
#define HAVE_ROUNDF 1
#define HAVE_SCALBN 1
#define HAVE_SIN 1
#define HAVE_SINF 1
#define HAVE_SQRT 1
#define HAVE_SQRTF 1
#define HAVE_TAN 1
#define HAVE_TANF 1
#define HAVE_TRUNC 1
#define HAVE_TRUNCF 1
#define HAVE_SETJMP 1
/* Enable the dummy thread support (src/thread/dummy/\*.c) */
#define SDL_THREADS_DISABLED 1
@@ -96,8 +95,8 @@
/* Enable the dummy timer support (src/timer/dummy/\*.c) */
#define SDL_TIMER_DUMMY 1
/* Enable the dummy video driver (src/video/dummy/\*.c) */
#define SDL_VIDEO_DRIVER_DUMMY 1
/* Enable the Kolibri video driver (src/video/kolibri/\*.c) */
#define SDL_VIDEO_DRIVER_KOLIBRI 1
/* Enable the Kolibri audio driver (src/audio/kolibri/\*.c) */
#define SDL_AUDIO_DRIVER_KOLIBRI 1

85
src/video/SDL_sysvideo.h
View File

@@ -24,10 +24,10 @@
#define SDL_sysvideo_h_
#include "SDL_messagebox.h"
#include "SDL_metal.h"
#include "SDL_mouse.h"
#include "SDL_shape.h"
#include "SDL_thread.h"
#include "SDL_metal.h"
#include "SDL_vulkan_internal.h"
@@ -95,7 +95,7 @@ struct SDL_Window
float brightness;
Uint16 *gamma;
Uint16 *saved_gamma; /* (just offset into gamma) */
Uint16 *saved_gamma; /* (just offset into gamma) */
SDL_Surface *surface;
SDL_bool surface_valid;
@@ -235,32 +235,32 @@ struct SDL_VideoDevice
void (*SetWindowMaximumSize)(_THIS, SDL_Window *window);
int (*GetWindowBordersSize)(_THIS, SDL_Window *window, int *top, int *left, int *bottom, int *right);
void (*GetWindowSizeInPixels)(_THIS, SDL_Window *window, int *w, int *h);
int (*SetWindowOpacity) (_THIS, SDL_Window * window, float opacity);
int (*SetWindowModalFor) (_THIS, SDL_Window * modal_window, SDL_Window * parent_window);
int (*SetWindowInputFocus) (_THIS, SDL_Window * window);
void (*ShowWindow) (_THIS, SDL_Window * window);
void (*HideWindow) (_THIS, SDL_Window * window);
void (*RaiseWindow) (_THIS, SDL_Window * window);
void (*MaximizeWindow) (_THIS, SDL_Window * window);
void (*MinimizeWindow) (_THIS, SDL_Window * window);
void (*RestoreWindow) (_THIS, SDL_Window * window);
void (*SetWindowBordered) (_THIS, SDL_Window * window, SDL_bool bordered);
void (*SetWindowResizable) (_THIS, SDL_Window * window, SDL_bool resizable);
void (*SetWindowAlwaysOnTop) (_THIS, SDL_Window * window, SDL_bool on_top);
void (*SetWindowFullscreen) (_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen);
int (*SetWindowGammaRamp) (_THIS, SDL_Window * window, const Uint16 * ramp);
int (*GetWindowGammaRamp) (_THIS, SDL_Window * window, Uint16 * ramp);
void* (*GetWindowICCProfile) (_THIS, SDL_Window * window, size_t* size);
int (*GetWindowDisplayIndex)(_THIS, SDL_Window * window);
void (*SetWindowMouseRect)(_THIS, SDL_Window * window);
void (*SetWindowMouseGrab) (_THIS, SDL_Window * window, SDL_bool grabbed);
void (*SetWindowKeyboardGrab) (_THIS, SDL_Window * window, SDL_bool grabbed);
void (*DestroyWindow) (_THIS, SDL_Window * window);
int (*CreateWindowFramebuffer) (_THIS, SDL_Window * window, Uint32 * format, void ** pixels, int *pitch);
int (*UpdateWindowFramebuffer) (_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects);
void (*DestroyWindowFramebuffer) (_THIS, SDL_Window * window);
void (*OnWindowEnter) (_THIS, SDL_Window * window);
int (*FlashWindow) (_THIS, SDL_Window * window, SDL_FlashOperation operation);
int (*SetWindowOpacity)(_THIS, SDL_Window *window, float opacity);
int (*SetWindowModalFor)(_THIS, SDL_Window *modal_window, SDL_Window *parent_window);
int (*SetWindowInputFocus)(_THIS, SDL_Window *window);
void (*ShowWindow)(_THIS, SDL_Window *window);
void (*HideWindow)(_THIS, SDL_Window *window);
void (*RaiseWindow)(_THIS, SDL_Window *window);
void (*MaximizeWindow)(_THIS, SDL_Window *window);
void (*MinimizeWindow)(_THIS, SDL_Window *window);
void (*RestoreWindow)(_THIS, SDL_Window *window);
void (*SetWindowBordered)(_THIS, SDL_Window *window, SDL_bool bordered);
void (*SetWindowResizable)(_THIS, SDL_Window *window, SDL_bool resizable);
void (*SetWindowAlwaysOnTop)(_THIS, SDL_Window *window, SDL_bool on_top);
void (*SetWindowFullscreen)(_THIS, SDL_Window *window, SDL_VideoDisplay *display, SDL_bool fullscreen);
int (*SetWindowGammaRamp)(_THIS, SDL_Window *window, const Uint16 *ramp);
int (*GetWindowGammaRamp)(_THIS, SDL_Window *window, Uint16 *ramp);
void *(*GetWindowICCProfile)(_THIS, SDL_Window *window, size_t *size);
int (*GetWindowDisplayIndex)(_THIS, SDL_Window *window);
void (*SetWindowMouseRect)(_THIS, SDL_Window *window);
void (*SetWindowMouseGrab)(_THIS, SDL_Window *window, SDL_bool grabbed);
void (*SetWindowKeyboardGrab)(_THIS, SDL_Window *window, SDL_bool grabbed);
void (*DestroyWindow)(_THIS, SDL_Window *window);
int (*CreateWindowFramebuffer)(_THIS, SDL_Window *window, Uint32 *format, void **pixels, int *pitch);
int (*UpdateWindowFramebuffer)(_THIS, SDL_Window *window, const SDL_Rect *rects, int numrects);
void (*DestroyWindowFramebuffer)(_THIS, SDL_Window *window);
void (*OnWindowEnter)(_THIS, SDL_Window *window);
int (*FlashWindow)(_THIS, SDL_Window *window, SDL_FlashOperation operation);
/* * * */
/*
@@ -269,24 +269,24 @@ struct SDL_VideoDevice
SDL_ShapeDriver shape_driver;
/* Get some platform dependent window information */
SDL_bool(*GetWindowWMInfo) (_THIS, SDL_Window * window,
struct SDL_SysWMinfo * info);
SDL_bool (*GetWindowWMInfo)(_THIS, SDL_Window *window,
struct SDL_SysWMinfo *info);
/* * * */
/*
* OpenGL support
*/
int (*GL_LoadLibrary) (_THIS, const char *path);
void *(*GL_GetProcAddress) (_THIS, const char *proc);
void (*GL_UnloadLibrary) (_THIS);
SDL_GLContext(*GL_CreateContext) (_THIS, SDL_Window * window);
int (*GL_MakeCurrent) (_THIS, SDL_Window * window, SDL_GLContext context);
void (*GL_GetDrawableSize) (_THIS, SDL_Window * window, int *w, int *h);
int (*GL_SetSwapInterval) (_THIS, int interval);
int (*GL_GetSwapInterval) (_THIS);
int (*GL_SwapWindow) (_THIS, SDL_Window * window);
void (*GL_DeleteContext) (_THIS, SDL_GLContext context);
void (*GL_DefaultProfileConfig) (_THIS, int *mask, int *major, int *minor);
int (*GL_LoadLibrary)(_THIS, const char *path);
void *(*GL_GetProcAddress)(_THIS, const char *proc);
void (*GL_UnloadLibrary)(_THIS);
SDL_GLContext (*GL_CreateContext)(_THIS, SDL_Window *window);
int (*GL_MakeCurrent)(_THIS, SDL_Window *window, SDL_GLContext context);
void (*GL_GetDrawableSize)(_THIS, SDL_Window *window, int *w, int *h);
int (*GL_SetSwapInterval)(_THIS, int interval);
int (*GL_GetSwapInterval)(_THIS);
int (*GL_SwapWindow)(_THIS, SDL_Window *window);
void (*GL_DeleteContext)(_THIS, SDL_GLContext context);
void (*GL_DefaultProfileConfig)(_THIS, int *mask, int *major, int *minor);
/* * * */
/*
@@ -452,7 +452,7 @@ typedef struct VideoBootStrap
const char *name;
const char *desc;
SDL_VideoDevice *(*create)(void);
int (*ShowMessageBox)(const SDL_MessageBoxData *messageboxdata, int *buttonid); /* can be done without initializing backend! */
int (*ShowMessageBox)(const SDL_MessageBoxData *messageboxdata, int *buttonid); /* can be done without initializing backend! */
} VideoBootStrap;
/* Not all of these are available in a given build. Use #ifdefs, etc. */
@@ -484,6 +484,7 @@ extern VideoBootStrap OFFSCREEN_bootstrap;
extern VideoBootStrap NGAGE_bootstrap;
extern VideoBootStrap OS2DIVE_bootstrap;
extern VideoBootStrap OS2VMAN_bootstrap;
extern VideoBootStrap KOLIBRI_bootstrap;
/* Use SDL_OnVideoThread() sparingly, to avoid regressions in use cases that currently happen to work */
extern SDL_bool SDL_OnVideoThread(void);

103
src/video/SDL_video.c
View File

@@ -23,14 +23,14 @@
/* The high-level video driver subsystem */
#include "../events/SDL_events_c.h"
#include "../timer/SDL_timer_c.h"
#include "SDL.h"
#include "SDL_video.h"
#include "SDL_sysvideo.h"
#include "SDL_blit.h"
#include "SDL_pixels_c.h"
#include "SDL_rect_c.h"
#include "../events/SDL_events_c.h"
#include "../timer/SDL_timer_c.h"
#include "SDL_sysvideo.h"
#include "SDL_video.h"
#include "SDL_syswm.h"
@@ -58,10 +58,10 @@
#endif
#ifdef __LINUX__
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dlfcn.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#endif
/* Available video drivers */
@@ -144,6 +144,9 @@ static VideoBootStrap *bootstrap[] = {
#ifdef SDL_INPUT_LINUXEV
&DUMMY_evdev_bootstrap,
#endif
#endif
#ifdef SDL_VIDEO_DRIVER_KOLIBRI
&KOLIBRI_bootstrap,
#endif
NULL
};
@@ -173,8 +176,8 @@ static VideoBootStrap *bootstrap[] = {
#if defined(__MACOSX__) && defined(SDL_VIDEO_DRIVER_COCOA)
/* Support for Mac OS X fullscreen spaces */
extern SDL_bool Cocoa_IsWindowInFullscreenSpace(SDL_Window * window);
extern SDL_bool Cocoa_SetWindowFullscreenSpace(SDL_Window * window, SDL_bool state);
extern SDL_bool Cocoa_IsWindowInFullscreenSpace(SDL_Window *window);
extern SDL_bool Cocoa_SetWindowFullscreenSpace(SDL_Window *window, SDL_bool state);
#endif
/* Convenience functions for reading driver flags */
@@ -473,15 +476,15 @@ int SDL_VideoInit(const char *driver_name)
if (!driver_name) {
/* See if it looks like we need X11 */
SDL_bool force_x11 = SDL_FALSE;
void *global_symbols = dlopen(NULL, RTLD_LOCAL|RTLD_NOW);
void *global_symbols = dlopen(NULL, RTLD_LOCAL | RTLD_NOW);
/* Use linked libraries to detect what quirks we are likely to need */
if (global_symbols != NULL) {
if (dlsym(global_symbols, "glxewInit") != NULL) { /* GLEW (e.g. Frogatto, SLUDGE) */
if (dlsym(global_symbols, "glxewInit") != NULL) { /* GLEW (e.g. Frogatto, SLUDGE) */
force_x11 = SDL_TRUE;
} else if (dlsym(global_symbols, "cgGLEnableProgramProfiles") != NULL) { /* NVIDIA Cg (e.g. Awesomenauts, Braid) */
} else if (dlsym(global_symbols, "cgGLEnableProgramProfiles") != NULL) { /* NVIDIA Cg (e.g. Awesomenauts, Braid) */
force_x11 = SDL_TRUE;
} else if (dlsym(global_symbols, "_Z7ssgInitv") != NULL) { /* ::ssgInit(void) in plib (e.g. crrcsim) */
} else if (dlsym(global_symbols, "_Z7ssgInitv") != NULL) { /* ::ssgInit(void) in plib (e.g. crrcsim) */
force_x11 = SDL_TRUE;
}
dlclose(global_symbols);
@@ -496,7 +499,7 @@ int SDL_VideoInit(const char *driver_name)
while (driver_attempt && *driver_attempt != 0 && !video) {
const char *driver_attempt_end = SDL_strchr(driver_attempt, ',');
size_t driver_attempt_len = (driver_attempt_end) ? (driver_attempt_end - driver_attempt)
: SDL_strlen(driver_attempt);
: SDL_strlen(driver_attempt);
for (i = 0; bootstrap[i]; ++i) {
if ((driver_attempt_len == SDL_strlen(bootstrap[i]->name)) &&
@@ -1046,8 +1049,8 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di
}
SDL_DisplayMode *SDL_GetClosestDisplayMode(int displayIndex,
const SDL_DisplayMode *mode,
SDL_DisplayMode *closest)
const SDL_DisplayMode *mode,
SDL_DisplayMode *closest)
{
SDL_VideoDisplay *display;
@@ -1228,7 +1231,7 @@ int SDL_GetWindowDisplayIndex(SDL_Window *window)
return displayIndex;
}
displayIndex = GetRectDisplayIndex(window->x, window->y, window->w, window->h);
displayIndex = GetRectDisplayIndex(window->x, window->y, window->w, window->h);
/* Find the display containing the window if fullscreen */
for (i = 0; i < _this->num_displays; ++i) {
@@ -2786,7 +2789,7 @@ int SDL_UpdateWindowSurfaceRects(SDL_Window *window, const SDL_Rect *rects,
return _this->UpdateWindowFramebuffer(_this, window, rects, numrects);
}
int SDL_SetWindowBrightness(SDL_Window * window, float brightness)
int SDL_SetWindowBrightness(SDL_Window *window, float brightness)
{
Uint16 ramp[256];
int status;
@@ -2801,14 +2804,14 @@ int SDL_SetWindowBrightness(SDL_Window * window, float brightness)
return status;
}
float SDL_GetWindowBrightness(SDL_Window * window)
float SDL_GetWindowBrightness(SDL_Window *window)
{
CHECK_WINDOW_MAGIC(window, 1.0f);
return window->brightness;
}
int SDL_SetWindowOpacity(SDL_Window * window, float opacity)
int SDL_SetWindowOpacity(SDL_Window *window, float opacity)
{
int retval;
CHECK_WINDOW_MAGIC(window, -1);
@@ -2878,10 +2881,9 @@ int SDL_SetWindowInputFocus(SDL_Window *window)
return _this->SetWindowInputFocus(_this, window);
}
int SDL_SetWindowGammaRamp(SDL_Window * window, const Uint16 * red,
const Uint16 * green,
const Uint16 * blue)
int SDL_SetWindowGammaRamp(SDL_Window *window, const Uint16 *red,
const Uint16 *green,
const Uint16 *blue)
{
CHECK_WINDOW_MAGIC(window, -1);
@@ -2897,13 +2899,13 @@ int SDL_SetWindowGammaRamp(SDL_Window * window, const Uint16 * red,
}
if (red) {
SDL_memcpy(&window->gamma[0*256], red, 256*sizeof(Uint16));
SDL_memcpy(&window->gamma[0 * 256], red, 256 * sizeof(Uint16));
}
if (green) {
SDL_memcpy(&window->gamma[1*256], green, 256*sizeof(Uint16));
SDL_memcpy(&window->gamma[1 * 256], green, 256 * sizeof(Uint16));
}
if (blue) {
SDL_memcpy(&window->gamma[2*256], blue, 256*sizeof(Uint16));
SDL_memcpy(&window->gamma[2 * 256], blue, 256 * sizeof(Uint16));
}
if (window->flags & SDL_WINDOW_INPUT_FOCUS) {
return _this->SetWindowGammaRamp(_this, window, window->gamma);
@@ -2912,20 +2914,20 @@ int SDL_SetWindowGammaRamp(SDL_Window * window, const Uint16 * red,
}
}
int SDL_GetWindowGammaRamp(SDL_Window * window, Uint16 * red,
Uint16 * green,
Uint16 * blue)
int SDL_GetWindowGammaRamp(SDL_Window *window, Uint16 *red,
Uint16 *green,
Uint16 *blue)
{
CHECK_WINDOW_MAGIC(window, -1);
if (!window->gamma) {
int i;
window->gamma = (Uint16 *)SDL_malloc(256*6*sizeof(Uint16));
window->gamma = (Uint16 *)SDL_malloc(256 * 6 * sizeof(Uint16));
if (!window->gamma) {
return SDL_OutOfMemory();
}
window->saved_gamma = window->gamma + 3*256;
window->saved_gamma = window->gamma + 3 * 256;
if (_this->GetWindowGammaRamp) {
if (_this->GetWindowGammaRamp(_this, window, window->gamma) < 0) {
@@ -2936,27 +2938,27 @@ int SDL_GetWindowGammaRamp(SDL_Window * window, Uint16 * red,
for (i = 0; i < 256; ++i) {
Uint16 value = (Uint16)((i << 8) | i);
window->gamma[0*256+i] = value;
window->gamma[1*256+i] = value;
window->gamma[2*256+i] = value;
window->gamma[0 * 256 + i] = value;
window->gamma[1 * 256 + i] = value;
window->gamma[2 * 256 + i] = value;
}
}
SDL_memcpy(window->saved_gamma, window->gamma, 3*256*sizeof(Uint16));
SDL_memcpy(window->saved_gamma, window->gamma, 3 * 256 * sizeof(Uint16));
}
if (red) {
SDL_memcpy(red, &window->gamma[0*256], 256*sizeof(Uint16));
SDL_memcpy(red, &window->gamma[0 * 256], 256 * sizeof(Uint16));
}
if (green) {
SDL_memcpy(green, &window->gamma[1*256], 256*sizeof(Uint16));
SDL_memcpy(green, &window->gamma[1 * 256], 256 * sizeof(Uint16));
}
if (blue) {
SDL_memcpy(blue, &window->gamma[2*256], 256*sizeof(Uint16));
SDL_memcpy(blue, &window->gamma[2 * 256], 256 * sizeof(Uint16));
}
return 0;
}
void SDL_UpdateWindowGrab(SDL_Window * window)
void SDL_UpdateWindowGrab(SDL_Window *window)
{
SDL_bool keyboard_grabbed, mouse_grabbed;
@@ -3202,7 +3204,7 @@ static SDL_bool ShouldMinimizeOnFocusLoss(SDL_Window *window)
}
#if defined(__MACOSX__) && defined(SDL_VIDEO_DRIVER_COCOA)
if (SDL_strcmp(_this->name, "cocoa") == 0) { /* don't do this for X11, etc */
if (SDL_strcmp(_this->name, "cocoa") == 0) { /* don't do this for X11, etc */
if (Cocoa_IsWindowInFullscreenSpace(window)) {
return SDL_FALSE;
}
@@ -3984,10 +3986,10 @@ int SDL_GL_GetAttribute(SDL_GLattr attr, int *value)
return 0;
}
case SDL_GL_CONTEXT_NO_ERROR:
{
*value = _this->gl_config.no_error;
return 0;
}
{
*value = _this->gl_config.no_error;
return 0;
}
default:
return SDL_SetError("Unknown OpenGL attribute");
}
@@ -4129,7 +4131,7 @@ SDL_GLContext SDL_GL_GetCurrentContext(void)
return (SDL_GLContext)SDL_TLSGet(_this->current_glctx_tls);
}
void SDL_GL_GetDrawableSize(SDL_Window * window, int *w, int *h)
void SDL_GL_GetDrawableSize(SDL_Window *window, int *w, int *h)
{
CHECK_WINDOW_MAGIC(window, );
@@ -4296,7 +4298,7 @@ void SDL_WM_SetIcon(SDL_Surface * icon, Uint8 * mask)
}
#endif
SDL_bool SDL_GetWindowWMInfo(SDL_Window * window, struct SDL_SysWMinfo *info)
SDL_bool SDL_GetWindowWMInfo(SDL_Window *window, struct SDL_SysWMinfo *info)
{
CHECK_WINDOW_MAGIC(window, SDL_FALSE);
@@ -4456,7 +4458,7 @@ int SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
while (driver_attempt && (*driver_attempt != 0) && (retval == -1)) {
const char *driver_attempt_end = SDL_strchr(driver_attempt, ',');
size_t driver_attempt_len = (driver_attempt_end) ? (driver_attempt_end - driver_attempt)
: SDL_strlen(driver_attempt);
: SDL_strlen(driver_attempt);
for (i = 0; bootstrap[i]; ++i) {
if (bootstrap[i]->ShowMessageBox && (driver_attempt_len == SDL_strlen(bootstrap[i]->name)) &&
(SDL_strncasecmp(bootstrap[i]->name, driver_attempt, driver_attempt_len) == 0)) {
@@ -4513,10 +4515,7 @@ int SDL_ShowSimpleMessageBox(Uint32 flags, const char *title, const char *messag
if (!message) {
message = "";
}
EM_ASM({
alert(UTF8ToString($0) + "\n\n" + UTF8ToString($1));
},
title, message);
EM_ASM({ alert(UTF8ToString($0) + "\n\n" + UTF8ToString($1)); }, title, message);
return 0;
#else
SDL_MessageBoxData data;

357
src/video/kolibri/SDL_kolibrievents.c Normal file
View File

@@ -0,0 +1,357 @@
#include "../../SDL_internal.h"
#ifdef SDL_VIDEO_DRIVER_KOLIBRI
#include <sys/ksys.h>
#include "SDL.h"
#include "../../events/SDL_events_c.h"
#include "../../events/SDL_keyboard_c.h"
#include "../SDL_sysvideo.h"
#include "SDL_kolibrievents.h"
#include "SDL_kolibrivideo.h"
#include "SDL_kolibriwindow.h"
static SDL_Keycode sdlkeys[0x80] = {
// 0x0*
0, SDLK_ESCAPE, SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5, SDLK_6,
SDLK_7, SDLK_8, SDLK_9, SDLK_0, SDLK_MINUS, SDLK_EQUALS, SDLK_BACKSPACE, SDLK_TAB,
// 0x1*
SDLK_q, SDLK_w, SDLK_e, SDLK_r, SDLK_t, SDLK_y, SDLK_u, SDLK_i,
SDLK_o, SDLK_p, SDLK_LEFTBRACKET, SDLK_RIGHTBRACKET, SDLK_RETURN, SDLK_LCTRL, SDLK_a, SDLK_s,
// 0x2*
SDLK_d, SDLK_f, SDLK_g, SDLK_h, SDLK_j, SDLK_k, SDLK_l, SDLK_SEMICOLON,
SDLK_QUOTE, SDLK_BACKQUOTE, SDLK_LSHIFT, SDLK_BACKSLASH, SDLK_z, SDLK_x, SDLK_c, SDLK_v,
// 0x3*
SDLK_b, SDLK_n, SDLK_m, SDLK_COMMA, SDLK_PERIOD, SDLK_SLASH, SDLK_RSHIFT, SDLK_KP_MULTIPLY,
SDLK_LALT, SDLK_SPACE, SDLK_CAPSLOCK, SDLK_F1, SDLK_F2, SDLK_F3, SDLK_F4, SDLK_F5,
// 0x4*
SDLK_F6, SDLK_F7, SDLK_F8, SDLK_F9, SDLK_F10, SDLK_NUMLOCKCLEAR, SDLK_SCROLLLOCK, SDLK_KP_7,
SDLK_KP_8, SDLK_KP_9, SDLK_KP_MINUS, SDLK_KP_4, SDLK_KP_5, SDLK_KP_6, SDLK_KP_PLUS, SDLK_KP_1,
// 0x5*
SDLK_KP_2, SDLK_KP_3, SDLK_KP_0, SDLK_KP_PERIOD, 0, 0, 0, SDLK_F11,
SDLK_F12, 0, 0, 0, 0, 0, 0, 0,
// 0x6*
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
// 0x7*
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
};
static SDL_Keycode sdlkeys_shift[0x80] = {
// 0x0*
0, SDLK_ESCAPE, SDLK_EXCLAIM, SDLK_AT, SDLK_HASH, SDLK_DOLLAR, '%', SDLK_CARET,
SDLK_AMPERSAND, SDLK_ASTERISK, SDLK_LEFTPAREN, SDLK_RIGHTPAREN, SDLK_UNDERSCORE, SDLK_PLUS, SDLK_BACKSPACE, SDLK_TAB,
// 0x1*
SDLK_q, SDLK_w, SDLK_e, SDLK_r, SDLK_t, SDLK_y, SDLK_u, SDLK_i,
SDLK_o, SDLK_p, '{', '}', SDLK_RETURN, SDLK_LCTRL, SDLK_a, SDLK_s,
// 0x2*
SDLK_d, SDLK_f, SDLK_g, SDLK_h, SDLK_j, SDLK_k, SDLK_l, SDLK_COLON,
SDLK_QUOTEDBL, '~', SDLK_LSHIFT, '|', SDLK_z, SDLK_x, SDLK_c, SDLK_v,
// 0x3*
SDLK_b, SDLK_n, SDLK_m, SDLK_LESS, SDLK_GREATER, SDLK_QUESTION, SDLK_RSHIFT, SDLK_KP_MULTIPLY,
SDLK_LALT, SDLK_SPACE, SDLK_CAPSLOCK, SDLK_F1, SDLK_F2, SDLK_F3, SDLK_F4, SDLK_F5,
// 0x4*
SDLK_F6, SDLK_F7, SDLK_F8, SDLK_F9, SDLK_F10, SDLK_NUMLOCKCLEAR, SDLK_SCROLLLOCK, SDLK_KP_7,
SDLK_KP_8, SDLK_KP_9, SDLK_KP_MINUS, SDLK_KP_4, SDLK_KP_5, SDLK_KP_6, SDLK_KP_PLUS, SDLK_KP_1,
// 0x5*
SDLK_KP_2, SDLK_KP_3, SDLK_KP_0, SDLK_KP_PERIOD, 0, 0, 0, SDLK_F11,
SDLK_F12, 0, 0, 0, 0, 0, 0, 0,
// 0x6*
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
// 0x7*
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0
};
static SDL_Keycode sdlkeys_e0[0x80] = {
// 0x0*
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
// 0x1*
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
SDLK_KP_ENTER,
SDLK_RCTRL,
0,
0,
// 0x2*
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
// 0x3*
0,
0,
0,
0,
0,
SDLK_KP_DIVIDE,
0,
SDLK_PRINTSCREEN,
SDLK_RALT,
0,
0,
0,
0,
0,
0,
0,
// 0x4*
0,
0,
0,
0,
0,
0,
0,
SDLK_HOME,
SDLK_UP,
SDLK_PAGEUP,
0,
SDLK_LEFT,
0,
SDLK_RIGHT,
0,
SDLK_END,
// 0x5*
SDLK_DOWN,
SDLK_PAGEDOWN,
SDLK_INSERT,
SDLK_DELETE,
0,
0,
0,
0,
0,
0,
0,
0,
0,
SDLK_MENU,
0,
0,
// 0x6*
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
// 0x7*
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
static SDL_Keymod SDL_KOLIBRI_get_mod_state(void)
{
unsigned controlstate = _ksys_get_control_key_state();
SDL_Keymod res = 0;
if (controlstate & KSYS_CONTROL_LSHIFT)
res |= KMOD_LSHIFT;
if (controlstate & KSYS_CONTROL_RSHIFT)
res |= KMOD_RSHIFT;
if (controlstate & KSYS_CONTROL_LCTRL)
res |= KMOD_LCTRL;
if (controlstate & KSYS_CONTROL_RCTRL)
res |= KMOD_RCTRL;
if (controlstate & KSYS_CONTROL_LALT)
res |= KMOD_LALT;
if (controlstate & KSYS_CONTROL_RALT)
res |= KMOD_RALT;
if (controlstate & KSYS_CONTROL_CAPS)
res |= KMOD_CAPS;
if (controlstate & KSYS_CONTROL_NUM_LOCK)
res |= KMOD_NUM;
return res;
}
void KOLIBRI_InitOSKeymap(void)
{
_ksys_set_key_input_mode(KSYS_KEY_INPUT_MODE_SCANC);
}
extern void kos_CheckMouseMode(_THIS);
void KOLIBRI_PumpEvents(_THIS)
{
SDL_VideoData *data = (SDL_VideoData *)_this->driverdata;
SDL_Window *window = SDL_GetWindowFromID(data->window_id);
uint32_t kos_event;
ksys_pos_t mouse_pos;
ksys_pos_t center_pos;
ksys_thread_t thread_info;
int scancode = 0;
int pressed = 0;
SDL_Keycode keycode = SDLK_UNKNOWN;
SDL_Keymod mod = 0;
static int ext_code = 0;
static uint8_t old_mode = 0;
static uint32_t old_mouse_but = 0;
while (1) {
kos_event = _ksys_check_event();
switch (kos_event) {
case KSYS_EVENT_NONE:
return;
case KSYS_EVENT_REDRAW:
KOLIBRI_RepaintWnd(_this);
break;
case KSYS_EVENT_KEY:
scancode = _ksys_get_key().code;
if (scancode == 0xE0 || scancode == 0xE1) {
ext_code = scancode;
break;
}
if (ext_code == 0xE1 && (scancode & 0x7F) == 0x1D) {
break;
}
if (ext_code == 0xE1 && scancode == 0xC5) {
ext_code = 0;
break;
}
mod = SDL_KOLIBRI_get_mod_state();
if (ext_code == 0xE1)
mod &= ~KMOD_CTRL;
if (!(scancode & 0x80))
old_mode = mod;
SDL_SetModState(mod);
pressed = (scancode & 0x80) ? SDL_RELEASED : SDL_PRESSED;
scancode &= 0x7F;
if (ext_code == 0xE1 && scancode == 0x45)
keycode = SDLK_PAUSE;
else if (ext_code == 0xE0)
keycode = sdlkeys_e0[scancode];
else if (old_mode & KMOD_SHIFT)
keycode = sdlkeys_shift[scancode];
else
keycode = sdlkeys[scancode];
ext_code = 0;
if (!keycode)
break;
SDL_SendKeyboardKey(pressed, SDL_GetScancodeFromKey(keycode));
break;
case KSYS_EVENT_BUTTON:
if (_ksys_get_button() == 1)
exit(0);
break;
case KSYS_EVENT_MOUSE:
{
mouse_pos = _ksys_get_mouse_pos(KSYS_MOUSE_WINDOW_POS);
if (mouse_pos.x >= 0 && mouse_pos.x < window->w && mouse_pos.y >= 0 && mouse_pos.y < window->h || SDL_GetMouse()->relative_mode) {
if (SDL_GetMouse()->relative_mode) {
center_pos.x = mouse_pos.x - window->w / 2;
center_pos.y = mouse_pos.y - window->h / 2;
if (center_pos.x || center_pos.y) {
SDL_SendMouseMotion(window, 0, SDL_TRUE, center_pos.x, center_pos.y);
int top = _ksys_thread_info(&thread_info, KSYS_THIS_SLOT);
if (top == thread_info.pos_in_window_stack) {
int x = thread_info.winx_start + thread_info.clientx + window->w / 2;
int y = thread_info.winy_start + thread_info.clienty + window->h / 2;
_ksys_set_mouse_pos(x, y);
}
}
} else
SDL_SendMouseMotion(window, 0, SDL_FALSE, mouse_pos.x, mouse_pos.y);
uint32_t mouse_but = _ksys_get_mouse_buttons();
if ((mouse_but ^ old_mouse_but) & KSYS_MOUSE_LBUTTON_PRESSED) {
if (mouse_but & KSYS_MOUSE_LBUTTON_PRESSED)
SDL_SendMouseButton(window, 0, SDL_PRESSED, SDL_BUTTON_LEFT);
else
SDL_SendMouseButton(window, 0, SDL_RELEASED, SDL_BUTTON_LEFT);
}
if ((mouse_but ^ old_mouse_but) & KSYS_MOUSE_RBUTTON_PRESSED) {
if (mouse_but & KSYS_MOUSE_RBUTTON_PRESSED)
SDL_SendMouseButton(window, 0, SDL_PRESSED, SDL_BUTTON_RIGHT);
else
SDL_SendMouseButton(window, 0, SDL_RELEASED, SDL_BUTTON_RIGHT);
}
if ((mouse_but ^ old_mouse_but) & KSYS_MOUSE_MBUTTON_PRESSED) {
if (mouse_but & KSYS_MOUSE_MBUTTON_PRESSED)
SDL_SendMouseButton(window, 0, SDL_PRESSED, SDL_BUTTON_MIDDLE);
else
SDL_SendMouseButton(window, 0, SDL_RELEASED, SDL_BUTTON_MIDDLE);
}
old_mouse_but = mouse_but;
}
}
}
}
}
#endif

10
src/video/kolibri/SDL_kolibrievents.h Normal file
View File

@@ -0,0 +1,10 @@
#ifndef SDL_kolibrievents_c_h_
#define SDL_kolibrievents_c_h_
#include "../../SDL_internal.h"
extern void KOLIBRI_InitOSKeymap(void);
extern void KOLIBRI_PumpEvents(_THIS);
#endif

70
src/video/kolibri/SDL_kolibriframebuffer.c Normal file
View File

@@ -0,0 +1,70 @@
#include "../../SDL_internal.h"
#ifdef SDL_VIDEO_DRIVER_KOLIBRI
#include <sys/ksys.h>
#include "SDL.h"
#include "../SDL_sysvideo.h"
#include "SDL_kolibriframebuffer.h"
#include "SDL_kolibrivideo.h"
#include "SDL_kolibriwindow.h"
void FreeOldFramebuffer(SDL_Window *window)
{
SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
SDL_FreeSurface(data->surface);
}
int SDL_KOLIBRI_CreateWindowFramebuffer(_THIS, SDL_Window *window, Uint32 *format, void **pixels, int *pitch)
{
SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
SDL_Surface *surface;
const Uint32 surface_format = SDL_PIXELFORMAT_RGB24;
int w, h;
/* Free the old framebuffer surface */
FreeOldFramebuffer(window);
/* Create a new one */
SDL_GetWindowSizeInPixels(window, &w, &h);
surface = SDL_CreateRGBSurfaceWithFormat(0, w, h, 0, surface_format);
if (!surface)
return -1;
/* Save the info and return! */
data->surface = surface;
*format = surface_format;
*pixels = surface->pixels;
*pitch = surface->pitch;
return 0;
}
int SDL_KOLIBRI_UpdateWindowFramebuffer(_THIS, SDL_Window *window, const SDL_Rect *rects, int numrects)
{
SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
SDL_Surface *surface;
static int frame_number;
surface = data->surface;
if (!surface)
return SDL_SetError("Couldn't find surface for window");
/* Send the data to the display */
_ksys_draw_bitmap(surface->pixels, 0, 0, surface->w, surface->h);
}
void SDL_KOLIBRI_DestroyWindowFramebuffer(_THIS, SDL_Window *window)
{
SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
SDL_Surface *surface;
SDL_FreeSurface(data->surface);
data->surface = NULL;
}
#endif

11
src/video/kolibri/SDL_kolibriframebuffer.h Normal file
View File

@@ -0,0 +1,11 @@
#include "../../SDL_internal.h"
#ifndef SDL_kolibriframebuffer_h_
#define SDL_kolibriframebuffer_h_
extern int SDL_KOLIBRI_CreateWindowFramebuffer(_THIS, SDL_Window *window, Uint32 *format, void **pixels, int *pitch);
extern int SDL_KOLIBRI_UpdateWindowFramebuffer(_THIS, SDL_Window *window, const SDL_Rect *rects, int numrects);
extern void SDL_KOLIBRI_DestroyWindowFramebuffer(_THIS, SDL_Window *window);
#endif

141
src/video/kolibri/SDL_kolibrimouse.c Normal file
View File

@@ -0,0 +1,141 @@
#include "../../SDL_internal.h"
#ifdef SDL_VIDEO_DRIVER_KOLIBRI
#include <sys/ksys.h>
#include "SDL_hints.h"
#include "SDL_surface.h"
#include "../../events/SDL_mouse_c.h"
#include "../../events/default_cursor.h"
#include "../SDL_sysvideo.h"
#include "SDL_kolibrimouse.h"
#include "SDL_kolibrivideo.h"
static SDL_Cursor *KOLIBRI_CreateDefaultCursor(void)
{
KOLIBRI_CursorData *curdata;
SDL_Cursor *cursor;
Uint32 *temp;
cursor = (SDL_Cursor *)SDL_calloc(1, sizeof(*cursor));
if (!cursor) {
SDL_OutOfMemory();
return NULL;
}
curdata = (KOLIBRI_CursorData *)SDL_calloc(1, sizeof(*curdata));
if (!curdata) {
SDL_OutOfMemory();
SDL_free(cursor);
return NULL;
}
/* Convert default SDL cursor to 32x32 */
temp = (Uint32 *)SDL_malloc(32 * 32 * 4);
if (!temp)
return NULL;
for (int i = 0; i < 32; i++) {
for (int j = 0; j < 32; j++) {
if (i >= 16 || j >= 16) {
temp[i * 32 + j] = 0x00000000;
continue;
}
if (default_cmask[i * 16 / 8 + j / 8] & (0x80 >> (j & 7)))
temp[i * 32 + j] = (default_cdata[i * 16 / 8 + j / 8] & (0x80 >> (j & 7)))
? 0xFF000000
: 0xFFFFFFFF;
else
temp[i * 32 + j] = 0x00000000;
}
}
curdata->cursor = _ksys_load_cursor(temp, (DEFAULT_CHOTX << 24) + (DEFAULT_CHOTY << 16) + KSYS_CURSOR_INDIRECT);
cursor->driverdata = curdata;
SDL_free(temp);
return cursor;
}
/* Create a cursor from a surface */
static SDL_Cursor *KOLIBRI_CreateCursor(SDL_Surface *surface, int hot_x, int hot_y)
{
KOLIBRI_CursorData *curdata;
SDL_Cursor *cursor;
int i, j;
/* Size of cursor must be 32x32 */
if (surface->w == 32 || surface->h == 32) {
SDL_SetError("Size of the cursor must be 32x32");
return NULL;
}
cursor = (SDL_Cursor *)SDL_calloc(1, sizeof(*cursor));
if (!cursor) {
SDL_OutOfMemory();
return NULL;
}
curdata = (KOLIBRI_CursorData *)SDL_calloc(1, sizeof(*curdata));
if (!curdata) {
SDL_OutOfMemory();
SDL_free(cursor);
return NULL;
}
curdata->cursor = _ksys_load_cursor(surface->pixels, (hot_x << 24) + (hot_y << 16) + KSYS_CURSOR_INDIRECT);
cursor->driverdata = curdata;
return cursor;
}
static int KOLIBRI_ShowCursor(SDL_Cursor *cursor)
{
KOLIBRI_CursorData *curdata;
if (cursor) {
curdata = (KOLIBRI_CursorData *)cursor->driverdata;
if (!curdata->cursor) {
if (!curdata->has_null_cursor) {
unsigned *u = SDL_malloc(32 * 32 * 4);
if (!u)
return 0;
SDL_memset(u, 0, 32 * 32 * 4);
curdata->null_cursor = _ksys_load_cursor(u, KSYS_CURSOR_INDIRECT);
free(u);
curdata->has_null_cursor = 1;
}
curdata->cursor = curdata->null_cursor;
}
_ksys_set_cursor(curdata->cursor);
}
return 0;
}
static void KOLIBRI_FreeCursor(SDL_Cursor *cursor)
{
KOLIBRI_CursorData *curdata;
if (cursor) {
curdata = (KOLIBRI_CursorData *)cursor->driverdata;
if (curdata) {
SDL_free(curdata->cursor);
SDL_free(curdata);
}
SDL_free(cursor);
}
}
void KOLIBRI_InitMouse(void)
{
SDL_Mouse *mouse = SDL_GetMouse();
mouse->CreateCursor = KOLIBRI_CreateCursor;
mouse->ShowCursor = KOLIBRI_ShowCursor;
mouse->FreeCursor = KOLIBRI_FreeCursor;
SDL_SetDefaultCursor(KOLIBRI_CreateDefaultCursor());
}
#endif

16
src/video/kolibri/SDL_kolibrimouse.h Normal file
View File

@@ -0,0 +1,16 @@
#include "../../SDL_internal.h"
#ifndef SDL_kolibrimouse_h_
#define SDL_kolibrimouse_h_
typedef struct _KOLIBRI_CursorData
{
int has_null_cursor;
void *cursor;
void *null_cursor;
} KOLIBRI_CursorData;
extern void KOLIBRI_InitMouse(void);
#endif

110
src/video/kolibri/SDL_kolibrivideo.c Normal file
View File

@@ -0,0 +1,110 @@
#include "../../SDL_internal.h"
#ifdef SDL_VIDEO_DRIVER_KOLIBRI
#include <sys/ksys.h>
#include "../../events/SDL_events_c.h"
#include "../SDL_pixels_c.h"
#include "../SDL_sysvideo.h"
#include "SDL_video.h"
#include "SDL_kolibrievents.h"
#include "SDL_kolibriframebuffer.h"
#include "SDL_kolibrimouse.h"
#include "SDL_kolibrivideo.h"
#include "SDL_kolibriwindow.h"
#define KOLIBRIVID_DRIVER_NAME "kolibri"
static void KOLIBRI_DeleteDevice(SDL_VideoDevice *device)
{
SDL_free(device->driverdata);
SDL_free(device);
}
int KOLIBRI_VideoInit(_THIS)
{
SDL_DisplayMode mode;
SDL_VideoData *data = _this->driverdata;
data->screen_size = _ksys_screen_size();
/* Use 24-bpp desktop mode */
mode.format = SDL_PIXELFORMAT_RGB24;
mode.w = data->screen_size.x;
mode.h = data->screen_size.y;
mode.refresh_rate = 0;
mode.driverdata = NULL;
if (SDL_AddBasicVideoDisplay(&mode) < 0)
return -1;
SDL_zero(mode);
SDL_AddDisplayMode(&_this->displays[0], &mode);
KOLIBRI_InitMouse();
KOLIBRI_InitOSKeymap();
/* We're done! */
return 0;
}
static int KOLIBRI_SetDisplayMode(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode)
{
return 0;
}
void KOLIBRI_VideoQuit(_THIS)
{
}
static SDL_VideoDevice *KOLIBRI_CreateDevice(void)
{
SDL_VideoDevice *device;
SDL_VideoData *data;
/* Initialize all variables that we clean on shutdown */
device = (SDL_VideoDevice *)SDL_calloc(1, sizeof(SDL_VideoDevice));
if (!device) {
SDL_OutOfMemory();
return 0;
}
/* Initialize internal Kolibri specific data */
data = (SDL_VideoData *)SDL_calloc(1, sizeof(SDL_VideoData));
if (!data) {
SDL_OutOfMemory();
SDL_free(device);
return 0;
}
/* General video */
device->VideoInit = KOLIBRI_VideoInit;
device->VideoQuit = KOLIBRI_VideoQuit;
device->SetDisplayMode = KOLIBRI_SetDisplayMode;
device->PumpEvents = KOLIBRI_PumpEvents;
device->free = KOLIBRI_DeleteDevice;
/* Framebuffer */
device->CreateWindowFramebuffer = SDL_KOLIBRI_CreateWindowFramebuffer;
device->UpdateWindowFramebuffer = SDL_KOLIBRI_UpdateWindowFramebuffer;
device->DestroyWindowFramebuffer = SDL_KOLIBRI_DestroyWindowFramebuffer;
/* "Window" */
device->CreateSDLWindow = KOLIBRI_CreateWindow;
device->SetWindowTitle = KOLIBRI_SetWindowTitle;
device->DestroyWindow = KOLIBRI_DestroyWindow;
/* KolibriOS specific data */
device->driverdata = data;
return device;
}
VideoBootStrap KOLIBRI_bootstrap = {
KOLIBRIVID_DRIVER_NAME, "SDL kolibri video driver",
KOLIBRI_CreateDevice,
NULL /* no ShowMessageBox implementation */
};
#endif

11
src/video/kolibri/SDL_kolibrivideo.h Normal file
View File

@@ -0,0 +1,11 @@
#ifndef _SDL_kolibri_video_h
#define _SDL_kolibri_video_h
typedef struct SDL_VideoData
{
Uint32 window_id;
ksys_pos_t screen_size;
} SDL_VideoData;
#endif

73
src/video/kolibri/SDL_kolibriwindow.c Normal file
View File

@@ -0,0 +1,73 @@
#include "../../SDL_internal.h"
#ifdef SDL_VIDEO_DRIVER_KOLIBRI
#include <sys/ksys.h>
#include "../../events/SDL_keyboard_c.h"
#include "../../events/SDL_mouse_c.h"
#include "../SDL_sysvideo.h"
#include "SDL_kolibrivideo.h"
#include "SDL_kolibriwindow.h"
#define WINDOW_BORDER_H 4
#define WINDOW_BORDER_W 9
void KOLIBRI_RepaintWnd(_THIS)
{
SDL_VideoData *data = (SDL_VideoData *)_this->driverdata;
SDL_Window *window = SDL_GetWindowFromID(data->window_id);
SDL_WindowData *wdata = (SDL_WindowData *)window->driverdata;
int win_pos_x, win_pos_y;
int win_size_w, win_size_h;
win_size_w = window->w + WINDOW_BORDER_W;
win_size_h = window->h + _ksys_get_skin_height() + WINDOW_BORDER_H;
win_pos_x = data->screen_size.x / 2 - win_size_w / 2;
win_pos_y = data->screen_size.y / 2 - win_size_h / 2;
_ksys_start_draw();
_ksys_create_window(win_pos_x, win_pos_y, win_size_w, win_size_h, window->title, 0, 0x34);
if (wdata->surface->pixels)
_ksys_draw_bitmap(wdata->surface->pixels, 0, 0, wdata->surface->w, wdata->surface->h);
_ksys_end_draw();
}
int KOLIBRI_CreateWindow(_THIS, SDL_Window *window)
{
SDL_VideoData *data = (SDL_VideoData *)_this->driverdata;
SDL_WindowData *wdata;
/* Allocate window internal data */
wdata = (SDL_WindowData *)SDL_calloc(1, sizeof(SDL_WindowData));
if (!wdata)
return SDL_OutOfMemory();
/* Setup driver data for this window */
window->driverdata = wdata;
data->window_id = SDL_GetWindowID(window);
_ksys_set_event_mask(0x27);
KOLIBRI_RepaintWnd(_this);
SDL_SetMouseFocus(window);
SDL_SetKeyboardFocus(window);
return 0;
}
void KOLIBRI_SetWindowTitle(_THIS, SDL_Window *window)
{
_ksys_set_window_title(window->title);
}
void KOLIBRI_DestroyWindow(_THIS, SDL_Window *window)
{
if (!window)
return;
SDL_free(window->driverdata);
}
#endif

18
src/video/kolibri/SDL_kolibriwindow.h Normal file
View File

@@ -0,0 +1,18 @@
#include "../../SDL_internal.h"
#ifndef SDL_kolibriwindow_h_
#define SDL_kolibriwindow_h_
typedef struct SDL_WindowData
{
SDL_Surface *surface;
} SDL_WindowData;
extern int KOLIBRI_CreateWindow(_THIS, SDL_Window *window);
extern void KOLIBRI_RepaintWnd(_THIS);
extern void KOLIBRI_SetWindowTitle(_THIS, SDL_Window *window);
extern void KOLIBRI_DestroyWindow(_THIS, SDL_Window *window);
#endif