Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-10-19 16:03:29 +00:00
Code Issues Projects Releases Packages Wiki Activity

Fix compiling SDL without DBus under Linux

Browse source 
(cherry picked from commit 03eb42642c)
This commit is contained in:
Kaleb Reid 2025-10-01 23:28:31 -07:00 • committed by Rémi Verschelde
parent bcd06b478a
commit b891558050
No known key found for this signature in database
GPG key ID: C3336907360768E1
11 changed files with 1 additions and 1787 deletions
Download patch file Download diff file Expand all files Collapse all files

4
drivers/sdl/SCsub
View file

@ -126,10 +126,6 @@ if env["builtin_sdl"]:
"core/linux/SDL_evdev.c",
"core/linux/SDL_evdev_capabilities.c",
"core/linux/SDL_evdev_kbd.c",
"core/linux/SDL_fcitx.c",
"core/linux/SDL_ibus.c",
"core/linux/SDL_ime.c",
"core/linux/SDL_system_theme.c",
"core/linux/SDL_threadprio.c",
"core/linux/SDL_udev.c",
"core/unix/SDL_appid.c",

414
thirdparty/sdl/core/linux/SDL_fcitx.c vendored
View file

@ -1,414 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2025 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_internal.h"
#include <unistd.h>
#include "SDL_fcitx.h"
//#include "../../video/SDL_sysvideo.h"
#include "SDL_dbus.h"
#ifdef SDL_VIDEO_DRIVER_X11
#include "../../video/x11/SDL_x11video.h"
#endif
#define FCITX_DBUS_SERVICE "org.freedesktop.portal.Fcitx"
#define FCITX_IM_DBUS_PATH "/org/freedesktop/portal/inputmethod"
#define FCITX_IM_DBUS_INTERFACE "org.fcitx.Fcitx.InputMethod1"
#define FCITX_IC_DBUS_INTERFACE "org.fcitx.Fcitx.InputContext1"
#define DBUS_TIMEOUT 500
typedef struct FcitxClient
{
SDL_DBusContext *dbus;
char *ic_path;
int id;
SDL_Rect cursor_rect;
} FcitxClient;
static FcitxClient fcitx_client;
static char *GetAppName(void)
{
#if defined(SDL_PLATFORM_LINUX) || defined(SDL_PLATFORM_FREEBSD)
char *spot;
char procfile[1024];
char linkfile[1024];
int linksize;
#ifdef SDL_PLATFORM_LINUX
(void)SDL_snprintf(procfile, sizeof(procfile), "/proc/%d/exe", getpid());
#elif defined(SDL_PLATFORM_FREEBSD)
(void)SDL_snprintf(procfile, sizeof(procfile), "/proc/%d/file", getpid());
#endif
linksize = readlink(procfile, linkfile, sizeof(linkfile) - 1);
if (linksize > 0) {
linkfile[linksize] = '\0';
spot = SDL_strrchr(linkfile, '/');
if (spot) {
return SDL_strdup(spot + 1);
} else {
return SDL_strdup(linkfile);
}
}
#endif // SDL_PLATFORM_LINUX || SDL_PLATFORM_FREEBSD
return SDL_strdup("SDL_App");
}
static size_t Fcitx_GetPreeditString(SDL_DBusContext *dbus,
DBusMessage *msg,
char **ret,
Sint32 *start_pos,
Sint32 *end_pos)
{
char *text = NULL, *subtext;
size_t text_bytes = 0;
DBusMessageIter iter, array, sub;
Sint32 p_start_pos = -1;
Sint32 p_end_pos = -1;
dbus->message_iter_init(msg, &iter);
// Message type is a(si)i, we only need string part
if (dbus->message_iter_get_arg_type(&iter) == DBUS_TYPE_ARRAY) {
size_t pos = 0;
// First pass: calculate string length
dbus->message_iter_recurse(&iter, &array);
while (dbus->message_iter_get_arg_type(&array) == DBUS_TYPE_STRUCT) {
dbus->message_iter_recurse(&array, &sub);
subtext = NULL;
if (dbus->message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING) {
dbus->message_iter_get_basic(&sub, &subtext);
if (subtext && *subtext) {
text_bytes += SDL_strlen(subtext);
}
}
dbus->message_iter_next(&sub);
if (dbus->message_iter_get_arg_type(&sub) == DBUS_TYPE_INT32 && p_end_pos == -1) {
// Type is a bit field defined as follows:
// bit 3: Underline, bit 4: HighLight, bit 5: DontCommit,
// bit 6: Bold, bit 7: Strike, bit 8: Italic
Sint32 type;
dbus->message_iter_get_basic(&sub, &type);
// We only consider highlight
if (type & (1 << 4)) {
if (p_start_pos == -1) {
p_start_pos = pos;
}
} else if (p_start_pos != -1 && p_end_pos == -1) {
p_end_pos = pos;
}
}
dbus->message_iter_next(&array);
if (subtext && *subtext) {
pos += SDL_utf8strlen(subtext);
}
}
if (p_start_pos != -1 && p_end_pos == -1) {
p_end_pos = pos;
}
if (text_bytes) {
text = SDL_malloc(text_bytes + 1);
}
if (text) {
char *pivot = text;
// Second pass: join all the sub string
dbus->message_iter_recurse(&iter, &array);
while (dbus->message_iter_get_arg_type(&array) == DBUS_TYPE_STRUCT) {
dbus->message_iter_recurse(&array, &sub);
if (dbus->message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING) {
dbus->message_iter_get_basic(&sub, &subtext);
if (subtext && *subtext) {
size_t length = SDL_strlen(subtext);
SDL_strlcpy(pivot, subtext, length + 1);
pivot += length;
}
}
dbus->message_iter_next(&array);
}
} else {
text_bytes = 0;
}
}
*ret = text;
*start_pos = p_start_pos;
*end_pos = p_end_pos;
return text_bytes;
}
static Sint32 Fcitx_GetPreeditCursorByte(SDL_DBusContext *dbus, DBusMessage *msg)
{
Sint32 byte = -1;
DBusMessageIter iter;
dbus->message_iter_init(msg, &iter);
dbus->message_iter_next(&iter);
if (dbus->message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32) {
return -1;
}
dbus->message_iter_get_basic(&iter, &byte);
return byte;
}
static DBusHandlerResult DBus_MessageFilter(DBusConnection *conn, DBusMessage *msg, void *data)
{
SDL_DBusContext *dbus = (SDL_DBusContext *)data;
if (dbus->message_is_signal(msg, FCITX_IC_DBUS_INTERFACE, "CommitString")) {
DBusMessageIter iter;
const char *text = NULL;
dbus->message_iter_init(msg, &iter);
dbus->message_iter_get_basic(&iter, &text);
//SDL_SendKeyboardText(text);
return DBUS_HANDLER_RESULT_HANDLED;
}
if (dbus->message_is_signal(msg, FCITX_IC_DBUS_INTERFACE, "UpdateFormattedPreedit")) {
char *text = NULL;
Sint32 start_pos, end_pos;
size_t text_bytes = Fcitx_GetPreeditString(dbus, msg, &text, &start_pos, &end_pos);
if (text_bytes) {
if (start_pos == -1) {
Sint32 byte_pos = Fcitx_GetPreeditCursorByte(dbus, msg);
start_pos = byte_pos >= 0 ? SDL_utf8strnlen(text, byte_pos) : -1;
}
//SDL_SendEditingText(text, start_pos, end_pos >= 0 ? end_pos - start_pos : -1);
SDL_free(text);
} else {
//SDL_SendEditingText("", 0, 0);
}
//SDL_Fcitx_UpdateTextInputArea(SDL_GetKeyboardFocus());
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static void FcitxClientICCallMethod(FcitxClient *client, const char *method)
{
if (!client->ic_path) {
return;
}
SDL_DBus_CallVoidMethod(FCITX_DBUS_SERVICE, client->ic_path, FCITX_IC_DBUS_INTERFACE, method, DBUS_TYPE_INVALID);
}
static void SDLCALL Fcitx_SetCapabilities(void *data,
const char *name,
const char *old_val,
const char *hint)
{
FcitxClient *client = (FcitxClient *)data;
Uint64 caps = 0;
if (!client->ic_path) {
return;
}
if (hint && SDL_strstr(hint, "composition")) {
caps |= (1 << 1); // Preedit Flag
caps |= (1 << 4); // Formatted Preedit Flag
}
if (hint && SDL_strstr(hint, "candidates")) {
// FIXME, turn off native candidate rendering
}
SDL_DBus_CallVoidMethod(FCITX_DBUS_SERVICE, client->ic_path, FCITX_IC_DBUS_INTERFACE, "SetCapability", DBUS_TYPE_UINT64, &caps, DBUS_TYPE_INVALID);
}
static bool FcitxCreateInputContext(SDL_DBusContext *dbus, const char *appname, char **ic_path)
{
const char *program = "program";
bool result = false;
if (dbus && dbus->session_conn) {
DBusMessage *msg = dbus->message_new_method_call(FCITX_DBUS_SERVICE, FCITX_IM_DBUS_PATH, FCITX_IM_DBUS_INTERFACE, "CreateInputContext");
if (msg) {
DBusMessage *reply = NULL;
DBusMessageIter args, array, sub;
dbus->message_iter_init_append(msg, &args);
dbus->message_iter_open_container(&args, DBUS_TYPE_ARRAY, "(ss)", &array);
dbus->message_iter_open_container(&array, DBUS_TYPE_STRUCT, 0, &sub);
dbus->message_iter_append_basic(&sub, DBUS_TYPE_STRING, &program);
dbus->message_iter_append_basic(&sub, DBUS_TYPE_STRING, &appname);
dbus->message_iter_close_container(&array, &sub);
dbus->message_iter_close_container(&args, &array);
reply = dbus->connection_send_with_reply_and_block(dbus->session_conn, msg, 300, NULL);
if (reply) {
if (dbus->message_get_args(reply, NULL, DBUS_TYPE_OBJECT_PATH, ic_path, DBUS_TYPE_INVALID)) {
result = true;
}
dbus->message_unref(reply);
}
dbus->message_unref(msg);
}
}
return result;
}
static bool FcitxClientCreateIC(FcitxClient *client)
{
char *appname = GetAppName();
char *ic_path = NULL;
SDL_DBusContext *dbus = client->dbus;
// SDL_DBus_CallMethod cannot handle a(ss) type, call dbus function directly
if (!FcitxCreateInputContext(dbus, appname, &ic_path)) {
ic_path = NULL; // just in case.
}
SDL_free(appname);
if (ic_path) {
SDL_free(client->ic_path);
client->ic_path = SDL_strdup(ic_path);
dbus->bus_add_match(dbus->session_conn,
"type='signal', interface='org.fcitx.Fcitx.InputContext1'",
NULL);
dbus->connection_add_filter(dbus->session_conn,
&DBus_MessageFilter, dbus,
NULL);
dbus->connection_flush(dbus->session_conn);
SDL_AddHintCallback(SDL_HINT_IME_IMPLEMENTED_UI, Fcitx_SetCapabilities, client);
return true;
}
return false;
}
static Uint32 Fcitx_ModState(void)
{
Uint32 fcitx_mods = 0;
SDL_Keymod sdl_mods = SDL_GetModState();
if (sdl_mods & SDL_KMOD_SHIFT) {
fcitx_mods |= (1 << 0);
}
if (sdl_mods & SDL_KMOD_CAPS) {
fcitx_mods |= (1 << 1);
}
if (sdl_mods & SDL_KMOD_CTRL) {
fcitx_mods |= (1 << 2);
}
if (sdl_mods & SDL_KMOD_ALT) {
fcitx_mods |= (1 << 3);
}
if (sdl_mods & SDL_KMOD_NUM) {
fcitx_mods |= (1 << 4);
}
if (sdl_mods & SDL_KMOD_MODE) {
fcitx_mods |= (1 << 7);
}
if (sdl_mods & SDL_KMOD_LGUI) {
fcitx_mods |= (1 << 6);
}
if (sdl_mods & SDL_KMOD_RGUI) {
fcitx_mods |= (1 << 28);
}
return fcitx_mods;
}
bool SDL_Fcitx_Init(void)
{
fcitx_client.dbus = SDL_DBus_GetContext();
fcitx_client.cursor_rect.x = -1;
fcitx_client.cursor_rect.y = -1;
fcitx_client.cursor_rect.w = 0;
fcitx_client.cursor_rect.h = 0;
return FcitxClientCreateIC(&fcitx_client);
}
void SDL_Fcitx_Quit(void)
{
FcitxClientICCallMethod(&fcitx_client, "DestroyIC");
if (fcitx_client.ic_path) {
SDL_free(fcitx_client.ic_path);
fcitx_client.ic_path = NULL;
}
}
void SDL_Fcitx_SetFocus(bool focused)
{
if (focused) {
FcitxClientICCallMethod(&fcitx_client, "FocusIn");
} else {
FcitxClientICCallMethod(&fcitx_client, "FocusOut");
}
}
void SDL_Fcitx_Reset(void)
{
FcitxClientICCallMethod(&fcitx_client, "Reset");
}
bool SDL_Fcitx_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, bool down)
{
Uint32 mod_state = Fcitx_ModState();
Uint32 handled = false;
Uint32 is_release = !down;
Uint32 event_time = 0;
if (!fcitx_client.ic_path) {
return false;
}
if (SDL_DBus_CallMethod(FCITX_DBUS_SERVICE, fcitx_client.ic_path, FCITX_IC_DBUS_INTERFACE, "ProcessKeyEvent",
DBUS_TYPE_UINT32, &keysym, DBUS_TYPE_UINT32, &keycode, DBUS_TYPE_UINT32, &mod_state, DBUS_TYPE_BOOLEAN, &is_release, DBUS_TYPE_UINT32, &event_time, DBUS_TYPE_INVALID,
DBUS_TYPE_BOOLEAN, &handled, DBUS_TYPE_INVALID)) {
if (handled) {
//SDL_Fcitx_UpdateTextInputArea(SDL_GetKeyboardFocus());
return true;
}
}
return false;
}
void SDL_Fcitx_PumpEvents(void)
{
SDL_DBusContext *dbus = fcitx_client.dbus;
DBusConnection *conn = dbus->session_conn;
dbus->connection_read_write(conn, 0);
while (dbus->connection_dispatch(conn) == DBUS_DISPATCH_DATA_REMAINS) {
// Do nothing, actual work happens in DBus_MessageFilter
}
}

35
thirdparty/sdl/core/linux/SDL_fcitx.h vendored
View file

@ -1,35 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2025 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.
*/
#ifndef SDL_fcitx_h_
#define SDL_fcitx_h_
#include "SDL_internal.h"
extern bool SDL_Fcitx_Init(void);
extern void SDL_Fcitx_Quit(void);
extern void SDL_Fcitx_SetFocus(bool focused);
extern void SDL_Fcitx_Reset(void);
extern bool SDL_Fcitx_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, bool down);
extern void SDL_Fcitx_UpdateTextInputArea(SDL_Window *window);
extern void SDL_Fcitx_PumpEvents(void);
#endif // SDL_fcitx_h_

