We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

[patch] patch to implement SendEditEX for bugs 3006, 3421, 4782, and 4783 on windows and fcitx (not yet for ibus)

SDL_3006_3421_4782_4783_for_windows_and_fcitx.diff (text/plain), 33.21 KB, created by tamo on 2019-09-10 01:06:26 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: tamo

Created: 2019-09-10 01:06:26 UTC

Size: 33.21 KB

patch

obsolete

>diff -r bfed06214c2a include/SDL_events.h
>--- a/include/SDL_events.h	Tue Aug 27 11:38:43 2019 +0200
>+++ b/include/SDL_events.h	Tue Sep 10 09:56:24 2019 +0900
>@@ -96,6 +96,7 @@
>     SDL_KEYDOWN        = 0x300, /**< Key pressed */
>     SDL_KEYUP,                  /**< Key released */
>     SDL_TEXTEDITING,            /**< Keyboard text editing (composition) */
>+    SDL_TEXTEDITINGEX,          /**< Keyboard text editing with extra information */
>     SDL_TEXTINPUT,              /**< Keyboard text input */
>     SDL_KEYMAPCHANGED,          /**< Keymap changed due to a system event such as an
>                                      input language or keyboard layout change.
>@@ -220,7 +221,8 @@
>     SDL_Keysym keysym;  /**< The key that was pressed or released */
> } SDL_KeyboardEvent;
> 
>-#define SDL_TEXTEDITINGEVENT_TEXT_SIZE (32)
>+#define SDL_TEXTEDITINGEVENT_TEXT_MINI (32)
>+#define SDL_TEXTEDITINGEVENT_TEXT_SIZE (512)
> /**
>  *  \brief Keyboard text editing event structure (event.edit.*)
>  */
>@@ -229,13 +231,35 @@
>     Uint32 type;                                /**< ::SDL_TEXTEDITING */
>     Uint32 timestamp;                           /**< In milliseconds, populated using SDL_GetTicks() */
>     Uint32 windowID;                            /**< The window with keyboard focus, if any */
>-    char text[SDL_TEXTEDITINGEVENT_TEXT_SIZE];  /**< The editing text */
>-    Sint32 start;                               /**< The start cursor of selected editing text */
>-    Sint32 length;                              /**< The length of selected editing text */
>+    char text[SDL_TEXTEDITINGEVENT_TEXT_MINI];  /**< The editing text */
>+    Sint32 start;                               /**< The cursor, where the reading string starts if any */
>+    Sint32 length;                              /**< The length of the reading string */
> } SDL_TextEditingEvent;
> 
>+#define MAX_CANDLIST (10)
>+#define MAX_CANDLENGTH (256)
>+#define AVG_UTF8_CHAR_LENGTH (2)
>+#define MAX_CANDLIST_SIZE (MAX_CANDLIST * MAX_CANDLENGTH * AVG_UTF8_CHAR_LENGTH)
>+/**
>+ * \brief Keyboard text editing event structure with extra information (event.editx.*)
>+ */
>+typedef struct SDL_TextEditingExEvent
>+{
>+    Uint32 type;          /**< ::SDL_TEXTEDITINGEX */
>+    Uint32 timestamp;     /**< In milliseconds, populated using SDL_GetTicks() */
>+    Uint32 windowID;      /**< The window with keyboard focus, if any */
>+    char* composition;    /**< The editing text, needs freeing */
>+    SDL_bool commit;      /**< Whether the event should be treated as TEXTINPUT */
>+    Uint16 cursor;        /**< The cursor position */
>+    Uint16 target_start;  /**< The starting point of editing part */
>+    Uint16 target_end;    /**< The length of editing part */
>+    SDL_bool candshow;    /**< Whether to show candidate list */
>+    char* candidates;     /**< The candidate array[MAX_CANDLIST][MAX_CANDLENGTH], needs freeing */
>+    Sint8 candsel;        /**< The cursor of the candidate list */
>+} SDL_TextEditingExEvent;
> 
>-#define SDL_TEXTINPUTEVENT_TEXT_SIZE (32)
>+#define SDL_TEXTINPUTEVENT_TEXT_MINI (32)
>+#define SDL_TEXTINPUTEVENT_TEXT_SIZE (512)
> /**
>  *  \brief Keyboard text input event structure (event.text.*)
>  */
>@@ -244,7 +268,7 @@
>     Uint32 type;                              /**< ::SDL_TEXTINPUT */
>     Uint32 timestamp;                         /**< In milliseconds, populated using SDL_GetTicks() */
>     Uint32 windowID;                          /**< The window with keyboard focus, if any */
>-    char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];  /**< The input text */
>+    char text[SDL_TEXTINPUTEVENT_TEXT_MINI];  /**< The input text */
> } SDL_TextInputEvent;
> 
> /**
>@@ -563,6 +587,7 @@
>     SDL_WindowEvent window;         /**< Window event data */
>     SDL_KeyboardEvent key;          /**< Keyboard event data */
>     SDL_TextEditingEvent edit;      /**< Text editing event data */
>+    SDL_TextEditingExEvent editx;   /**< Text editing EX event data */
>     SDL_TextInputEvent text;        /**< Text input event data */
>     SDL_MouseMotionEvent motion;    /**< Mouse motion event data */
>     SDL_MouseButtonEvent button;    /**< Mouse button event data */
>diff -r bfed06214c2a src/core/linux/SDL_fcitx.c
>--- a/src/core/linux/SDL_fcitx.c	Tue Aug 27 11:38:43 2019 +0200
>+++ b/src/core/linux/SDL_fcitx.c	Tue Sep 10 09:56:24 2019 +0900
>@@ -118,6 +118,53 @@
>     return SDL_strdup("SDL_App");
> }
> 
>+typedef SDL_bool (*typecb)(Sint32);
>+
>+static SDL_bool isHIGHLIGHT(Sint32 type) {
>+    return (MSG_HIGHLIGHT & type);
>+}
>+
>+static SDL_bool isnotHIGHLIGHT(Sint32 type) {
>+    return !(MSG_HIGHLIGHT & type);
>+}
>+
>+/* returns SDL_TRUE if the process continues */
>+/* returns SDL_FALSE if the preedit or the buffer ran out */
>+static SDL_bool AppendFmtPreedit(SDL_DBusContext *dbus, DBusMessageIter *array,
>+                                 char **bufptr, size_t *buflen,
>+                                 size_t *sumchars, size_t *lastchars, typecb callback) {
>+    do {
>+        struct FcitxPreeditItem {
>+            char* string;
>+            Sint32 type;
>+        } fitem;
>+        DBusMessageIter fstru;
>+        if (DBUS_TYPE_STRUCT == dbus->message_iter_get_arg_type(array)) {
>+            dbus->message_iter_recurse(array, &fstru);
>+            dbus->message_iter_get_basic(&fstru, &fitem.string);
>+            if (fitem.string && dbus->message_iter_next(&fstru)) {
>+                size_t bytes = SDL_utf8strlcpy(*bufptr, fitem.string, *buflen);
>+                *lastchars = SDL_utf8strlen(*bufptr);
>+                *bufptr += bytes;
>+                if (bytes >= *buflen)
>+                    bytes = *buflen;
>+                *buflen -= bytes;
>+                /* maybe buflen==0, but even in that case, */
>+                /* the last fragment should be processed later */
>+                dbus->message_iter_get_basic(&fstru, &fitem.type);
>+                if ((callback) && callback(fitem.type)) {
>+                    dbus->message_iter_next(array);
>+                    return SDL_TRUE;
>+                }
>+                *sumchars += *lastchars;
>+            } else
>+                break;
>+        } else
>+            break;
>+    } while (*buflen && dbus->message_iter_next(array));
>+    return SDL_FALSE;
>+}
>+
> static DBusHandlerResult
> DBus_MessageFilter(DBusConnection *conn, DBusMessage *msg, void *data)
> {
>@@ -125,39 +172,51 @@
> 
>     if (dbus->message_is_signal(msg, FCITX_IC_DBUS_INTERFACE, "CommitString")) {
>         DBusMessageIter iter;
>-        const char *text = NULL;
>+        char *text = NULL;
> 
>         dbus->message_iter_init(msg, &iter);
>         dbus->message_iter_get_basic(&iter, &text);
> 
>-        if (text)
>+        if (text) {
>             SDL_SendKeyboardText(text);
>+            SDL_SendEditingTextEx(text, SDL_TRUE, 0, 0, 0, 0, NULL, 0);
>+        }
> 
>         return DBUS_HANDLER_RESULT_HANDLED;
>     }
> 
>-    if (dbus->message_is_signal(msg, FCITX_IC_DBUS_INTERFACE, "UpdatePreedit")) {
>-        DBusMessageIter iter;
>-        const char *text;
>+    if (dbus->message_is_signal(msg, FCITX_IC_DBUS_INTERFACE, "UpdateFormattedPreedit")) {
>+        DBusMessageIter iter, array;
>+        char buf[SDL_TEXTEDITINGEVENT_TEXT_SIZE], *bufptr = buf;
>+        size_t target_start = 0, target_end = 0, sumchars = 0, chars = 0, buflen = sizeof(buf);
>+        buf[0] = '\0';
> 
>         dbus->message_iter_init(msg, &iter);
>-        dbus->message_iter_get_basic(&iter, &text);
>+        dbus->message_iter_recurse(&iter, &array);
> 
>-        if (text && *text) {
>-            char buf[SDL_TEXTEDITINGEVENT_TEXT_SIZE];
>-            size_t text_bytes = SDL_strlen(text), i = 0;
>-            size_t cursor = 0;
>+        if (AppendFmtPreedit(dbus, &array, &bufptr, &buflen, &target_start, &chars, isHIGHLIGHT)) {
>+            /* found target_start */
>+            target_end = target_start + chars;
>+            if (AppendFmtPreedit(dbus, &array, &bufptr, &buflen, &target_end, &chars, isnotHIGHLIGHT)) {
>+                /* found target_end */
>+                sumchars = target_end + chars;
>+                AppendFmtPreedit(dbus, &array, &bufptr, &buflen, &sumchars, &chars, NULL);
>+            } else {
>+                /* preedit ended at target_end */
>+                /* ...or found an error */
>+                sumchars = target_end;
>+            }
>+        } else {
>+            /* found no target and reached at the end */
>+            /* ...or found an error */
>+            target_end = target_start;
>+            sumchars = target_end;
>+        }
> 
>-            while (i < text_bytes) {
>-                const size_t sz = SDL_utf8strlcpy(buf, text + i, sizeof(buf));
>-                const size_t chars = SDL_utf8strlen(buf);
>-
>-                SDL_SendEditingText(buf, cursor, chars);
>-
>-                i += sz;
>-                cursor += chars;
>-            }
>-        }
>+        /* readingstring is not supported */
>+        SDL_SendEditingText(buf, sumchars, 0);
>+        /* candidate list is not supported */
>+        SDL_SendEditingTextEx(buf, SDL_FALSE, 0, target_start, target_end, 0, NULL, 0);
> 
>         SDL_Fcitx_UpdateTextRect(NULL);
>         return DBUS_HANDLER_RESULT_HANDLED;
>@@ -182,7 +241,7 @@
>     Uint32 caps = CAPACITY_NONE;
> 
>     if (!(internal_editing && *internal_editing == '1')) {
>-        caps |= CAPACITY_PREEDIT;
>+        caps |= CAPACITY_PREEDIT | CAPACITY_FORMATTED_PREEDIT;
>     }
> 
>     SDL_DBus_CallVoidMethod(client->servicename, client->icname, FCITX_IC_DBUS_INTERFACE, "SetCapacity", DBUS_TYPE_UINT32, &caps, DBUS_TYPE_INVALID);
>diff -r bfed06214c2a src/core/linux/SDL_ibus.c
>--- a/src/core/linux/SDL_ibus.c	Tue Aug 27 11:38:43 2019 +0200
>+++ b/src/core/linux/SDL_ibus.c	Tue Sep 10 09:56:24 2019 +0900
>@@ -67,43 +67,61 @@
> }
> 
> static const char *
>-IBus_GetVariantText(DBusConnection *conn, DBusMessageIter *iter, SDL_DBusContext *dbus)
>+IBus_GetVariantText(DBusConnection *conn, DBusMessageIter *iter, SDL_DBusContext *dbus, Uint32 *start, Uint32 *end)
> {
>     /* The text we need is nested weirdly, use dbus-monitor to see the structure better */
>     const char *text = NULL;
>     const char *struct_id = NULL;
>-    DBusMessageIter sub1, sub2;
>+    DBusMessageIter sub1, sub2, sub3, sub4;
>+    Uint32 attr, value;
> 
>-    if (dbus->message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT) {
>-        return NULL;
>+    if (dbus->message_iter_get_arg_type(iter) == DBUS_TYPE_VARIANT) {
>+        dbus->message_iter_recurse(iter, &sub1);
>+        if (dbus->message_iter_get_arg_type(&sub1) == DBUS_TYPE_STRUCT) {
>+            dbus->message_iter_recurse(&sub1, &sub2);
>+            if (dbus->message_iter_get_arg_type(&sub2) == DBUS_TYPE_STRING) {
>+                dbus->message_iter_get_basic(&sub2, &struct_id);
>+                if (struct_id && SDL_strncmp(struct_id, "IBusText", sizeof("IBusText")) == 0) {
>+                    dbus->message_iter_next(&sub2);
>+                    dbus->message_iter_next(&sub2);
>+                    if (dbus->message_iter_get_arg_type(&sub2) == DBUS_TYPE_STRING) {
>+                        dbus->message_iter_get_basic(&sub2, &text);
>+                        if (start == NULL || end == NULL) {
>+                            return text;
>+                        }
>+                    }
>+                    dbus->message_iter_next(&sub2);
>+                    if (dbus->message_iter_get_arg_type(&sub2) == DBUS_TYPE_ARRAY) {
>+                        dbus->message_iter_recurse(&sub2, &sub3);
>+                        while (dbus->message_iter_get_arg_type(&sub3) == DBUS_TYPE_STRUCT) {
>+                            /* http://ibus.github.io/docs/ibus-1.5/IBusAttribute.html#IBusAttribute-struct */
>+                            dbus->message_iter_recurse(&sub3, &sub4);
>+                            if (dbus->message_iter_get_arg_type(&sub4) == DBUS_TYPE_UINT32) {
>+                                dbus->message_iter_get_basic(&sub4, &attr);
>+                                if (attr == 1) { /* underline */
>+                                    dbus->message_iter_next(&sub4);
>+                                    if (dbus->message_iter_get_arg_type(&sub4) == DBUS_TYPE_UINT32) {
>+                                        dbus->message_iter_get_basic(&sub4, &value);
>+                                        if (value == 1 || value == 2) { /* single or double */
>+                                            dbus->message_iter_next(&sub4);
>+                                            if (dbus->message_iter_get_arg_type(&sub4) == DBUS_TYPE_UINT32) {
>+                                                dbus->message_iter_get_basic(&sub4, start);
>+                                                dbus->message_iter_next(&sub4);
>+                                                if (dbus->message_iter_get_arg_type(&sub4) == DBUS_TYPE_UINT32) {
>+                                                    dbus->message_iter_get_basic(&sub4, end);
>+                                                    break;
>+                                                }
>+                                            }
>+                                        }
>+                                    }
>+                                }
>+                            }
>+                        }
>+                    }
>+                }
>+            }
>+        }
>     }
>-    
>-    dbus->message_iter_recurse(iter, &sub1);
>-    
>-    if (dbus->message_iter_get_arg_type(&sub1) != DBUS_TYPE_STRUCT) {
>-        return NULL;
>-    }
>-    
>-    dbus->message_iter_recurse(&sub1, &sub2);
>-    
>-    if (dbus->message_iter_get_arg_type(&sub2) != DBUS_TYPE_STRING) {
>-        return NULL;
>-    }
>-    
>-    dbus->message_iter_get_basic(&sub2, &struct_id);
>-    if (!struct_id || SDL_strncmp(struct_id, "IBusText", sizeof("IBusText")) != 0) {
>-        return NULL;
>-    }
>-    
>-    dbus->message_iter_next(&sub2);
>-    dbus->message_iter_next(&sub2);
>-    
>-    if (dbus->message_iter_get_arg_type(&sub2) != DBUS_TYPE_STRING) {
>-        return NULL;
>-    }
>-    
>-    dbus->message_iter_get_basic(&sub2, &text);
>-    
>     return text;
> }
> 
>@@ -118,7 +136,7 @@
> 
>         dbus->message_iter_init(msg, &iter);
>         
>-        text = IBus_GetVariantText(conn, &iter, dbus);
>+        text = IBus_GetVariantText(conn, &iter, dbus, NULL, NULL);
>         if (text && *text) {
>             char buf[SDL_TEXTINPUTEVENT_TEXT_SIZE];
>             size_t text_bytes = SDL_strlen(text), i = 0;
>@@ -126,6 +144,7 @@
>             while (i < text_bytes) {
>                 size_t sz = SDL_utf8strlcpy(buf, text+i, sizeof(buf));
>                 SDL_SendKeyboardText(buf);
>+                SDL_SendEditingTextEx(buf, SDL_TRUE, 0, 0, 0, SDL_FALSE, NULL, 0);
>                 
>                 i += sz;
>             }
>@@ -137,25 +156,20 @@
>     if (dbus->message_is_signal(msg, IBUS_INPUT_INTERFACE, "UpdatePreeditText")) {
>         DBusMessageIter iter;
>         const char *text;
>+        Uint32 start, end;
>+        char buf[SDL_TEXTEDITINGEVENT_TEXT_SIZE];
>+        size_t chars;
> 
>         dbus->message_iter_init(msg, &iter);
>-        text = IBus_GetVariantText(conn, &iter, dbus);
>+        text = IBus_GetVariantText(conn, &iter, dbus, &start, &end);
>         
>-        if (text) {
>-            char buf[SDL_TEXTEDITINGEVENT_TEXT_SIZE];
>-            size_t text_bytes = SDL_strlen(text), i = 0;
>-            size_t cursor = 0;
>-            
>-            do {
>-                const size_t sz = SDL_utf8strlcpy(buf, text+i, sizeof(buf));
>-                const size_t chars = SDL_utf8strlen(buf);
>-                
>-                SDL_SendEditingText(buf, cursor, chars);
>+        SDL_utf8strlcpy(buf, text, sizeof(buf));
>+        chars = SDL_utf8strlen(buf);
> 
>-                i += sz;
>-                cursor += chars;
>-            } while (i < text_bytes);
>-        }
>+        /* readingstring is not supported */ 
>+        SDL_SendEditingText(buf, chars, 0);
>+        /* candidate list is not supported */
>+        SDL_SendEditingTextEx(buf, SDL_FALSE, chars, start, end, SDL_FALSE, NULL, 0);
>         
>         SDL_IBus_UpdateTextRect(NULL);
>         
>@@ -164,6 +178,7 @@
>     
>     if (dbus->message_is_signal(msg, IBUS_INPUT_INTERFACE, "HidePreeditText")) {
>         SDL_SendEditingText("", 0, 0);
>+        SDL_SendEditingTextEx("", SDL_FALSE, 0, 0, 0, SDL_FALSE, NULL, 0);
>         return DBUS_HANDLER_RESULT_HANDLED;
>     }
>     
>diff -r bfed06214c2a src/events/SDL_events.c
>--- a/src/events/SDL_events.c	Tue Aug 27 11:38:43 2019 +0200
>+++ b/src/events/SDL_events.c	Tue Sep 10 09:56:24 2019 +0900
>@@ -439,6 +439,7 @@
>     /* Process most event types */
>     SDL_EventState(SDL_TEXTINPUT, SDL_DISABLE);
>     SDL_EventState(SDL_TEXTEDITING, SDL_DISABLE);
>+    SDL_EventState(SDL_TEXTEDITINGEX, SDL_DISABLE);
>     SDL_EventState(SDL_SYSWMEVENT, SDL_DISABLE);
> #if 0 /* Leave these events enabled so apps can respond to items being dragged onto them at startup */
>     SDL_EventState(SDL_DROPFILE, SDL_DISABLE);
>diff -r bfed06214c2a src/events/SDL_keyboard.c
>--- a/src/events/SDL_keyboard.c	Tue Aug 27 11:38:43 2019 +0200
>+++ b/src/events/SDL_keyboard.c	Tue Sep 10 09:56:24 2019 +0900
>@@ -652,7 +652,7 @@
>                             0, 0);
> 
>         /* Ensures IME compositions are committed */
>-        if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
>+        if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY) || SDL_EventState(SDL_TEXTEDITINGEX, SDL_QUERY)) {
>             SDL_VideoDevice *video = SDL_GetVideoDevice();
>             if (video && video->StopTextInput) {
>                 video->StopTextInput(video);
>@@ -666,7 +666,7 @@
>         SDL_SendWindowEvent(keyboard->focus, SDL_WINDOWEVENT_FOCUS_GAINED,
>                             0, 0);
> 
>-        if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
>+        if (SDL_EventState(SDL_TEXTINPUT, SDL_QUERY) || SDL_EventState(SDL_TEXTEDITINGEX, SDL_QUERY)) {
>             SDL_VideoDevice *video = SDL_GetVideoDevice();
>             if (video && video->StartTextInput) {
>                 video->StartTextInput(video);
>@@ -828,6 +828,37 @@
>     return (posted);
> }
> 
>+int SDL_SendEditingTextEx(char* composition, SDL_bool commit, Uint16 cursor,
>+                          Uint16 target_start, Uint16 target_end,
>+                          SDL_bool candshow, char* candidates, Sint8 candsel)
>+{
>+    SDL_Keyboard* keyboard = &SDL_keyboard;
>+    int posted = 0;
>+
>+    /* Post the event, if desired */
>+    if (SDL_GetEventState(SDL_TEXTEDITINGEX) == SDL_ENABLE) {
>+        SDL_Event event;
>+        char* newcands = NULL;
>+        if (candidates) {
>+            newcands = (char*)SDL_malloc(MAX_CANDLIST_SIZE);
>+            SDL_memcpy(newcands, candidates, MAX_CANDLIST_SIZE);
>+        }
>+        event.editx.type = SDL_TEXTEDITINGEX;
>+        event.editx.windowID = keyboard->focus ? keyboard->focus->id : 0;
>+        event.editx.composition = SDL_strdup(composition); /* needs freeing */
>+        event.editx.commit = commit;
>+        event.editx.cursor = cursor;
>+        event.editx.target_start = target_start;
>+        event.editx.target_end = target_end;
>+        event.editx.candshow = candshow;
>+        event.editx.candidates = newcands; /* needs freeing if not null */
>+        event.editx.candsel = candsel;
>+        posted = (SDL_PushEvent(&event) > 0);
>+    }
>+    return (posted);
>+}
>+
>+
> void
> SDL_KeyboardQuit(void)
> {
>diff -r bfed06214c2a src/events/SDL_keyboard_c.h
>--- a/src/events/SDL_keyboard_c.h	Tue Aug 27 11:38:43 2019 +0200
>+++ b/src/events/SDL_keyboard_c.h	Tue Sep 10 09:56:24 2019 +0900
>@@ -53,8 +53,15 @@
> /* Send keyboard text input */
> extern int SDL_SendKeyboardText(const char *text);
> 
>-/* Send editing text for selected range from start to end */
>-extern int SDL_SendEditingText(const char *text, int start, int end);
>+/* Send editing text which may contain a reading string in specified length from start */
>+extern int SDL_SendEditingText(const char *text, int read_start, int read_length);
>+
>+/* Send editing text with extra information such as cursor, current target,
>+   and candidate list */
>+extern int SDL_SendEditingTextEx(char *composition, SDL_bool commit,
>+    Uint16 cursor, Uint16 target_start, Uint16 target_end,
>+    SDL_bool candshow, char *candidates, Sint8 candsel);
>+
> 
> /* Shutdown the keyboard subsystem */
> extern void SDL_KeyboardQuit(void);
>diff -r bfed06214c2a src/video/SDL_video.c
>--- a/src/video/SDL_video.c	Tue Aug 27 11:38:43 2019 +0200
>+++ b/src/video/SDL_video.c	Tue Sep 10 09:56:24 2019 +0900
>@@ -3759,6 +3759,7 @@
>     /* First, enable text events */
>     SDL_EventState(SDL_TEXTINPUT, SDL_ENABLE);
>     SDL_EventState(SDL_TEXTEDITING, SDL_ENABLE);
>+    /* SDL_TEXTEDITINGEX needs explicit enabling */
> 
>     /* Then show the on-screen keyboard, if any */
>     window = SDL_GetFocusWindow();
>@@ -3797,6 +3798,7 @@
>     /* Finally disable text events */
>     SDL_EventState(SDL_TEXTINPUT, SDL_DISABLE);
>     SDL_EventState(SDL_TEXTEDITING, SDL_DISABLE);
>+    /* SDL_TEXTEDITINGEX has not been enabled automatically */
> }
> 
> void
>diff -r bfed06214c2a src/video/windows/SDL_windowskeyboard.c
>--- a/src/video/windows/SDL_windowskeyboard.c	Tue Aug 27 11:38:43 2019 +0200
>+++ b/src/video/windows/SDL_windowskeyboard.c	Tue Sep 10 09:56:24 2019 +0900
>@@ -64,6 +64,8 @@
>     data->ime_composition[0] = 0;
>     data->ime_readingstring[0] = 0;
>     data->ime_cursor = 0;
>+    data->ime_target_start = 0;
>+    data->ime_target_end = 0;
> 
>     data->ime_candlist = SDL_FALSE;
>     SDL_memset(data->ime_candidates, 0, sizeof(data->ime_candidates));
>@@ -329,6 +331,7 @@
> static void IME_SetupAPI(SDL_VideoData *videodata);
> static DWORD IME_GetId(SDL_VideoData *videodata, UINT uIndex);
> static void IME_SendEditingEvent(SDL_VideoData *videodata);
>+static void IME_SendEditingExEvent(SDL_VideoData* videodata, SDL_bool commit);
> static void IME_DestroyTextures(SDL_VideoData *videodata);
> 
> static SDL_bool UILess_SetupSinks(SDL_VideoData *videodata);
>@@ -530,6 +533,7 @@
>     }
>     ImmReleaseContext(hwnd, himc);
>     IME_SendEditingEvent(videodata);
>+    IME_SendEditingExEvent(videodata, SDL_FALSE);
> }
> 
> static void
>@@ -724,6 +728,7 @@
>     ImmNotifyIME(himc, NI_CLOSECANDIDATE, 0, 0);
>     ImmReleaseContext(videodata->ime_hwnd_current, himc);
>     SDL_SendEditingText("", 0, 0);
>+    SDL_SendEditingTextEx("", SDL_FALSE, 0, 0, 0, SDL_FALSE, NULL, 0);
> }
> 
> static void
>@@ -743,6 +748,20 @@
>         --length;
>     }
>     videodata->ime_composition[length] = 0;
>+
>+    LONG attrs_size = ImmGetCompositionStringW(himc, GCS_COMPATTR, NULL, 0);
>+    if (attrs_size) {
>+        char* attrs = (char *)SDL_calloc(attrs_size, sizeof(char));
>+        ImmGetCompositionStringW(himc, GCS_COMPATTR, attrs, attrs_size);
>+        Uint16 i;
>+        for (i = 0; i < attrs_size / sizeof(attrs[0]) &&
>+            attrs[i] != ATTR_TARGET_CONVERTED && attrs[i] != ATTR_TARGET_NOTCONVERTED; i++);
>+        videodata->ime_target_start = i;
>+        for (; i < attrs_size / sizeof(attrs[0]) &&
>+            attrs[i] == ATTR_TARGET_CONVERTED || attrs[i] == ATTR_TARGET_NOTCONVERTED; i++);
>+        videodata->ime_target_end = i;
>+        SDL_free(attrs);
>+    }
> }
> 
> static void
>@@ -756,30 +775,58 @@
>     videodata->ime_composition[0] = 0;
>     videodata->ime_readingstring[0] = 0;
>     videodata->ime_cursor = 0;
>+    videodata->ime_target_start = 0;
>+    videodata->ime_target_end = 0;
> }
> 
> static void
> IME_SendEditingEvent(SDL_VideoData *videodata)
> {
>     char *s = 0;
>+    size_t cursor;
>     WCHAR buffer[SDL_TEXTEDITINGEVENT_TEXT_SIZE];
>     const size_t size = SDL_arraysize(buffer);
>     buffer[0] = 0;
>     if (videodata->ime_readingstring[0]) {
>-        size_t len = SDL_min(SDL_wcslen(videodata->ime_composition), (size_t)videodata->ime_cursor);
>-        SDL_wcslcpy(buffer, videodata->ime_composition, len + 1);
>+        cursor = SDL_min(SDL_wcslen(videodata->ime_composition), (size_t)videodata->ime_cursor);
>+        SDL_wcslcpy(buffer, videodata->ime_composition, cursor + 1);
>         SDL_wcslcat(buffer, videodata->ime_readingstring, size);
>-        SDL_wcslcat(buffer, &videodata->ime_composition[len], size);
>+        SDL_wcslcat(buffer, &videodata->ime_composition[cursor], size);
>     }
>     else {
>-        SDL_wcslcpy(buffer, videodata->ime_composition, size);
>+        cursor = SDL_wcslcpy(buffer, videodata->ime_composition, size);
>     }
>     s = WIN_StringToUTF8(buffer);
>-    SDL_SendEditingText(s, videodata->ime_cursor + (int)SDL_wcslen(videodata->ime_readingstring), 0);
>+    SDL_SendEditingText(s, (int)cursor, (int)SDL_wcslen(videodata->ime_readingstring));
>     SDL_free(s);
> }
> 
> static void
>+IME_SendEditingExEvent(SDL_VideoData* videodata, SDL_bool commit)
>+{
>+    char* composit = WIN_StringToUTF8(videodata->ime_composition);
>+    char* candidates = NULL;
>+    char* newcands = NULL;
>+    if (videodata->ime_candlist) {
>+        size_t i;
>+        newcands = (char*)SDL_calloc(1, MAX_CANDLIST_SIZE);
>+        for (i = 0; i < MAX_CANDLIST; i++) {
>+            char* u8can = WIN_StringToUTF8(&videodata->ime_candidates[i]);
>+            if (u8can) {
>+                SDL_utf8strlcpy(newcands + (i * MAX_CANDLENGTH * AVG_UTF8_CHAR_LENGTH),
>+                    u8can, MAX_CANDLENGTH);
>+                SDL_free(u8can);
>+            }
>+        }
>+    }
>+    SDL_SendEditingTextEx(composit, commit, videodata->ime_cursor,
>+        videodata->ime_target_start, videodata->ime_target_end,
>+        videodata->ime_candlist, newcands, videodata->ime_candsel);
>+    SDL_free(composit);
>+    SDL_free(newcands);
>+}
>+
>+static void
> IME_AddCandidate(SDL_VideoData *videodata, UINT i, LPCWSTR candidate)
> {
>     LPWSTR dst = videodata->ime_candidates[i];
>@@ -855,6 +902,7 @@
>     videodata->ime_candlist = SDL_TRUE;
>     IME_DestroyTextures(videodata);
>     IME_SendEditingEvent(videodata);
>+    IME_SendEditingExEvent(videodata, SDL_FALSE);
> }
> 
> static void
>@@ -864,6 +912,7 @@
>     videodata->ime_candlist = SDL_FALSE;
>     IME_DestroyTextures(videodata);
>     IME_SendEditingEvent(videodata);
>+    IME_SendEditingExEvent(videodata, SDL_FALSE);
> }
> 
> SDL_bool
>@@ -889,6 +938,7 @@
>         himc = ImmGetContext(hwnd);
>         if (*lParam & GCS_RESULTSTR) {
>             IME_GetCompositionString(videodata, himc, GCS_RESULTSTR);
>+            IME_SendEditingExEvent(videodata, SDL_TRUE);
>             IME_SendInputEvent(videodata);
>         }
>         if (*lParam & GCS_COMPSTR) {
>@@ -897,6 +947,7 @@
> 
>             IME_GetCompositionString(videodata, himc, GCS_COMPSTR);
>             IME_SendEditingEvent(videodata);
>+            IME_SendEditingExEvent(videodata, SDL_FALSE);
>         }
>         ImmReleaseContext(hwnd, himc);
>         break;
>@@ -905,6 +956,7 @@
>         videodata->ime_readingstring[0] = 0;
>         videodata->ime_cursor = 0;
>         SDL_SendEditingText("", 0, 0);
>+        SDL_SendEditingTextEx("", SDL_FALSE, 0, 0, 0, SDL_FALSE, NULL, 0);
>         break;
>     case WM_IME_NOTIFY:
>         switch (wParam) {
>@@ -1112,6 +1164,7 @@
>             WCHAR *s = (WCHAR *)bstr;
>             SDL_wcslcpy(videodata->ime_readingstring, s, SDL_arraysize(videodata->ime_readingstring));
>             IME_SendEditingEvent(videodata);
>+            IME_SendEditingExEvent(videodata, SDL_FALSE);
>             SysFreeString(bstr);
>         }
>         preading->lpVtbl->Release(preading);
>@@ -1135,6 +1188,7 @@
>     if (SUCCEEDED(element->lpVtbl->QueryInterface(element, &IID_ITfReadingInformationUIElement, (LPVOID *)&preading))) {
>         videodata->ime_readingstring[0] = 0;
>         IME_SendEditingEvent(videodata);
>+        IME_SendEditingExEvent(videodata, SDL_FALSE);
>         preading->lpVtbl->Release(preading);
>     }
>     if (SUCCEEDED(element->lpVtbl->QueryInterface(element, &IID_ITfCandidateListUIElement, (LPVOID *)&pcandlist))) {
>diff -r bfed06214c2a src/video/windows/SDL_windowsvideo.h
>--- a/src/video/windows/SDL_windowsvideo.h	Tue Aug 27 11:38:43 2019 +0200
>+++ b/src/video/windows/SDL_windowsvideo.h	Tue Sep 10 09:56:24 2019 +0900
>@@ -35,9 +35,6 @@
> 
> #include <imm.h>
> 
>-#define MAX_CANDLIST    10
>-#define MAX_CANDLENGTH  256
>-
> #include "SDL_windowsclipboard.h"
> #include "SDL_windowsevents.h"
> #include "SDL_windowskeyboard.h"
>@@ -153,6 +150,8 @@
>     WCHAR ime_composition[SDL_TEXTEDITINGEVENT_TEXT_SIZE];
>     WCHAR ime_readingstring[16];
>     int ime_cursor;
>+    Uint16 ime_target_start;
>+    Uint16 ime_target_end;
> 
>     SDL_bool ime_candlist;
>     WCHAR ime_candidates[MAX_CANDLIST][MAX_CANDLENGTH];
>diff -r bfed06214c2a test/testime.c
>--- a/test/testime.c	Tue Aug 27 11:38:43 2019 +0200
>+++ b/test/testime.c	Tue Sep 10 09:56:24 2019 +0900
>@@ -46,6 +46,7 @@
> static SDL_Color textColor = {0,0,0,255};
> static char text[MAX_TEXT_LENGTH], markedText[SDL_TEXTEDITINGEVENT_TEXT_SIZE];
> static int cursor = 0;
>+static int cursor_end = 0;
> #ifdef HAVE_SDL_TTF
> static TTF_Font *font;
> #else
>@@ -450,11 +451,13 @@
>     markedText[0] = 0;
> 
>     SDL_StartTextInput();
>+    SDL_EventState(SDL_TEXTEDITINGEX, SDL_ENABLE);
> }
> 
> void CleanupVideo()
> {
>     SDL_StopTextInput();
>+    SDL_EventState(SDL_TEXTEDITINGEX, SDL_DISABLE);
> #ifdef HAVE_SDL_TTF
>     TTF_CloseFont(font);
>     TTF_Quit();
>@@ -518,11 +521,13 @@
>     {
>         /* Stop text input because we cannot hold any more characters */
>         SDL_StopTextInput();
>+        SDL_EventState(SDL_TEXTEDITINGEX, SDL_DISABLE);
>         return;
>     }
>     else
>     {
>         SDL_StartTextInput();
>+        SDL_EventState(SDL_TEXTEDITINGEX, SDL_ENABLE);
>     }
> 
>     cursorRect = drawnTextRect;
>@@ -538,21 +543,31 @@
> 
>     if (markedText[0])
>     {
>+        underlineRect = markedRect;
>+        underlineRect.w = 0;
> #ifdef HAVE_SDL_TTF
>         SDL_Surface *textSur;
>         SDL_Texture *texture;
>         if (cursor)
>         {
>             char *p = utf8_advance(markedText, cursor);
>-            char c = 0;
>+            char *t = utf8_advance(p, cursor_end - cursor);
>+            char cp = 0, ct = 0;
>             if (!p)
>                 p = &markedText[SDL_strlen(markedText)];
>+            if (!t)
>+                t = &markedText[SDL_strlen(markedText)];
> 
>-            c = *p;
>+            cp = *p;
>             *p = 0;
>             TTF_SizeUTF8(font, markedText, &drawnTextRect.w, NULL);
>             cursorRect.x += drawnTextRect.w;
>-            *p = c;
>+            *p = cp;
>+
>+            ct = *t;
>+            *t = 0;
>+            TTF_SizeUTF8(font, p, &underlineRect.w, NULL);
>+            *t = ct;
>         }
>         textSur = TTF_RenderUTF8_Blended(font, markedText, textColor);
>         /* Vertically center text */
>@@ -586,6 +601,8 @@
>             drawnTextRect.w += advance;
>             if (i < cursor)
>                 cursorRect.x += advance;
>+            else if (i < cursor_end)
>+                underlineRect.w += advance;
>             i++;
>             utext += len;
>         }
>@@ -597,10 +614,9 @@
>             cursorRect.h = drawnTextRect.h;
>         }
> 
>-        underlineRect = markedRect;
>+        underlineRect.x = cursorRect.x;
>         underlineRect.y = drawnTextRect.y + drawnTextRect.h - 2;
>         underlineRect.h = 2;
>-        underlineRect.w = drawnTextRect.w;
> 
>         SDL_SetRenderDrawColor(renderer, lineColor.r, lineColor.g, lineColor.b, lineColor.a);
>         SDL_RenderFillRect(renderer, &underlineRect);
>@@ -704,7 +720,7 @@
>     while (!done) {
>         /* Check for events */
>         while (SDL_PollEvent(&event)) {
>-            SDLTest_CommonEvent(state, &event, &done);
>+            /* SDLTest_CommonEvent(state, &event, &done); */
>             switch(event.type) {
>                 case SDL_KEYDOWN: {
>                     switch (event.key.keysym.sym)
>@@ -722,6 +738,7 @@
>                                  do {
>                                      if (textlen==0)
>                                      {
>+                                         done = 1;
>                                          break;
>                                      }
>                                      if ((text[textlen-1] & 0x80) == 0x00)
>@@ -760,7 +777,37 @@
>                             event.key.keysym.sym, SDL_GetKeyName(event.key.keysym.sym));
>                     break;
> 
>-                case SDL_TEXTINPUT:
>+                case SDL_TEXTEDITINGEX:
>+                    if (event.editx.commit) {
>+                        if (!event.editx.composition ||
>+                            !event.editx.composition[0] || event.editx.composition[0] == '\n' ||
>+                            markedRect.w < 0)
>+                            break;
>+
>+                        SDL_Log("Keyboard: text input \"%s\"\n", event.editx.composition);
>+
>+                        if (SDL_strlen(text) + SDL_strlen(event.editx.composition) < sizeof(text))
>+                            SDL_strlcat(text, event.editx.composition, sizeof(text));
>+
>+                        SDL_Log("text inputed: %s\n", text);
>+
>+                        /* After text inputed, we can clear up markedText because it */
>+                        /* is committed */
>+                        markedText[0] = 0;
>+                        Redraw();
>+                        break;
>+                    } else {
>+                        SDL_Log("text editing \"%s\", target range (%d, %d)\n",
>+                                event.editx.composition, event.editx.target_start, event.editx.target_end);
>+
>+                        SDL_strlcpy(markedText, event.editx.composition, SDL_TEXTEDITINGEVENT_TEXT_SIZE);
>+                        cursor = event.editx.target_start;
>+                        cursor_end = event.editx.target_end;
>+                        Redraw();
>+                        break;
>+                    }
>+
>+                // case SDL_TEXTINPUT:
>                     if (event.text.text[0] == '\0' || event.text.text[0] == '\n' ||
>                         markedRect.w < 0)
>                         break;
>@@ -778,7 +825,7 @@
>                     Redraw();
>                     break;
> 
>-                case SDL_TEXTEDITING:
>+                // case SDL_TEXTEDITING:
>                     SDL_Log("text editing \"%s\", selected range (%d, %d)\n",
>                             event.edit.text, event.edit.start, event.edit.length);
>

Actions: View | Diff

Attachments on bug 3006: 3958 | 3962

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.