694
thirdparty/sdl/core/linux/SDL_ibus.c vendored
View file

@ -1,694 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2025 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_internal.h"
#ifdef HAVE_IBUS_IBUS_H
#include "SDL_ibus.h"
#include "SDL_dbus.h"
#ifdef SDL_USE_LIBDBUS
//#include "../../video/SDL_sysvideo.h"
#include "../../events/SDL_keyboard_c.h"
#ifdef SDL_VIDEO_DRIVER_X11
#include "../../video/x11/SDL_x11video.h"
#endif
#include <sys/inotify.h>
#include <unistd.h>
#include <fcntl.h>
static const char IBUS_PATH[] = "/org/freedesktop/IBus";
static const char IBUS_SERVICE[] = "org.freedesktop.IBus";
static const char IBUS_INTERFACE[] = "org.freedesktop.IBus";
static const char IBUS_INPUT_INTERFACE[] = "org.freedesktop.IBus.InputContext";
static const char IBUS_PORTAL_SERVICE[] = "org.freedesktop.portal.IBus";
static const char IBUS_PORTAL_INTERFACE[] = "org.freedesktop.IBus.Portal";
static const char IBUS_PORTAL_INPUT_INTERFACE[] = "org.freedesktop.IBus.InputContext";
static const char *ibus_service = NULL;
static const char *ibus_interface = NULL;
static const char *ibus_input_interface = NULL;
static char *input_ctx_path = NULL;
static SDL_Rect ibus_cursor_rect = { 0, 0, 0, 0 };
static DBusConnection *ibus_conn = NULL;
static bool ibus_is_portal_interface = false;
static char *ibus_addr_file = NULL;
static int inotify_fd = -1, inotify_wd = -1;
static Uint32 IBus_ModState(void)
{
Uint32 ibus_mods = 0;
SDL_Keymod sdl_mods = SDL_GetModState();
// Not sure about MOD3, MOD4 and HYPER mappings
if (sdl_mods & SDL_KMOD_LSHIFT) {
ibus_mods |= IBUS_SHIFT_MASK;
}
if (sdl_mods & SDL_KMOD_CAPS) {
ibus_mods |= IBUS_LOCK_MASK;
}
if (sdl_mods & SDL_KMOD_LCTRL) {
ibus_mods |= IBUS_CONTROL_MASK;
}
if (sdl_mods & SDL_KMOD_LALT) {
ibus_mods |= IBUS_MOD1_MASK;
}
if (sdl_mods & SDL_KMOD_NUM) {
ibus_mods |= IBUS_MOD2_MASK;
}
if (sdl_mods & SDL_KMOD_MODE) {
ibus_mods |= IBUS_MOD5_MASK;
}
if (sdl_mods & SDL_KMOD_LGUI) {
ibus_mods |= IBUS_SUPER_MASK;
}
if (sdl_mods & SDL_KMOD_RGUI) {
ibus_mods |= IBUS_META_MASK;
}
return ibus_mods;
}
static bool IBus_EnterVariant(DBusConnection *conn, DBusMessageIter *iter, SDL_DBusContext *dbus,
DBusMessageIter *inside, const char *struct_id, size_t id_size)
{
DBusMessageIter sub;
if (dbus->message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT) {
return false;
}
dbus->message_iter_recurse(iter, &sub);
if (dbus->message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
return false;
}
dbus->message_iter_recurse(&sub, inside);
if (dbus->message_iter_get_arg_type(inside) != DBUS_TYPE_STRING) {
return false;
}
dbus->message_iter_get_basic(inside, &struct_id);
if (!struct_id || SDL_strncmp(struct_id, struct_id, id_size) != 0) {
return false;
}
return true;
}
static bool IBus_GetDecorationPosition(DBusConnection *conn, DBusMessageIter *iter, SDL_DBusContext *dbus,
Uint32 *start_pos, Uint32 *end_pos)
{
DBusMessageIter sub1, sub2, array;
if (!IBus_EnterVariant(conn, iter, dbus, &sub1, "IBusText", sizeof("IBusText"))) {
return false;
}
dbus->message_iter_next(&sub1);
dbus->message_iter_next(&sub1);
dbus->message_iter_next(&sub1);
if (!IBus_EnterVariant(conn, &sub1, dbus, &sub2, "IBusAttrList", sizeof("IBusAttrList"))) {
return false;
}
dbus->message_iter_next(&sub2);
dbus->message_iter_next(&sub2);
if (dbus->message_iter_get_arg_type(&sub2) != DBUS_TYPE_ARRAY) {
return false;
}
dbus->message_iter_recurse(&sub2, &array);
while (dbus->message_iter_get_arg_type(&array) == DBUS_TYPE_VARIANT) {
DBusMessageIter sub;
if (IBus_EnterVariant(conn, &array, dbus, &sub, "IBusAttribute", sizeof("IBusAttribute"))) {
Uint32 type;
dbus->message_iter_next(&sub);
dbus->message_iter_next(&sub);
// From here on, the structure looks like this:
// Uint32 type: 1=underline, 2=foreground, 3=background
// Uint32 value: for underline it's 0=NONE, 1=SINGLE, 2=DOUBLE,
// 3=LOW, 4=ERROR
// for foreground and background it's a color
// Uint32 start_index: starting position for the style (utf8-char)
// Uint32 end_index: end position for the style (utf8-char)
dbus->message_iter_get_basic(&sub, &type);
// We only use the background type to determine the selection
if (type == 3) {
Uint32 start = -1;
dbus->message_iter_next(&sub);
dbus->message_iter_next(&sub);
if (dbus->message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32) {
dbus->message_iter_get_basic(&sub, &start);
dbus->message_iter_next(&sub);
if (dbus->message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32) {
dbus->message_iter_get_basic(&sub, end_pos);
*start_pos = start;
return true;
}
}
}
}
dbus->message_iter_next(&array);
}
return false;
}
static const char *IBus_GetVariantText(DBusConnection *conn, DBusMessageIter *iter, SDL_DBusContext *dbus)
{
// The text we need is nested weirdly, use dbus-monitor to see the structure better
const char *text = NULL;
DBusMessageIter sub;
if (!IBus_EnterVariant(conn, iter, dbus, &sub, "IBusText", sizeof("IBusText"))) {
return NULL;
}
dbus->message_iter_next(&sub);
dbus->message_iter_next(&sub);
if (dbus->message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
return NULL;
}
dbus->message_iter_get_basic(&sub, &text);
return text;
}
static bool IBus_GetVariantCursorPos(DBusConnection *conn, DBusMessageIter *iter, SDL_DBusContext *dbus,
Uint32 *pos)
{
dbus->message_iter_next(iter);
if (dbus->message_iter_get_arg_type(iter) != DBUS_TYPE_UINT32) {
return false;
}
dbus->message_iter_get_basic(iter, pos);
return true;
}
static DBusHandlerResult IBus_MessageHandler(DBusConnection *conn, DBusMessage *msg, void *user_data)
{
SDL_DBusContext *dbus = (SDL_DBusContext *)user_data;
if (dbus->message_is_signal(msg, ibus_input_interface, "CommitText")) {
DBusMessageIter iter;
const char *text;
dbus->message_iter_init(msg, &iter);
text = IBus_GetVariantText(conn, &iter, dbus);
SDL_SendKeyboardText(text);
return DBUS_HANDLER_RESULT_HANDLED;
}
if (dbus->message_is_signal(msg, ibus_input_interface, "UpdatePreeditText")) {
DBusMessageIter iter;
const char *text;
dbus->message_iter_init(msg, &iter);
text = IBus_GetVariantText(conn, &iter, dbus);
if (text) {
Uint32 pos, start_pos, end_pos;
bool has_pos = false;
bool has_dec_pos = false;
dbus->message_iter_init(msg, &iter);
has_dec_pos = IBus_GetDecorationPosition(conn, &iter, dbus, &start_pos, &end_pos);
if (!has_dec_pos) {
dbus->message_iter_init(msg, &iter);
has_pos = IBus_GetVariantCursorPos(conn, &iter, dbus, &pos);
}
if (has_dec_pos) {
SDL_SendEditingText(text, start_pos, end_pos - start_pos);
} else if (has_pos) {
SDL_SendEditingText(text, pos, -1);
} else {
SDL_SendEditingText(text, -1, -1);
}
}
//SDL_IBus_UpdateTextInputArea(SDL_GetKeyboardFocus());
return DBUS_HANDLER_RESULT_HANDLED;
}
if (dbus->message_is_signal(msg, ibus_input_interface, "HidePreeditText")) {
SDL_SendEditingText("", 0, 0);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static char *IBus_ReadAddressFromFile(const char *file_path)
{
char addr_buf[1024];
bool success = false;
FILE *addr_file;
addr_file = fopen(file_path, "r");
if (!addr_file) {
return NULL;
}
while (fgets(addr_buf, sizeof(addr_buf), addr_file)) {
if (SDL_strncmp(addr_buf, "IBUS_ADDRESS=", sizeof("IBUS_ADDRESS=") - 1) == 0) {
size_t sz = SDL_strlen(addr_buf);
if (addr_buf[sz - 1] == '\n') {
addr_buf[sz - 1] = 0;
}
if (addr_buf[sz - 2] == '\r') {
addr_buf[sz - 2] = 0;
}
success = true;
break;
}
}
(void)fclose(addr_file);
if (success) {
return SDL_strdup(addr_buf + (sizeof("IBUS_ADDRESS=") - 1));
} else {
return NULL;
}
}
static char *IBus_GetDBusAddressFilename(void)
{
SDL_DBusContext *dbus;
const char *disp_env;
char config_dir[PATH_MAX];
char *display = NULL;
const char *addr;
const char *conf_env;
char *key;
char file_path[PATH_MAX];
const char *host;
char *disp_num, *screen_num;
if (ibus_addr_file) {
return SDL_strdup(ibus_addr_file);
}
dbus = SDL_DBus_GetContext();
if (!dbus) {
return NULL;
}
// Use this environment variable if it exists.
addr = SDL_getenv("IBUS_ADDRESS");
if (addr && *addr) {
return SDL_strdup(addr);
}
/* Otherwise, we have to get the hostname, display, machine id, config dir
and look up the address from a filepath using all those bits, eek. */
disp_env = SDL_getenv("DISPLAY");
if (!disp_env || !*disp_env) {
display = SDL_strdup(":0.0");
} else {
display = SDL_strdup(disp_env);
}
host = display;
disp_num = SDL_strrchr(display, ':');
screen_num = SDL_strrchr(display, '.');
if (!disp_num) {
SDL_free(display);
return NULL;
}
*disp_num = 0;
disp_num++;
if (screen_num) {
*screen_num = 0;
}
if (!*host) {
const char *session = SDL_getenv("XDG_SESSION_TYPE");
if (session && SDL_strcmp(session, "wayland") == 0) {
host = "unix-wayland";
} else {
host = "unix";
}
}
SDL_memset(config_dir, 0, sizeof(config_dir));
conf_env = SDL_getenv("XDG_CONFIG_HOME");
if (conf_env && *conf_env) {
SDL_strlcpy(config_dir, conf_env, sizeof(config_dir));
} else {
const char *home_env = SDL_getenv("HOME");
if (!home_env || !*home_env) {
SDL_free(display);
return NULL;
}
(void)SDL_snprintf(config_dir, sizeof(config_dir), "%s/.config", home_env);
}
key = SDL_DBus_GetLocalMachineId();
if (!key) {
SDL_free(display);
return NULL;
}
SDL_memset(file_path, 0, sizeof(file_path));
(void)SDL_snprintf(file_path, sizeof(file_path), "%s/ibus/bus/%s-%s-%s",
config_dir, key, host, disp_num);
dbus->free(key);
SDL_free(display);
return SDL_strdup(file_path);
}
static bool IBus_CheckConnection(SDL_DBusContext *dbus);
static void SDLCALL IBus_SetCapabilities(void *data, const char *name, const char *old_val,
const char *hint)
{
SDL_DBusContext *dbus = SDL_DBus_GetContext();
if (IBus_CheckConnection(dbus)) {
Uint32 caps = IBUS_CAP_FOCUS;
if (hint && SDL_strstr(hint, "composition")) {
caps |= IBUS_CAP_PREEDIT_TEXT;
}
if (hint && SDL_strstr(hint, "candidates")) {
// FIXME, turn off native candidate rendering
}
SDL_DBus_CallVoidMethodOnConnection(ibus_conn, ibus_service, input_ctx_path, ibus_input_interface, "SetCapabilities",
DBUS_TYPE_UINT32, &caps, DBUS_TYPE_INVALID);
}
}
static bool IBus_SetupConnection(SDL_DBusContext *dbus, const char *addr)
{
const char *client_name = "SDL3_Application";
const char *path = NULL;
bool result = false;
DBusObjectPathVTable ibus_vtable;
SDL_zero(ibus_vtable);
ibus_vtable.message_function = &IBus_MessageHandler;
/* try the portal interface first. Modern systems have this in general,
and sandbox things like FlakPak and Snaps, etc, require it. */
ibus_is_portal_interface = true;
ibus_service = IBUS_PORTAL_SERVICE;
ibus_interface = IBUS_PORTAL_INTERFACE;
ibus_input_interface = IBUS_PORTAL_INPUT_INTERFACE;
ibus_conn = dbus->session_conn;
result = SDL_DBus_CallMethodOnConnection(ibus_conn, ibus_service, IBUS_PATH, ibus_interface, "CreateInputContext",
DBUS_TYPE_STRING, &client_name, DBUS_TYPE_INVALID,
DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
if (!result) {
ibus_is_portal_interface = false;
ibus_service = IBUS_SERVICE;
ibus_interface = IBUS_INTERFACE;
ibus_input_interface = IBUS_INPUT_INTERFACE;
ibus_conn = dbus->connection_open_private(addr, NULL);
if (!ibus_conn) {
return false; // oh well.
}
dbus->connection_flush(ibus_conn);
if (!dbus->bus_register(ibus_conn, NULL)) {
ibus_conn = NULL;
return false;
}
dbus->connection_flush(ibus_conn);
result = SDL_DBus_CallMethodOnConnection(ibus_conn, ibus_service, IBUS_PATH, ibus_interface, "CreateInputContext",
DBUS_TYPE_STRING, &client_name, DBUS_TYPE_INVALID,
DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
} else {
// re-using dbus->session_conn
dbus->connection_ref(ibus_conn);
}
if (result) {
char matchstr[128];
(void)SDL_snprintf(matchstr, sizeof(matchstr), "type='signal',interface='%s'", ibus_input_interface);
SDL_free(input_ctx_path);
input_ctx_path = SDL_strdup(path);
SDL_AddHintCallback(SDL_HINT_IME_IMPLEMENTED_UI, IBus_SetCapabilities, NULL);
dbus->bus_add_match(ibus_conn, matchstr, NULL);
dbus->connection_try_register_object_path(ibus_conn, input_ctx_path, &ibus_vtable, dbus, NULL);
dbus->connection_flush(ibus_conn);
}
return result;
}
static bool IBus_CheckConnection(SDL_DBusContext *dbus)
{
if (!dbus) {
return false;
}
if (ibus_conn && dbus->connection_get_is_connected(ibus_conn)) {
return true;
}
if (inotify_fd > 0 && inotify_wd > 0) {
char buf[1024];
ssize_t readsize = read(inotify_fd, buf, sizeof(buf));
if (readsize > 0) {
char *p;
bool file_updated = false;
for (p = buf; p < buf + readsize; /**/) {
struct inotify_event *event = (struct inotify_event *)p;
if (event->len > 0) {
char *addr_file_no_path = SDL_strrchr(ibus_addr_file, '/');
if (!addr_file_no_path) {
return false;
}
if (SDL_strcmp(addr_file_no_path + 1, event->name) == 0) {
file_updated = true;
break;
}
}
p += sizeof(struct inotify_event) + event->len;
}
if (file_updated) {
char *addr = IBus_ReadAddressFromFile(ibus_addr_file);
if (addr) {
bool result = IBus_SetupConnection(dbus, addr);
SDL_free(addr);
return result;
}
}
}
}
return false;
}
bool SDL_IBus_Init(void)
{
bool result = false;
SDL_DBusContext *dbus = SDL_DBus_GetContext();
if (dbus) {
char *addr_file = IBus_GetDBusAddressFilename();
char *addr;
char *addr_file_dir;
if (!addr_file) {
return false;
}
addr = IBus_ReadAddressFromFile(addr_file);
if (!addr) {
SDL_free(addr_file);
return false;
}
if (ibus_addr_file) {
SDL_free(ibus_addr_file);
}
ibus_addr_file = SDL_strdup(addr_file);
if (inotify_fd < 0) {
inotify_fd = inotify_init();
fcntl(inotify_fd, F_SETFL, O_NONBLOCK);
}
addr_file_dir = SDL_strrchr(addr_file, '/');
if (addr_file_dir) {
*addr_file_dir = 0;
}
inotify_wd = inotify_add_watch(inotify_fd, addr_file, IN_CREATE | IN_MODIFY);
SDL_free(addr_file);
result = IBus_SetupConnection(dbus, addr);
SDL_free(addr);
// don't use the addr_file if using the portal interface.
if (result && ibus_is_portal_interface) {
if (inotify_fd > 0) {
if (inotify_wd > 0) {
inotify_rm_watch(inotify_fd, inotify_wd);
inotify_wd = -1;
}
close(inotify_fd);
inotify_fd = -1;
}
}
}
return result;
}
void SDL_IBus_Quit(void)
{
SDL_DBusContext *dbus;
if (input_ctx_path) {
SDL_free(input_ctx_path);
input_ctx_path = NULL;
}
if (ibus_addr_file) {
SDL_free(ibus_addr_file);
ibus_addr_file = NULL;
}
dbus = SDL_DBus_GetContext();
// if using portal, ibus_conn == session_conn; don't release it here.
if (dbus && ibus_conn && !ibus_is_portal_interface) {
dbus->connection_close(ibus_conn);
dbus->connection_unref(ibus_conn);
}
ibus_conn = NULL;
ibus_service = NULL;
ibus_interface = NULL;
ibus_input_interface = NULL;
ibus_is_portal_interface = false;
if (inotify_fd > 0 && inotify_wd > 0) {
inotify_rm_watch(inotify_fd, inotify_wd);
inotify_wd = -1;
}
// !!! FIXME: should we close(inotify_fd) here?
SDL_RemoveHintCallback(SDL_HINT_IME_IMPLEMENTED_UI, IBus_SetCapabilities, NULL);
SDL_memset(&ibus_cursor_rect, 0, sizeof(ibus_cursor_rect));
}
static void IBus_SimpleMessage(const char *method)
{
SDL_DBusContext *dbus = SDL_DBus_GetContext();
if ((input_ctx_path) && (IBus_CheckConnection(dbus))) {
SDL_DBus_CallVoidMethodOnConnection(ibus_conn, ibus_service, input_ctx_path, ibus_input_interface, method, DBUS_TYPE_INVALID);
}
}
void SDL_IBus_SetFocus(bool focused)
{
const char *method = focused ? "FocusIn" : "FocusOut";
IBus_SimpleMessage(method);
}
void SDL_IBus_Reset(void)
{
IBus_SimpleMessage("Reset");
}
bool SDL_IBus_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, bool down)
{
Uint32 result = 0;
SDL_DBusContext *dbus = SDL_DBus_GetContext();
if (IBus_CheckConnection(dbus)) {
Uint32 mods = IBus_ModState();
Uint32 ibus_keycode = keycode - 8;
if (!down) {
mods |= (1 << 30); // IBUS_RELEASE_MASK
}
if (!SDL_DBus_CallMethodOnConnection(ibus_conn, ibus_service, input_ctx_path, ibus_input_interface, "ProcessKeyEvent",
DBUS_TYPE_UINT32, &keysym, DBUS_TYPE_UINT32, &ibus_keycode, DBUS_TYPE_UINT32, &mods, DBUS_TYPE_INVALID,
DBUS_TYPE_BOOLEAN, &result, DBUS_TYPE_INVALID)) {
result = 0;
}
}
//SDL_IBus_UpdateTextInputArea(SDL_GetKeyboardFocus());
return (result != 0);
}
void SDL_IBus_PumpEvents(void)
{
SDL_DBusContext *dbus = SDL_DBus_GetContext();
if (IBus_CheckConnection(dbus)) {
dbus->connection_read_write(ibus_conn, 0);
while (dbus->connection_dispatch(ibus_conn) == DBUS_DISPATCH_DATA_REMAINS) {
// Do nothing, actual work happens in IBus_MessageHandler
}
}
}
#endif // SDL_USE_LIBDBUS
#endif

55
thirdparty/sdl/core/linux/SDL_ibus.h vendored
View file

@ -1,55 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2025 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_internal.h"
#ifndef SDL_ibus_h_
#define SDL_ibus_h_
#ifdef HAVE_IBUS_IBUS_H
#define SDL_USE_IBUS 1
#include <ibus.h>
extern bool SDL_IBus_Init(void);
extern void SDL_IBus_Quit(void);
// Lets the IBus server know about changes in window focus
extern void SDL_IBus_SetFocus(bool focused);
// Closes the candidate list and resets any text currently being edited
extern void SDL_IBus_Reset(void);
/* Sends a keypress event to IBus, returns true if IBus used this event to
update its candidate list or change input methods. PumpEvents should be
called some time after this, to receive the TextInput / TextEditing event back. */
extern bool SDL_IBus_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, bool down);
/* Update the position of IBus' candidate list. If rect is NULL then this will
just reposition it relative to the focused window's new position. */
extern void SDL_IBus_UpdateTextInputArea(SDL_Window *window);
/* Checks DBus for new IBus events, and calls SDL_SendKeyboardText /
SDL_SendEditingText for each event it finds */
extern void SDL_IBus_PumpEvents(void);
#endif // HAVE_IBUS_IBUS_H
#endif // SDL_ibus_h_

150
thirdparty/sdl/core/linux/SDL_ime.c vendored
View file

@ -1,150 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2025 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_internal.h"
#include "SDL_ime.h"
#include "SDL_ibus.h"
#include "SDL_fcitx.h"
typedef bool (*SDL_IME_Init_t)(void);
typedef void (*SDL_IME_Quit_t)(void);
typedef void (*SDL_IME_SetFocus_t)(bool);
typedef void (*SDL_IME_Reset_t)(void);
typedef bool (*SDL_IME_ProcessKeyEvent_t)(Uint32, Uint32, bool down);
typedef void (*SDL_IME_UpdateTextInputArea_t)(SDL_Window *window);
typedef void (*SDL_IME_PumpEvents_t)(void);
static SDL_IME_Init_t SDL_IME_Init_Real = NULL;
static SDL_IME_Quit_t SDL_IME_Quit_Real = NULL;
static SDL_IME_SetFocus_t SDL_IME_SetFocus_Real = NULL;
static SDL_IME_Reset_t SDL_IME_Reset_Real = NULL;
static SDL_IME_ProcessKeyEvent_t SDL_IME_ProcessKeyEvent_Real = NULL;
static SDL_IME_UpdateTextInputArea_t SDL_IME_UpdateTextInputArea_Real = NULL;
static SDL_IME_PumpEvents_t SDL_IME_PumpEvents_Real = NULL;
static void InitIME(void)
{
static bool inited = false;
#ifdef HAVE_FCITX
const char *im_module = SDL_getenv("SDL_IM_MODULE");
const char *xmodifiers = SDL_getenv("XMODIFIERS");
#endif
if (inited == true) {
return;
}
inited = true;
// See if fcitx IME support is being requested
#ifdef HAVE_FCITX
if (!SDL_IME_Init_Real &&
((im_module && SDL_strcmp(im_module, "fcitx") == 0) ||
(!im_module && xmodifiers && SDL_strstr(xmodifiers, "@im=fcitx") != NULL))) {
SDL_IME_Init_Real = SDL_Fcitx_Init;
SDL_IME_Quit_Real = SDL_Fcitx_Quit;
SDL_IME_SetFocus_Real = SDL_Fcitx_SetFocus;
SDL_IME_Reset_Real = SDL_Fcitx_Reset;
SDL_IME_ProcessKeyEvent_Real = SDL_Fcitx_ProcessKeyEvent;
SDL_IME_UpdateTextInputArea_Real = SDL_Fcitx_UpdateTextInputArea;
SDL_IME_PumpEvents_Real = SDL_Fcitx_PumpEvents;
}
#endif // HAVE_FCITX
// default to IBus
#ifdef HAVE_IBUS_IBUS_H
if (!SDL_IME_Init_Real) {
SDL_IME_Init_Real = SDL_IBus_Init;
SDL_IME_Quit_Real = SDL_IBus_Quit;
SDL_IME_SetFocus_Real = SDL_IBus_SetFocus;
SDL_IME_Reset_Real = SDL_IBus_Reset;
SDL_IME_ProcessKeyEvent_Real = SDL_IBus_ProcessKeyEvent;
SDL_IME_UpdateTextInputArea_Real = SDL_IBus_UpdateTextInputArea;
SDL_IME_PumpEvents_Real = SDL_IBus_PumpEvents;
}
#endif // HAVE_IBUS_IBUS_H
}
bool SDL_IME_Init(void)
{
InitIME();
if (SDL_IME_Init_Real) {
if (SDL_IME_Init_Real()) {
return true;
}
// uhoh, the IME implementation's init failed! Disable IME support.
SDL_IME_Init_Real = NULL;
SDL_IME_Quit_Real = NULL;
SDL_IME_SetFocus_Real = NULL;
SDL_IME_Reset_Real = NULL;
SDL_IME_ProcessKeyEvent_Real = NULL;
SDL_IME_UpdateTextInputArea_Real = NULL;
SDL_IME_PumpEvents_Real = NULL;
}
return false;
}
void SDL_IME_Quit(void)
{
if (SDL_IME_Quit_Real) {
SDL_IME_Quit_Real();
}
}
void SDL_IME_SetFocus(bool focused)
{
if (SDL_IME_SetFocus_Real) {
SDL_IME_SetFocus_Real(focused);
}
}
void SDL_IME_Reset(void)
{
if (SDL_IME_Reset_Real) {
SDL_IME_Reset_Real();
}
}
bool SDL_IME_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, bool down)
{
if (SDL_IME_ProcessKeyEvent_Real) {
return SDL_IME_ProcessKeyEvent_Real(keysym, keycode, down);
}
return false;
}
void SDL_IME_UpdateTextInputArea(SDL_Window *window)
{
if (SDL_IME_UpdateTextInputArea_Real) {
SDL_IME_UpdateTextInputArea_Real(window);
}
}
void SDL_IME_PumpEvents(void)
{
if (SDL_IME_PumpEvents_Real) {
SDL_IME_PumpEvents_Real();
}
}

35
thirdparty/sdl/core/linux/SDL_ime.h vendored
View file

@ -1,35 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2025 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.
*/
#ifndef SDL_ime_h_
#define SDL_ime_h_
#include "SDL_internal.h"
extern bool SDL_IME_Init(void);
extern void SDL_IME_Quit(void);
extern void SDL_IME_SetFocus(bool focused);
extern void SDL_IME_Reset(void);
extern bool SDL_IME_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, bool down);
extern void SDL_IME_UpdateTextInputArea(SDL_Window *window);
extern void SDL_IME_PumpEvents(void);
#endif // SDL_ime_h_

156
thirdparty/sdl/core/linux/SDL_system_theme.c vendored
View file

@ -1,156 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2025 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_internal.h"
#include "SDL_dbus.h"
#include "SDL_system_theme.h"
//#include "../../video/SDL_sysvideo.h"
#include <unistd.h>
#define PORTAL_DESTINATION "org.freedesktop.portal.Desktop"
#define PORTAL_PATH "/org/freedesktop/portal/desktop"
#define PORTAL_INTERFACE "org.freedesktop.portal.Settings"
#define PORTAL_METHOD "Read"
#define SIGNAL_INTERFACE "org.freedesktop.portal.Settings"
#define SIGNAL_NAMESPACE "org.freedesktop.appearance"
#define SIGNAL_NAME "SettingChanged"
#define SIGNAL_KEY "color-scheme"
typedef struct SystemThemeData
{
SDL_DBusContext *dbus;
SDL_SystemTheme theme;
} SystemThemeData;
static SystemThemeData system_theme_data;
static bool DBus_ExtractThemeVariant(DBusMessageIter *iter, SDL_SystemTheme *theme) {
SDL_DBusContext *dbus = system_theme_data.dbus;
Uint32 color_scheme;
DBusMessageIter variant_iter;
if (dbus->message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT)
return false;
dbus->message_iter_recurse(iter, &variant_iter);
if (dbus->message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_UINT32)
return false;
dbus->message_iter_get_basic(&variant_iter, &color_scheme);
switch (color_scheme) {
case 0:
*theme = SDL_SYSTEM_THEME_UNKNOWN;
break;
case 1:
*theme = SDL_SYSTEM_THEME_DARK;
break;
case 2:
*theme = SDL_SYSTEM_THEME_LIGHT;
break;
}
return true;
}
static DBusHandlerResult DBus_MessageFilter(DBusConnection *conn, DBusMessage *msg, void *data) {
SDL_DBusContext *dbus = (SDL_DBusContext *)data;
if (dbus->message_is_signal(msg, SIGNAL_INTERFACE, SIGNAL_NAME)) {
DBusMessageIter signal_iter;
const char *namespace, *key;
dbus->message_iter_init(msg, &signal_iter);
// Check if the parameters are what we expect
if (dbus->message_iter_get_arg_type(&signal_iter) != DBUS_TYPE_STRING)
goto not_our_signal;
dbus->message_iter_get_basic(&signal_iter, &namespace);
if (SDL_strcmp(SIGNAL_NAMESPACE, namespace) != 0)
goto not_our_signal;
if (!dbus->message_iter_next(&signal_iter))
goto not_our_signal;
if (dbus->message_iter_get_arg_type(&signal_iter) != DBUS_TYPE_STRING)
goto not_our_signal;
dbus->message_iter_get_basic(&signal_iter, &key);
if (SDL_strcmp(SIGNAL_KEY, key) != 0)
goto not_our_signal;
if (!dbus->message_iter_next(&signal_iter))
goto not_our_signal;
if (!DBus_ExtractThemeVariant(&signal_iter, &system_theme_data.theme))
goto not_our_signal;
//SDL_SetSystemTheme(system_theme_data.theme);
return DBUS_HANDLER_RESULT_HANDLED;
}
not_our_signal:
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
bool SDL_SystemTheme_Init(void)
{
SDL_DBusContext *dbus = SDL_DBus_GetContext();
DBusMessage *msg;
static const char *namespace = SIGNAL_NAMESPACE;
static const char *key = SIGNAL_KEY;
system_theme_data.theme = SDL_SYSTEM_THEME_UNKNOWN;
system_theme_data.dbus = dbus;
if (!dbus) {
return false;
}
msg = dbus->message_new_method_call(PORTAL_DESTINATION, PORTAL_PATH, PORTAL_INTERFACE, PORTAL_METHOD);
if (msg) {
if (dbus->message_append_args(msg, DBUS_TYPE_STRING, &namespace, DBUS_TYPE_STRING, &key, DBUS_TYPE_INVALID)) {
DBusMessage *reply = dbus->connection_send_with_reply_and_block(dbus->session_conn, msg, 300, NULL);
if (reply) {
DBusMessageIter reply_iter, variant_outer_iter;
dbus->message_iter_init(reply, &reply_iter);
// The response has signature <<u>>
if (dbus->message_iter_get_arg_type(&reply_iter) != DBUS_TYPE_VARIANT)
goto incorrect_type;
dbus->message_iter_recurse(&reply_iter, &variant_outer_iter);
if (!DBus_ExtractThemeVariant(&variant_outer_iter, &system_theme_data.theme))
goto incorrect_type;
incorrect_type:
dbus->message_unref(reply);
}
}
dbus->message_unref(msg);
}
dbus->bus_add_match(dbus->session_conn,
"type='signal', interface='"SIGNAL_INTERFACE"',"
"member='"SIGNAL_NAME"', arg0='"SIGNAL_NAMESPACE"',"
"arg1='"SIGNAL_KEY"'", NULL);
dbus->connection_add_filter(dbus->session_conn,
&DBus_MessageFilter, dbus, NULL);
dbus->connection_flush(dbus->session_conn);
return true;
}
SDL_SystemTheme SDL_SystemTheme_Get(void)
{
return system_theme_data.theme;
}

30
thirdparty/sdl/core/linux/SDL_system_theme.h vendored
View file

@ -1,30 +0,0 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2025 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.
*/
#ifndef SDL_system_theme_h_
#define SDL_system_theme_h_
#include "SDL_internal.h"
extern bool SDL_SystemTheme_Init(void);
extern SDL_SystemTheme SDL_SystemTheme_Get(void);
#endif // SDL_system_theme_h_

214
thirdparty/sdl/patches/0001-remove-unnecessary-subsystems.patch vendored
View file

@ -357,220 +357,6 @@ index 5746e2ef98..04e3e9d6b6 100644
SDL_free(item->touchscreen_data->slots);
SDL_free(item->touchscreen_data->name);
SDL_free(item->touchscreen_data);
diff --git a/thirdparty/sdl/core/linux/SDL_fcitx.c b/thirdparty/sdl/core/linux/SDL_fcitx.c
index d7a9ed6656..c6bce5f796 100644
--- a/thirdparty/sdl/core/linux/SDL_fcitx.c
+++ b/thirdparty/sdl/core/linux/SDL_fcitx.c
@@ -23,8 +23,7 @@
#include <unistd.h>
#include "SDL_fcitx.h"
-#include "../../video/SDL_sysvideo.h"
-#include "../../events/SDL_keyboard_c.h"
+//#include "../../video/SDL_sysvideo.h"
#include "SDL_dbus.h"
#ifdef SDL_VIDEO_DRIVER_X11
@@ -192,7 +191,7 @@ static DBusHandlerResult DBus_MessageFilter(DBusConnection *conn, DBusMessage *m
dbus->message_iter_init(msg, &iter);
dbus->message_iter_get_basic(&iter, &text);
- SDL_SendKeyboardText(text);
+ //SDL_SendKeyboardText(text);
return DBUS_HANDLER_RESULT_HANDLED;
}
@@ -206,13 +205,13 @@ static DBusHandlerResult DBus_MessageFilter(DBusConnection *conn, DBusMessage *m
Sint32 byte_pos = Fcitx_GetPreeditCursorByte(dbus, msg);
start_pos = byte_pos >= 0 ? SDL_utf8strnlen(text, byte_pos) : -1;
}
- SDL_SendEditingText(text, start_pos, end_pos >= 0 ? end_pos - start_pos : -1);
+ //SDL_SendEditingText(text, start_pos, end_pos >= 0 ? end_pos - start_pos : -1);
SDL_free(text);
} else {
- SDL_SendEditingText("", 0, 0);
+ //SDL_SendEditingText("", 0, 0);
}
- SDL_Fcitx_UpdateTextInputArea(SDL_GetKeyboardFocus());
+ //SDL_Fcitx_UpdateTextInputArea(SDL_GetKeyboardFocus());
return DBUS_HANDLER_RESULT_HANDLED;
}
@@ -394,7 +393,7 @@ bool SDL_Fcitx_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, bool down)
DBUS_TYPE_UINT32, &keysym, DBUS_TYPE_UINT32, &keycode, DBUS_TYPE_UINT32, &mod_state, DBUS_TYPE_BOOLEAN, &is_release, DBUS_TYPE_UINT32, &event_time, DBUS_TYPE_INVALID,
DBUS_TYPE_BOOLEAN, &handled, DBUS_TYPE_INVALID)) {
if (handled) {
- SDL_Fcitx_UpdateTextInputArea(SDL_GetKeyboardFocus());
+ //SDL_Fcitx_UpdateTextInputArea(SDL_GetKeyboardFocus());
return true;
}
}
@@ -402,51 +401,6 @@ bool SDL_Fcitx_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, bool down)
return false;
}
-void SDL_Fcitx_UpdateTextInputArea(SDL_Window *window)
-{
- int x = 0, y = 0;
- SDL_Rect *cursor = &fcitx_client.cursor_rect;
-
- if (!window) {
- return;
- }
-
- // We'll use a square at the text input cursor location for the cursor_rect
- cursor->x = window->text_input_rect.x + window->text_input_cursor;
- cursor->y = window->text_input_rect.y;
- cursor->w = window->text_input_rect.h;
- cursor->h = window->text_input_rect.h;
-
- SDL_GetWindowPosition(window, &x, &y);
-
-#ifdef SDL_VIDEO_DRIVER_X11
- {
- SDL_PropertiesID props = SDL_GetWindowProperties(window);
- Display *x_disp = (Display *)SDL_GetPointerProperty(props, SDL_PROP_WINDOW_X11_DISPLAY_POINTER, NULL);
- int x_screen = SDL_GetNumberProperty(props, SDL_PROP_WINDOW_X11_SCREEN_NUMBER, 0);
- Window x_win = SDL_GetNumberProperty(props, SDL_PROP_WINDOW_X11_WINDOW_NUMBER, 0);
- Window unused;
- if (x_disp && x_win) {
- X11_XTranslateCoordinates(x_disp, x_win, RootWindow(x_disp, x_screen), 0, 0, &x, &y, &unused);
- }
- }
-#endif
-
- if (cursor->x == -1 && cursor->y == -1 && cursor->w == 0 && cursor->h == 0) {
- // move to bottom left
- int w = 0, h = 0;
- SDL_GetWindowSize(window, &w, &h);
- cursor->x = 0;
- cursor->y = h;
- }
-
- x += cursor->x;
- y += cursor->y;
-
- SDL_DBus_CallVoidMethod(FCITX_DBUS_SERVICE, fcitx_client.ic_path, FCITX_IC_DBUS_INTERFACE, "SetCursorRect",
- DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32, &y, DBUS_TYPE_INT32, &cursor->w, DBUS_TYPE_INT32, &cursor->h, DBUS_TYPE_INVALID);
-}
-
void SDL_Fcitx_PumpEvents(void)
{
SDL_DBusContext *dbus = fcitx_client.dbus;
diff --git a/thirdparty/sdl/core/linux/SDL_ibus.c b/thirdparty/sdl/core/linux/SDL_ibus.c
index ea58ed5778..3d4bb83694 100644
--- a/thirdparty/sdl/core/linux/SDL_ibus.c
+++ b/thirdparty/sdl/core/linux/SDL_ibus.c
@@ -26,7 +26,7 @@
#ifdef SDL_USE_LIBDBUS
-#include "../../video/SDL_sysvideo.h"
+//#include "../../video/SDL_sysvideo.h"
#include "../../events/SDL_keyboard_c.h"
#ifdef SDL_VIDEO_DRIVER_X11
@@ -261,7 +261,7 @@ static DBusHandlerResult IBus_MessageHandler(DBusConnection *conn, DBusMessage *
}
}
- SDL_IBus_UpdateTextInputArea(SDL_GetKeyboardFocus());
+ //SDL_IBus_UpdateTextInputArea(SDL_GetKeyboardFocus());
return DBUS_HANDLER_RESULT_HANDLED;
}
@@ -484,13 +484,6 @@ static bool IBus_SetupConnection(SDL_DBusContext *dbus, const char *addr)
dbus->connection_flush(ibus_conn);
}
- SDL_Window *window = SDL_GetKeyboardFocus();
- if (SDL_TextInputActive(window)) {
- SDL_IBus_SetFocus(true);
- SDL_IBus_UpdateTextInputArea(window);
- } else {
- SDL_IBus_SetFocus(false);
- }
return result;
}
@@ -678,53 +671,11 @@ bool SDL_IBus_ProcessKeyEvent(Uint32 keysym, Uint32 keycode, bool down)
}
}
- SDL_IBus_UpdateTextInputArea(SDL_GetKeyboardFocus());
+ //SDL_IBus_UpdateTextInputArea(SDL_GetKeyboardFocus());
return (result != 0);
}
-void SDL_IBus_UpdateTextInputArea(SDL_Window *window)
-{
- int x = 0, y = 0;
- SDL_DBusContext *dbus;
-
- if (!window) {
- return;
- }
-
- // We'll use a square at the text input cursor location for the ibus_cursor
- ibus_cursor_rect.x = window->text_input_rect.x + window->text_input_cursor;
- ibus_cursor_rect.y = window->text_input_rect.y;
- ibus_cursor_rect.w = window->text_input_rect.h;
- ibus_cursor_rect.h = window->text_input_rect.h;
-
- SDL_GetWindowPosition(window, &x, &y);
-
-#ifdef SDL_VIDEO_DRIVER_X11
- {
- SDL_PropertiesID props = SDL_GetWindowProperties(window);
- Display *x_disp = (Display *)SDL_GetPointerProperty(props, SDL_PROP_WINDOW_X11_DISPLAY_POINTER, NULL);
- int x_screen = SDL_GetNumberProperty(props, SDL_PROP_WINDOW_X11_SCREEN_NUMBER, 0);
- Window x_win = SDL_GetNumberProperty(props, SDL_PROP_WINDOW_X11_WINDOW_NUMBER, 0);
- Window unused;
-
- if (x_disp && x_win) {
- X11_XTranslateCoordinates(x_disp, x_win, RootWindow(x_disp, x_screen), 0, 0, &x, &y, &unused);
- }
- }
-#endif
-
- x += ibus_cursor_rect.x;
- y += ibus_cursor_rect.y;
-
- dbus = SDL_DBus_GetContext();
-
- if (IBus_CheckConnection(dbus)) {
- SDL_DBus_CallVoidMethodOnConnection(ibus_conn, ibus_service, input_ctx_path, ibus_input_interface, "SetCursorLocation",
- DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32, &y, DBUS_TYPE_INT32, &ibus_cursor_rect.w, DBUS_TYPE_INT32, &ibus_cursor_rect.h, DBUS_TYPE_INVALID);
- }
-}
-
void SDL_IBus_PumpEvents(void)
{
SDL_DBusContext *dbus = SDL_DBus_GetContext();
diff --git a/thirdparty/sdl/core/linux/SDL_system_theme.c b/thirdparty/sdl/core/linux/SDL_system_theme.c
index 6d6087db5a..f5ef92dd05 100644
--- a/thirdparty/sdl/core/linux/SDL_system_theme.c
+++ b/thirdparty/sdl/core/linux/SDL_system_theme.c
@@ -22,7 +22,7 @@
#include "SDL_dbus.h"
#include "SDL_system_theme.h"
-#include "../../video/SDL_sysvideo.h"
+//#include "../../video/SDL_sysvideo.h"
#include <unistd.h>
@@ -99,7 +99,7 @@ static DBusHandlerResult DBus_MessageFilter(DBusConnection *conn, DBusMessage *m
if (!DBus_ExtractThemeVariant(&signal_iter, &system_theme_data.theme))
goto not_our_signal;
- SDL_SetSystemTheme(system_theme_data.theme);
+ //SDL_SetSystemTheme(system_theme_data.theme);
return DBUS_HANDLER_RESULT_HANDLED;
}
not_our_signal:
diff --git a/thirdparty/sdl/events/SDL_events.c b/thirdparty/sdl/events/SDL_events.c
index a151740524..24c2c4270f 100644
--- a/thirdparty/sdl/events/SDL_events.c

1
thirdparty/sdl/update-sdl.sh vendored
View file

@ -49,6 +49,7 @@ cp -v io/SDL_iostream*.{c,h} $target/io
mkdir $target/core
cp -rv core/{linux,unix,windows} $target/core
rm -f $target/core/windows/version.rc
rm -f $target/core/linux/SDL_{fcitx,ibus,ime,system_theme}.*
mkdir $target/haptic
cp -rv haptic/{*.{c,h},darwin,linux,windows} $target/haptic