From 779b56276cbe5042596b8f1a04800114309c2468 Mon Sep 17 00:00:00 2001 From: Yoshiki Shibukawa Date: Wed, 9 Dec 2015 12:05:39 +0900 Subject: [PATCH] Add preedit text callback API Fixes #41. Closes #658. --- .gitignore | 1 - CMakeLists.txt | 1 + docs/input.dox | 90 ++++++++++++++++ include/GLFW/glfw3.h | 164 +++++++++++++++++++++++++++-- src/cocoa_window.m | 108 ++++++++++++++++++- src/input.c | 63 +++++++++++ src/internal.h | 65 ++++++++++++ src/mir_window.c | 19 ++++ src/osmesa_window.c | 13 +++ src/win32_window.c | 124 +++++++++++++++++++++- src/window.c | 10 +- src/wl_window.c | 22 ++++ src/x11_platform.h | 10 ++ src/x11_window.c | 244 ++++++++++++++++++++++++++++++++++++++++++- tests/events.c | 41 ++++++++ 15 files changed, 959 insertions(+), 16 deletions(-) diff --git a/.gitignore b/.gitignore index dd88e65e..7eb1d6ac 100644 --- a/.gitignore +++ b/.gitignore @@ -81,4 +81,3 @@ tests/timeout tests/title tests/vulkan tests/windows - diff --git a/CMakeLists.txt b/CMakeLists.txt index a480de37..2ae748e5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -226,6 +226,7 @@ endif() if (_GLFW_WIN32) list(APPEND glfw_PKG_LIBS "-lgdi32") + list(APPEND glfw_LIBRARIES "imm32") if (GLFW_USE_HYBRID_HPG) set(_GLFW_USE_HYBRID_HPG 1) diff --git a/docs/input.dox b/docs/input.dox index 497fe676..8b448e81 100644 --- a/docs/input.dox +++ b/docs/input.dox @@ -206,6 +206,96 @@ void charmods_callback(GLFWwindow* window, unsigned int codepoint, int mods) } @endcode +@subsection preedit IME Support + +All desktop operating systems support IME (Input Method Editor) to input characters +that are not mapped with physical keys. IME have been popular among Eeastern Asian people. +And some operating systems start supporting voice input via IME mechanism. + +GLFW provides IME support functions to help +you implement better text input features. You should add suitable visualization code for +preedit text. + +IME works in front of actual character input events (@ref input_char). +If your application uses text input and you want to support IME, +you should register preedit callback to receive preedit text before committed. + +@code +glfwSetPreeditCallback(window, preedit_callback); +@endcode + +The callback function receives chunk of text and focused block information. + +@code +static void preedit_callback(GLFWwindow* window, int strLength, unsigned int* string, int blockLength, int* blocks, int focusedBlock) { +} +@endcode + +strLength and string parameter reprsent whole preedit text. Each character of the preedit string is a codepoint like @ref input_char. + +If you want to type the text "寿司(sushi)", Usually the callback is called several times like the following sequence: + +-# key event: s +-# preedit: [string: "ｓ", block: [1], focusedBlock: 0] +-# key event: u +-# preedit: [string: "す", block: [1], focusedBlock: 0] +-# key event: s +-# preedit: [string: "すｓ", block: [2], focusedBlock: 0] +-# key event: h +-# preedit: [string: "すｓｈ", block: [2], focusedBlock: 0] +-# key event: i +-# preedit: [string: "すし", block: [2], focusedBlock: 0] +-# key event: ' ' +-# preedit: [string: "寿司", block: [2], focusedBlock: 0] +-# char: '寿' +-# char: '司' +-# preedit: [string: "", block: [], focusedBlock: 0] + +If preedit text includes several semantic blocks, preedit callbacks returns several blocks after a space key pressed: + +-# preedit: [string: "わたしはすしをたべます", block: [11], focusedBlock: 0] +-# preedit: [string: "私は寿司を食べます", block: [2, 7], focusedBlock: 1] + +"blocks" is a list of block length. The above case, it contains the following blocks and second block is focused. + +- 私は +- [寿司を食べます] + +commited text(passed via regular @ref input_char event), unfocused block, focused block should have different text style. + + +GLFW provides helper function to teach suitable position of the candidate window to window system. +Window system decides the best position from text cursor geometry (x, y coords and height). You should call this function +in the above preedit text callback function. + +@code +glfwSetPreeditCursorPos(window, x, y, h); +glfwGetPreeditCursorPos(window, &x, &y, &h); +@endcode + +Sometimes IME task is interrupted by user or application. There are several functions to support these situation. +You can receive notification about IME status change(on/off) by using the following function: + +@code +glfwSetIMEStatusCallback(window, imestatus_callback); +@endcode + +imestatus_callback has simple sigunature like this: + +@code +static void imestatus_callback(GLFWwindow* window) { +} +@endcode + +You can implement the code that resets or commits preedit text when IME status is changed and preedit text is not empty. + +When the focus is gone from text box, you can use the following functions to reset IME status: + +@code +void glfwResetPreeditText(GLFWwindow* window); +void glfwSetIMEStatus(GLFWwindow* window, int active) +int glfwGetIMEStatus(GLFWwindow* window) +@endcode @subsection input_key_name Key names diff --git a/include/GLFW/glfw3.h b/include/GLFW/glfw3.h index 15ace888..be3dbd16 100644 --- a/include/GLFW/glfw3.h +++ b/include/GLFW/glfw3.h @@ -686,6 +686,7 @@ extern "C" { #define GLFW_CURSOR 0x00033001 #define GLFW_STICKY_KEYS 0x00033002 #define GLFW_STICKY_MOUSE_BUTTONS 0x00033003 +#define GLFW_IME 0x00033004 #define GLFW_CURSOR_NORMAL 0x00034001 #define GLFW_CURSOR_HIDDEN 0x00034002 @@ -1100,6 +1101,37 @@ typedef void (* GLFWcharfun)(GLFWwindow*,unsigned int); */ typedef void (* GLFWcharmodsfun)(GLFWwindow*,unsigned int,int); +/*! @brief The function signature for preedit callbacks. + * + * This is the function signature for preedit callback functions. + * + * @param[in] window The window that received the event. + * @param[in] length Preedit string length. + * @param[in] string Preedit string. + * @param[in] count Attributed block count. + * @param[in] blocksizes List of attributed block size. + * @param[in] focusedblock Focused block index. + * + * @sa @ref preedit + * @sa glfwSetPreeditCallback + * + * @ingroup input + */ +typedef void (* GLFWpreeditfun)(GLFWwindow*,int,unsigned int*,int,int*,int); + +/*! @brief The function signature for IME status change callbacks. + * + * This is the function signature for IME status change callback functions. + * + * @param[in] window The window that received the event. + * + * @sa @ref preedit + * @sa glfwSetIMEStatusCallback + * + * @ingroup monitor + */ +typedef void (* GLFWimestatusfun)(GLFWwindow*); + /*! @brief The function signature for file drop callbacks. * * This is the function signature for file drop callbacks. @@ -3009,12 +3041,12 @@ GLFWAPI void glfwPostEmptyEvent(void); /*! @brief Returns the value of an input option for the specified window. * * This function returns the value of an input option for the specified window. - * The mode must be one of `GLFW_CURSOR`, `GLFW_STICKY_KEYS` or - * `GLFW_STICKY_MOUSE_BUTTONS`. + * The mode must be one of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`, + * `GLFW_STICKY_MOUSE_BUTTONS` or `GLFW_IME`. * * @param[in] window The window to query. - * @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS` or - * `GLFW_STICKY_MOUSE_BUTTONS`. + * @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`, + * `GLFW_STICKY_MOUSE_BUTTONS` or `GLFW_IME`. * * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref * GLFW_INVALID_ENUM. @@ -3032,8 +3064,8 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode); /*! @brief Sets an input option for the specified window. * * This function sets an input mode option for the specified window. The mode - * must be one of `GLFW_CURSOR`, `GLFW_STICKY_KEYS` or - * `GLFW_STICKY_MOUSE_BUTTONS`. + * must be one of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`, + * `GLFW_STICKY_MOUSE_BUTTONS` or `GLFW_IME`. * * If the mode is `GLFW_CURSOR`, the value must be one of the following cursor * modes: @@ -3059,9 +3091,12 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode); * you are only interested in whether mouse buttons have been pressed but not * when or in which order. * + * If the mode is `GLFW_IME`, the value must be either `GLFW_TRUE` to turn on IME, + * or `GLFW_FALSE` to turn off it. + * * @param[in] window The window whose input mode to set. - * @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS` or - * `GLFW_STICKY_MOUSE_BUTTONS`. + * @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`, + * `GLFW_STICKY_MOUSE_BUTTONS` or `GLFW_IME` * @param[in] value The new value of the specified input mode. * * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref @@ -3422,6 +3457,67 @@ GLFWAPI void glfwDestroyCursor(GLFWcursor* cursor); */ GLFWAPI void glfwSetCursor(GLFWwindow* window, GLFWcursor* cursor); +/*! @brief Retrieves the position of the text cursor relative to the client area of window. + * + * This function returns position hint to decide the candidate window. + * + * @param[in] window The window to set the text cursor for. + * @param[out] x The text cursor x position (relative position from window coordinates). + * @param[out] y The text cursor y position (relative position from window coordinates). + * @param[out] h The text cursor height. + * + * @par Thread Safety + * This function may only be called from the main thread. + * + * @sa @ref input_char + * + * @since Added in GLFW 3.X. + * + * @ingroup input + */ +GLFWAPI void glfwGetPreeditCursorPos(GLFWwindow* window, int *x, int *y, int *h); + +/*! @brief Notify the text cursor position to window system to decide the candidate window position. + * + * This function teach position hint to decide the candidate window. The candidate window + * is a part of IME(Input Method Editor) and show several candidate strings. + * + * Windows sytems decide proper pisition from text cursor geometry. + * You should call this function in preedit callback. + * + * @param[in] window The window to set the text cursor for. + * @param[in] x The text cursor x position (relative position from window coordinates). + * @param[in] y The text cursor y position (relative position from window coordinates). + * @param[in] h The text cursor height. + * + * @par Thread Safety + * This function may only be called from the main thread. + * + * @sa @ref input_char + * + * @since Added in GLFW 3.X. + * + * @ingroup input + */ +GLFWAPI void glfwSetPreeditCursorPos(GLFWwindow* window, int x, int y, int h); + +/*! @brief Reset IME input status. + * + * This function resets IME's preedit text. + * + * @param[in] window The window. + * + * @par Thread Safety + * This function may only be called from the main thread. + * + * @sa @ref preedit + * + * @since Added in GLFW 3.X. + * + * @ingroup input + */ +GLFWAPI void glfwResetPreeditText(GLFWwindow* window); + /*! @brief Sets the key callback. * * This function sets the key callback of the specified window, which is called @@ -3536,6 +3632,58 @@ GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* window, GLFWcharfun cbfun); */ GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* window, GLFWcharmodsfun cbfun); +/*! @brief Sets the preedit callback. + * + * This function sets the preedit callback of the specified + * window, which is called when an IME is processing text before commited. + * + * Callback receives relative position of input cursor inside preedit text and + * attributed text blocks. This callback is used for on-the-spot text editing + * with IME. + * + * @param[in] window The window whose callback to set. + * @param[in] cbfun The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or an + * error occurred. + * + * @par Thread Safety + * This function may only be called from the main thread. + * + * @sa @ref input_char + * + * @since Added in GLFW 3.X + * + * @ingroup input + */ +GLFWAPI GLFWpreeditfun glfwSetPreeditCallback(GLFWwindow* window, GLFWpreeditfun cbfun); + +/*! @brief Sets the IME status change callback. + * + * This function sets the preedit callback of the specified + * window, which is called when an IME is processing text before commited. + * + * Callback receives relative position of input cursor inside preedit text and + * attributed text blocks. This callback is used for on-the-spot text editing + * with IME. + * + * @param[in] window The window whose callback to set. + * @param[in] cbfun The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or an + * error occurred. + * + * @par Thread Safety + * This function may only be called from the main thread. + * + * @sa @ref input_char + * + * @since Added in GLFW 3.X + * + * @ingroup input + */ +GLFWAPI GLFWimestatusfun glfwSetIMEStatusCallback(GLFWwindow* window, GLFWimestatusfun cbfun); + /*! @brief Sets the mouse button callback. * * This function sets the mouse button callback of the specified window, which diff --git a/src/cocoa_window.m b/src/cocoa_window.m index 93f1a203..eb63d3c8 100644 --- a/src/cocoa_window.m +++ b/src/cocoa_window.m @@ -316,8 +316,11 @@ static const NSRange kEmptyRange = { NSNotFound, 0 }; _glfwInputWindowFocus(window, GLFW_FALSE); } -@end +- (void)imeStatusChangeNotified:(NSNotification *)notification { + _glfwInputIMEStatus(window); +} +@end //------------------------------------------------------------------------ // Delegate for application related notifications @@ -714,6 +717,56 @@ static const NSRange kEmptyRange = { NSNotFound, 0 }; [markedText initWithAttributedString:string]; else [markedText initWithString:string]; + NSString* markedTextString = markedText.string; + + NSUInteger i, length = [markedTextString length]; + int ctext = window->ctext; + while (ctext < length+1) { + ctext = (ctext == 0) ? 1 : ctext*2; + } + if (ctext != window->ctext) { + unsigned int* preeditText = realloc(window->preeditText, sizeof(unsigned int)*ctext); + if (preeditText == NULL) { + return; + } + window->preeditText = preeditText; + window->ctext = ctext; + } + window->ntext = length; + window->preeditText[length] = 0; + for (i = 0; i < length; i++) + { + const unichar codepoint = [markedTextString characterAtIndex:i]; + window->preeditText[i] = codepoint; + } + int focusedBlock = 0; + NSInteger offset = 0; + window->nblocks = 0; + while (offset < length) { + NSRange effectiveRange; + NSDictionary *attributes = [markedText attributesAtIndex:offset effectiveRange:&effectiveRange]; + + if (window->nblocks == window->cblocks) { + int cblocks = window->cblocks * 2; + int* blocks = realloc(window->preeditAttributeBlocks, sizeof(int)*cblocks); + if (blocks == NULL) { + return; + } + window->preeditAttributeBlocks = blocks; + window->cblocks = cblocks; + } + window->preeditAttributeBlocks[window->nblocks] = effectiveRange.length; + offset += effectiveRange.length; + if (effectiveRange.length == 0) { + break; + } + NSNumber* underline = (NSNumber*) [attributes objectForKey:@"NSUnderline"]; + if ([underline intValue] != 1) { + focusedBlock = window->nblocks; + } + window->nblocks++; + } + _glfwInputPreedit(window, focusedBlock); } - (void)unmarkText @@ -742,8 +795,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 }; { int xpos, ypos; _glfwPlatformGetWindowPos(window, &xpos, &ypos); - const NSRect contentRect = [window->ns.view frame]; - return NSMakeRect(xpos, transformY(ypos + contentRect.size.height), 0.0, 0.0); + return NSMakeRect(xpos + window->preeditCursorPosX, transformY(ypos + window->preeditCursorPosY), 0.0, window->preeditCursorHeight); } - (void)insertText:(id)string replacementRange:(NSRange)replacementRange @@ -1049,6 +1101,11 @@ static GLFWbool createNativeWindow(_GLFWwindow* window, [window->ns.object setAcceptsMouseMovedEvents:YES]; [window->ns.object setRestorable:NO]; + [[NSNotificationCenter defaultCenter] + addObserver: window->ns.delegate + selector:@selector(imeStatusChangeNotified:) + name:NSTextInputContextKeyboardSelectionDidChangeNotification + object: nil]; return GLFW_TRUE; } @@ -1102,6 +1159,8 @@ void _glfwPlatformDestroyWindow(_GLFWwindow* window) if (_glfw.ns.disabledCursorWindow == window) _glfw.ns.disabledCursorWindow = NULL; + [[NSNotificationCenter defaultCenter] removeObserver: window->ns.delegate]; + [window->ns.object orderOut:nil]; if (window->monitor) @@ -1735,6 +1794,49 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance, #endif } +void _glfwPlatformResetPreeditText(_GLFWwindow* window) +{ + NSTextInputContext *context = [NSTextInputContext currentInputContext]; + [context discardMarkedText]; + [window->ns.view unmarkText]; +} + +void _glfwPlatformSetIMEStatus(_GLFWwindow* window, int active) +{ + // Mac OS has several input sources. + // this code assumes input methods not in ascii capable inputs using IME. + NSArray* asciiInputSources = CFBridgingRelease(TISCreateASCIICapableInputSourceList()); + TISInputSourceRef asciiSource = (__bridge TISInputSourceRef)([asciiInputSources firstObject]); + if (active) { + NSArray* allInputSources = CFBridgingRelease(TISCreateInputSourceList(NULL, false)); + NSString* asciiSourceID = (__bridge NSString *)(TISGetInputSourceProperty(asciiSource, kTISPropertyInputSourceID)); + int i; + int count = [allInputSources count]; + for (i = 0; i < count; i++) { + TISInputSourceRef source = (__bridge TISInputSourceRef)([allInputSources objectAtIndex: i]); + NSString* sourceID = (__bridge NSString *)(TISGetInputSourceProperty(source, kTISPropertyInputSourceID)); + if ([asciiSourceID compare: sourceID] != NSOrderedSame) { + TISSelectInputSource(source); + break; + } + } + } else if (asciiSource) { + TISSelectInputSource(asciiSource); + } +} + +int _glfwPlatformGetIMEStatus(_GLFWwindow* window) +{ + TISInputSourceRef currentSource = TISCopyCurrentKeyboardInputSource(); + NSString* currentSourceID = (__bridge NSString *)(TISGetInputSourceProperty(currentSource, kTISPropertyInputSourceID)); + NSArray* asciiInputSources = CFBridgingRelease(TISCreateASCIICapableInputSourceList()); + TISInputSourceRef asciiSource = (__bridge TISInputSourceRef)([asciiInputSources firstObject]); + if (asciiSource) { + NSString* asciiSourceID = (__bridge NSString *)(TISGetInputSourceProperty(asciiSource, kTISPropertyInputSourceID)); + return ([asciiSourceID compare: currentSourceID] == NSOrderedSame) ? GLFW_FALSE : GLFW_TRUE; + } + return GLFW_FALSE; +} ////////////////////////////////////////////////////////////////////////// ////// GLFW native API ////// diff --git a/src/input.c b/src/input.c index f44ea575..dd8dfac1 100644 --- a/src/input.c +++ b/src/input.c @@ -79,6 +79,20 @@ void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, GLFWb } } +void _glfwInputPreedit(_GLFWwindow* window, int focusedBlock) +{ + if (window->callbacks.preedit) { + window->callbacks.preedit((GLFWwindow*) window, window->ntext, window->preeditText, window->nblocks, window->preeditAttributeBlocks, focusedBlock); + } +} + +void _glfwInputIMEStatus(_GLFWwindow* window) +{ + if (window->callbacks.imestatus) { + window->callbacks.imestatus((GLFWwindow*) window); + } +} + void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset) { if (window->callbacks.scroll) @@ -162,6 +176,8 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode) return window->stickyKeys; case GLFW_STICKY_MOUSE_BUTTONS: return window->stickyMouseButtons; + case GLFW_IME: + return _glfwPlatformGetIMEStatus(window); default: _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode %i", mode); return 0; @@ -245,6 +261,13 @@ GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value) window->stickyMouseButtons = value ? GLFW_TRUE : GLFW_FALSE; return; } + + case GLFW_IME: + _glfwPlatformSetIMEStatus(window, value ? GLFW_TRUE : GLFW_FALSE); + break; + default: + _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode %i", mode); + break; } _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode %i", mode); @@ -469,6 +492,30 @@ GLFWAPI void glfwSetCursor(GLFWwindow* windowHandle, GLFWcursor* cursorHandle) _glfwPlatformSetCursor(window, cursor); } +GLFWAPI void glfwGetPreeditCursorPos(GLFWwindow* handle, int *x, int *y, int *h) +{ + _GLFWwindow* window = (_GLFWwindow*) handle; + if (x) + *x = window->preeditCursorPosX; + if (y) + *y = window->preeditCursorPosY; + if (h) + *h = window->preeditCursorHeight; +} + +GLFWAPI void glfwSetPreeditCursorPos(GLFWwindow* handle, int x, int y, int h) +{ + _GLFWwindow* window = (_GLFWwindow*) handle; + window->preeditCursorPosX = x; + window->preeditCursorPosY = y; + window->preeditCursorHeight = h; +} + +GLFWAPI void glfwResetPreeditText(GLFWwindow* handle) { + _GLFWwindow* window = (_GLFWwindow*) handle; + _glfwPlatformResetPreeditText(window); +} + GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* handle, GLFWkeyfun cbfun) { _GLFWwindow* window = (_GLFWwindow*) handle; @@ -499,6 +546,22 @@ GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* handle, GLFWcharmods return cbfun; } +GLFWAPI GLFWpreeditfun glfwSetPreeditCallback(GLFWwindow* handle, GLFWpreeditfun cbfun) +{ + _GLFWwindow* window = (_GLFWwindow*) handle; + _GLFW_REQUIRE_INIT_OR_RETURN(NULL); + _GLFW_SWAP_POINTERS(window->callbacks.preedit, cbfun); + return cbfun; +} + +GLFWAPI GLFWimestatusfun glfwSetIMEStatusCallback(GLFWwindow* handle, GLFWimestatusfun cbfun) +{ + _GLFWwindow* window = (_GLFWwindow*) handle; + _GLFW_REQUIRE_INIT_OR_RETURN(NULL); + _GLFW_SWAP_POINTERS(window->callbacks.imestatus, cbfun); + return cbfun; +} + GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* handle, GLFWmousebuttonfun cbfun) { diff --git a/src/internal.h b/src/internal.h index 42e8d539..5052cf1c 100644 --- a/src/internal.h +++ b/src/internal.h @@ -370,9 +370,19 @@ struct _GLFWwindow int cursorMode; char mouseButtons[GLFW_MOUSE_BUTTON_LAST + 1]; char keys[GLFW_KEY_LAST + 1]; + // Virtual cursor position when cursor is disabled double virtualCursorPosX, virtualCursorPosY; + // Preedit texts + unsigned int* preeditText; + int ntext; + int ctext; + int* preeditAttributeBlocks; + int nblocks; + int cblocks; + int preeditCursorPosX, preeditCursorPosY, preeditCursorHeight; + _GLFWcontext context; struct { @@ -391,6 +401,8 @@ struct _GLFWwindow GLFWkeyfun key; GLFWcharfun character; GLFWcharmodsfun charmods; + GLFWpreeditfun preedit; + GLFWimestatusfun imestatus; GLFWdropfun drop; } callbacks; @@ -818,6 +830,46 @@ int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance, VkPhy */ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance, _GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface); +/*! @copydoc glfwResetPreeditText + * @ingroup platform + */ +void _glfwPlatformResetPreeditText(_GLFWwindow* window); + +/*! @brief Set IME status. + * + * This function set IME status. + * + * @param[in] window The window. + * @param[in] active Turns on IME if `GFLW_TRUE` is given. Otherwise (`GLFW_FALSE`) turns off. + * + * @par Thread Safety + * This function may only be called from the main thread. + * + * @sa @ref preedit + * + * @since Added in GLFW 3.X. + * + * @ingroup platform + */ +void _glfwPlatformSetIMEStatus(_GLFWwindow* window, int active); + +/*! @brief Get IME status. + * + * This function get IME status. + * + * @param[in] window The window. + * @return When IME is active, this function returns `GFLW_TRUE`. Otherwise `GLFW_FALSE`. + * + * @par Thread Safety + * This function may only be called from the main thread. + * + * @sa @ref preedit + * + * @since Added in GLFW 3.X. + * + * @ingroup platform + */ +int _glfwPlatformGetIMEStatus(_GLFWwindow* window); //======================================================================== // Event API functions @@ -904,6 +956,19 @@ void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int m */ void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, GLFWbool plain); +/*! @brief Notifies shared code of a IME preedit text update event. + * @param[in] window The window that received the event. + * @param[in] focusedBlock Focused preedit text block index. + * @ingroup event + */ +void _glfwInputPreedit(_GLFWwindow* window, int focusedBlock); + +/*! @brief Notifies shared code of a IME status change. + * @param[in] window The window that received the event. + * @ingroup event + */ +void _glfwInputIMEStatus(_GLFWwindow* window); + /*! @brief Notifies shared code of a scroll event. * @param[in] window The window that received the event. * @param[in] xoffset The scroll offset along the x-axis. diff --git a/src/mir_window.c b/src/mir_window.c index 7d2c276a..6ed6d2c6 100644 --- a/src/mir_window.c +++ b/src/mir_window.c @@ -890,6 +890,25 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance, return err; } +void _glfwPlatformResetPreeditText(_GLFWwindow* window) +{ + _glfwInputError(GLFW_PLATFORM_ERROR, + "Mir: Unsupported function %s", __PRETTY_FUNCTION__); +} + +void _glfwPlatformSetIMEStatus(_GLFWwindow* window, int active) +{ + _glfwInputError(GLFW_PLATFORM_ERROR, + "Mir: Unsupported function %s", __PRETTY_FUNCTION__); +} + +int _glfwPlatformGetIMEStatus(_GLFWwindow* window) +{ + _glfwInputError(GLFW_PLATFORM_ERROR, + "Mir: Unsupported function %s", __PRETTY_FUNCTION__); + return GLFW_FALSE; +} + ////////////////////////////////////////////////////////////////////////// ////// GLFW native API ////// diff --git a/src/osmesa_window.c b/src/osmesa_window.c index cba95530..a435077b 100644 --- a/src/osmesa_window.c +++ b/src/osmesa_window.c @@ -301,3 +301,16 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance, return VK_ERROR_INITIALIZATION_FAILED; } +void _glfwPlatformResetPreeditText(_GLFWwindow* window) +{ +} + +void _glfwPlatformSetIMEStatus(_GLFWwindow* window, int active) +{ +} + +int _glfwPlatformGetIMEStatus(_GLFWwindow* window) +{ + return GLFW_FALSE; +} + diff --git a/src/win32_window.c b/src/win32_window.c index 9214a66c..6b7cc568 100644 --- a/src/win32_window.c +++ b/src/win32_window.c @@ -33,6 +33,7 @@ #include #include #include +#include #define _GLFW_KEY_INVALID -2 @@ -422,6 +423,15 @@ static void releaseMonitor(_GLFWwindow* window) _glfwRestoreVideoModeWin32(window->monitor); } +// Set cursor position to decide candidate window +static void _win32ChangeCursorPosition(HIMC hIMC, _GLFWwindow* window) { + int x = window->preeditCursorPosX; + int y = window->preeditCursorPosY; + int h = window->preeditCursorHeight; + CANDIDATEFORM excludeRect = {0, CFS_EXCLUDE, {x, y}, {x, y, x, y+h}}; + ImmSetCandidateWindow(hIMC, &excludeRect); +} + // Window callback function (handles window messages) // static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, @@ -536,7 +546,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, } _glfwInputChar(window, (unsigned int) wParam, getKeyMods(), plain); - return 0; + return TRUE; } case WM_KEYDOWN: @@ -570,7 +580,93 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, break; } - + case WM_IME_COMPOSITION: + { + if (lParam & GCS_RESULTSTR) { + window->nblocks = 0; + window->ntext = 0; + _glfwInputPreedit(window, 0); + return TRUE; + } + if (lParam & GCS_COMPSTR) { + HIMC hIMC = ImmGetContext(hWnd); + // get preedit data sizes + LONG preeditTextLength = ImmGetCompositionStringW(hIMC, GCS_COMPSTR, NULL, 0); + LONG attrLength = ImmGetCompositionString(hIMC, GCS_COMPATTR, NULL, 0); + LONG clauseLength = ImmGetCompositionString(hIMC, GCS_COMPCLAUSE, NULL, 0); + if (preeditTextLength > 0) { + // get preedit data + int length = preeditTextLength/sizeof(WCHAR); + LPWSTR buffer = (LPWSTR)malloc(sizeof(WCHAR)+preeditTextLength); + LPSTR attributes = (LPSTR)malloc(attrLength); + DWORD *clauses = (DWORD*)malloc(clauseLength); + ImmGetCompositionStringW(hIMC, GCS_COMPSTR, buffer, preeditTextLength); + ImmGetCompositionString(hIMC, GCS_COMPATTR, attributes, attrLength); + ImmGetCompositionString(hIMC, GCS_COMPCLAUSE, clauses, clauseLength); + // store preedit text + int ctext = window->ctext; + while (ctext < length+1) { + ctext = (ctext == 0) ? 1 : ctext*2; + } + if (ctext != window->ctext) { + unsigned int* preeditText = realloc(window->preeditText, sizeof(unsigned int)*ctext); + if (preeditText == NULL) { + return 0; + free(buffer); + free(attributes); + free(clauses); + } + window->preeditText = preeditText; + window->ctext = ctext; + } + window->ntext = length; + window->preeditText[length] = 0; + int i; + for (i=0; i < length; i++) { + window->preeditText[i] = buffer[i]; + } + // store blocks + window->nblocks = clauseLength/sizeof(DWORD)-1; + // last element of clauses is a block count, but + // text length is convenient. + clauses[window->nblocks] = length; + int cblocks = window->cblocks; + while (cblocks < window->nblocks) { + cblocks = (cblocks == 0) ? 1 : cblocks*2; + } + if (cblocks != window->cblocks) { + int* blocks = realloc(window->preeditAttributeBlocks, sizeof(int)*cblocks); + if (blocks == NULL) { + return 0; + free(buffer); + free(attributes); + free(clauses); + } + window->preeditAttributeBlocks = blocks; + window->cblocks = cblocks; + } + int focusedBlock = 0; + for (i=0; i < window->nblocks; i++) { + window->preeditAttributeBlocks[i] = clauses[i+1]-clauses[i]; + if (attributes[clauses[i]] != ATTR_CONVERTED) { + focusedBlock = i; + } + } + free(buffer); + free(attributes); + free(clauses); + _glfwInputPreedit(window, focusedBlock); + _win32ChangeCursorPosition(hIMC, window); + } + ImmReleaseContext(hWnd, hIMC); + return TRUE; + } + break; + } + case WM_IME_NOTIFY: + if (wParam == IMN_SETOPENSTATUS) + _glfwInputIMEStatus(window); + break; case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: case WM_MBUTTONDOWN: @@ -1705,6 +1801,30 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance, return err; } +void _glfwPlatformResetPreeditText(_GLFWwindow* window) +{ + HWND hWnd = window->win32.handle; + HIMC hIMC = ImmGetContext(hWnd); + ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0); + ImmReleaseContext(hWnd, hIMC); +} + +void _glfwPlatformSetIMEStatus(_GLFWwindow* window, int active) +{ + HWND hWnd = window->win32.handle; + HIMC hIMC = ImmGetContext(hWnd); + ImmSetOpenStatus(hIMC, active ? TRUE : FALSE); + ImmReleaseContext(hWnd, hIMC); +} + +int _glfwPlatformGetIMEStatus(_GLFWwindow* window) +{ + HWND hWnd = window->win32.handle; + HIMC hIMC = ImmGetContext(hWnd); + BOOL result = ImmGetOpenStatus(hIMC); + ImmReleaseContext(hWnd, hIMC); + return result ? GLFW_TRUE : GLFW_FALSE; +} ////////////////////////////////////////////////////////////////////////// ////// GLFW native API ////// diff --git a/src/window.c b/src/window.c index ece8d75b..75b92764 100644 --- a/src/window.c +++ b/src/window.c @@ -230,6 +230,10 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height, if (wndconfig.focused) _glfwPlatformFocusWindow(window); } + + window->preeditCursorPosX = 0; + window->preeditCursorPosY = height; + window->preeditCursorHeight = 0; } return (GLFWwindow*) window; @@ -408,7 +412,11 @@ GLFWAPI void glfwDestroyWindow(GLFWwindow* handle) *prev = window->next; } - + // Clear memory for preedit text + if (window->preeditText) + free(window->preeditText); + if (window->preeditAttributeBlocks) + free(window->preeditAttributeBlocks); free(window); } diff --git a/src/wl_window.c b/src/wl_window.c index a2bae373..88770477 100644 --- a/src/wl_window.c +++ b/src/wl_window.c @@ -1027,6 +1027,28 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance, return err; } +void _glfwPlatformResetPreeditText(_GLFWwindow* window) +{ + // TODO + _glfwInputError(GLFW_PLATFORM_ERROR, + "Wayland: IME not implemented yet"); +} + +void _glfwPlatformSetIMEStatus(_GLFWwindow* window, int active) +{ + // TODO + _glfwInputError(GLFW_PLATFORM_ERROR, + "Wayland: IME not implemented yet"); +} + +int _glfwPlatformGetIMEStatus(_GLFWwindow* window) +{ + // TODO + _glfwInputError(GLFW_PLATFORM_ERROR, + "Wayland: IME not implemented yet"); + return GLFW_FALSE; +} + ////////////////////////////////////////////////////////////////////////// ////// GLFW native API ////// diff --git a/src/x11_platform.h b/src/x11_platform.h index 4268f262..6f79e197 100644 --- a/src/x11_platform.h +++ b/src/x11_platform.h @@ -128,6 +128,16 @@ typedef struct _GLFWwindowX11 unsigned int lastKeyCode; Time lastKeyTime; + // Preedit callbacks + XIMCallback preeditStartCallback; + XIMCallback preeditDoneCallback; + XIMCallback preeditDrawCallback; + XIMCallback preeditCaretCallback; + XIMCallback statusStartCallback; + XIMCallback statusDoneCallback; + XIMCallback statusDrawCallback; + + int imeFocus; } _GLFWwindowX11; // X11-specific global data diff --git a/src/x11_window.c b/src/x11_window.c index d552e269..0fcc3aa8 100644 --- a/src/x11_window.c +++ b/src/x11_window.c @@ -48,6 +48,9 @@ #define Button6 6 #define Button7 7 +#if defined(X_HAVE_UTF8_STRING) +static unsigned int decodeUTF8(const char** s); +#endif // Wait for data to arrive using select // This avoids blocking other threads via the per-display Xlib lock that also @@ -437,6 +440,196 @@ static char** parseUriList(char* text, int* count) return paths; } +// Update cursor position to decide candidate window +static void _ximChangeCursorPosition(XIC xic, _GLFWwindow* window) +{ + XVaNestedList preedit_attr; + XPoint spot; + + spot.x = window->preeditCursorPosX; + spot.y = window->preeditCursorPosY + window->preeditCursorHeight; + preedit_attr = XVaCreateNestedList(0, XNSpotLocation, &spot, NULL); + XSetICValues(xic, XNPreeditAttributes, preedit_attr, NULL); + XFree(preedit_attr); +} + +// IME Start callback (do nothing) +static void _ximPreeditStartCallback(XIC xic, XPointer clientData, XPointer callData) +{ +} + +// IME Done callback (do nothing) +static void _ximPreeditDoneCallback(XIC xic, XPointer clientData, XPointer callData) +{ +} + +// IME Draw callback +static void _ximPreeditDrawCallback(XIC xic, XPointer clientData, XIMPreeditDrawCallbackStruct *callData) +{ + int i, j, length, ctext, rstart, rend; + XIMText* text; + const char* src; + unsigned int codePoint; + unsigned int* preeditText; + XIMFeedback f; + _GLFWwindow* window = (_GLFWwindow*)clientData; + + // keep cursor position to reduce API call + int cursorX = window->preeditCursorPosX; + int cursorY = window->preeditCursorPosY; + int cursorHeight = window->preeditCursorHeight; + + if (!callData->text) { + // preedit text is empty + window->ntext = 0; + window->nblocks = 0; + _glfwInputPreedit(window, 0); + return; + } else { + text = callData->text; + length = callData->chg_length; + if (text->encoding_is_wchar) { + // wchar is not supported + return; + } + ctext = window->ctext; + while (ctext < length+1) { + ctext = (ctext == 0) ? 1 : ctext * 2; + } + if (ctext != window->ctext) { + preeditText = realloc(window->preeditText, sizeof(unsigned int)*ctext); + if (preeditText == NULL) { + return; + } + window->preeditText = preeditText; + window->ctext = ctext; + } + window->ntext = length; + window->preeditText[length] = 0; + if (window->cblocks == 0) { + window->preeditAttributeBlocks = malloc(sizeof(int)*4); + window->cblocks = 4; + } + src = text->string.multi_byte; + rend = 0; + rstart = length; + for (i = 0, j = 0; i < text->length; i++) { + #if defined(X_HAVE_UTF8_STRING) + codePoint = decodeUTF8(&src); + #else + codePoint = *src; + src++; + #endif + if (i < callData->chg_first || callData->chg_first+length < i) { + continue; + } + window->preeditText[j++] = codePoint; + f = text->feedback[i]; + if ((f & XIMReverse) || (f & XIMHighlight)) { + rend = i; + if (i < rstart) { + rstart = i; + } + } + } + if (rstart == length) { + window->nblocks = 1; + window->preeditAttributeBlocks[0] = length; + window->preeditAttributeBlocks[1] = 0; + _glfwInputPreedit(window, 0); + } else if (rstart == 0) { + if (rend == length -1) { + window->nblocks = 1; + window->preeditAttributeBlocks[0] = length; + window->preeditAttributeBlocks[1] = 0; + _glfwInputPreedit(window, 0); + } else { + window->nblocks = 2; + window->preeditAttributeBlocks[0] = rend + 1; + window->preeditAttributeBlocks[1] = length - rend - 1; + window->preeditAttributeBlocks[2] = 0; + _glfwInputPreedit(window, 0); + } + } else if (rend == length -1) { + window->nblocks = 2; + window->preeditAttributeBlocks[0] = rstart; + window->preeditAttributeBlocks[1] = length - rstart; + window->preeditAttributeBlocks[2] = 0; + _glfwInputPreedit(window, 1); + } else { + window->nblocks = 3; + window->preeditAttributeBlocks[0] = rstart; + window->preeditAttributeBlocks[1] = rend - rstart + 1; + window->preeditAttributeBlocks[2] = length - rend - 1; + window->preeditAttributeBlocks[3] = 0; + _glfwInputPreedit(window, 1); + } + if ((cursorX != window->preeditCursorPosX) + || (cursorY != window->preeditCursorPosY) + || (cursorHeight != window->preeditCursorHeight)) { + _ximChangeCursorPosition(xic, window); + } + } +} + +// IME Caret callback (do nothing) +static void _ximPreeditCaretCallback(XIC xic, XPointer clientData, XPointer callData) +{ +} + +static void _ximStatusStartCallback(XIC xic, XPointer clientData, XPointer callData) +{ + _GLFWwindow* window = (_GLFWwindow*)clientData; + window->x11.imeFocus = GLFW_TRUE; +} + +static void _ximStatusDoneCallback(XIC xic, XPointer clientData, XPointer callData) +{ + _GLFWwindow* window = (_GLFWwindow*)clientData; + window->x11.imeFocus = GLFW_FALSE; +} + +static void _ximStatusDrawCallback(XIC xic, XPointer clientData, XIMStatusDrawCallbackStruct* callData) +{ + _GLFWwindow* window = (_GLFWwindow*)clientData; + _glfwInputIMEStatus(window); +} + +// Create XIM Preedit callback +static XVaNestedList _createXIMPreeditCallbacks(_GLFWwindow* window) +{ + window->x11.preeditStartCallback.client_data = (XPointer)window; + window->x11.preeditStartCallback.callback = (XIMProc)_ximPreeditStartCallback; + window->x11.preeditDoneCallback.client_data = (XPointer)window; + window->x11.preeditDoneCallback.callback = (XIMProc)_ximPreeditDoneCallback; + window->x11.preeditDrawCallback.client_data = (XPointer)window; + window->x11.preeditDrawCallback.callback = (XIMProc)_ximPreeditDrawCallback; + window->x11.preeditCaretCallback.client_data = (XPointer)window; + window->x11.preeditCaretCallback.callback = (XIMProc)_ximPreeditCaretCallback; + return XVaCreateNestedList (0, + XNPreeditStartCallback, &window->x11.preeditStartCallback.client_data, + XNPreeditDoneCallback, &window->x11.preeditDoneCallback.client_data, + XNPreeditDrawCallback, &window->x11.preeditDrawCallback.client_data, + XNPreeditCaretCallback, &window->x11.preeditCaretCallback.client_data, + NULL); +} + +// Create XIM status callback +static XVaNestedList _createXIMStatusCallbacks(_GLFWwindow* window) +{ + window->x11.statusStartCallback.client_data = (XPointer)window; + window->x11.statusStartCallback.callback = (XIMProc)_ximStatusStartCallback; + window->x11.statusDoneCallback.client_data = (XPointer)window; + window->x11.statusDoneCallback.callback = (XIMProc)_ximStatusDoneCallback; + window->x11.statusDrawCallback.client_data = (XPointer)window; + window->x11.statusDrawCallback.callback = (XIMProc)_ximStatusDrawCallback; + return XVaCreateNestedList (0, + XNStatusStartCallback, &window->x11.statusStartCallback.client_data, + XNStatusDoneCallback, &window->x11.statusDoneCallback.client_data, + XNStatusDrawCallback, &window->x11.statusDrawCallback.client_data, + NULL); +} + // Centers the cursor over the window client area // static void centerCursor(_GLFWwindow* window) @@ -646,14 +839,23 @@ static GLFWbool createNativeWindow(_GLFWwindow* window, if (_glfw.x11.im) { + XVaNestedList preeditList = _createXIMPreeditCallbacks(window); + XVaNestedList statusList = _createXIMStatusCallbacks(window); window->x11.ic = XCreateIC(_glfw.x11.im, XNInputStyle, - XIMPreeditNothing | XIMStatusNothing, + XIMPreeditCallbacks | XIMStatusCallbacks, XNClientWindow, window->x11.handle, XNFocusWindow, window->x11.handle, + XNPreeditAttributes, + preeditList, + XNStatusAttributes, + statusList, NULL); + XFree(preeditList); + XFree(statusList); + window->x11.imeFocus = GLFW_FALSE; } _glfwPlatformGetWindowPos(window, &window->x11.xpos, &window->x11.ypos); @@ -2480,6 +2682,46 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance, } } +void _glfwPlatformResetPreeditText(_GLFWwindow* window) { + XIC ic = window->x11.ic; + + /* restore conversion state after resetting ic later */ + XIMPreeditState preedit_state = XIMPreeditUnKnown; + XVaNestedList preedit_attr; + char* result; + + if (window->ntext == 0) + return; + + preedit_attr = XVaCreateNestedList(0, XNPreeditState, &preedit_state, NULL); + XGetICValues(ic, XNPreeditAttributes, preedit_attr, NULL); + XFree(preedit_attr); + + result = XmbResetIC(ic); + + preedit_attr = XVaCreateNestedList(0, XNPreeditState, preedit_state, NULL); + XSetICValues(ic, XNPreeditAttributes, preedit_attr, NULL); + XFree(preedit_attr); + + window->ntext = 0; + window->nblocks = 0; + _glfwInputPreedit(window, 0); + + XFree (result); +} + +void _glfwPlatformSetIMEStatus(_GLFWwindow* window, int active) { + XIC ic = window->x11.ic; + if (active) { + XSetICFocus(ic); + } else { + XUnsetICFocus(ic); + } +} + +int _glfwPlatformGetIMEStatus(_GLFWwindow* window) { + return window->x11.imeFocus; +} ////////////////////////////////////////////////////////////////////////// ////// GLFW native API ////// diff --git a/tests/events.c b/tests/events.c index 73a61ab2..5915078f 100644 --- a/tests/events.c +++ b/tests/events.c @@ -420,6 +420,45 @@ static void char_mods_callback(GLFWwindow* window, unsigned int codepoint, int m get_mods_name(mods)); } +static void preedit_callback(GLFWwindow* window, int strLength, unsigned int* string, int blockLength, int* blocks, int focusedBlock) { + Slot* slot = glfwGetWindowUserPointer(window); + int i, blockIndex = -1, blockCount = 0; + int width, height; + printf("%08x to %i at %0.3f: Preedit text ", + counter++, slot->number, glfwGetTime()); + if (strLength == 0 || blockLength == 0) { + printf("(empty)\n"); + } else { + for (i = 0; i < strLength; i++) { + if (blockCount == 0) { + if (blockIndex == focusedBlock) { + printf("]"); + } + blockIndex++; + blockCount = blocks[blockIndex]; + printf("\n block %d: ", blockIndex); + if (blockIndex == focusedBlock) { + printf("["); + } + } + printf("%s", get_character_string(string[i])); + blockCount--; + } + if (blockIndex == focusedBlock) { + printf("]"); + } + printf("\n"); + glfwGetWindowSize(window, &width, &height); + glfwSetPreeditCursorPos(window, width/2, height/2, 20); + } +} + +static void ime_callback(GLFWwindow* window) { + Slot* slot = glfwGetWindowUserPointer(window); + printf("%08x to %i at %0.3f: IME switched\n", + counter++, slot->number, glfwGetTime()); +} + static void drop_callback(GLFWwindow* window, int count, const char** paths) { int i; @@ -596,6 +635,8 @@ int main(int argc, char** argv) glfwSetKeyCallback(slots[i].window, key_callback); glfwSetCharCallback(slots[i].window, char_callback); glfwSetCharModsCallback(slots[i].window, char_mods_callback); + glfwSetPreeditCallback(slots[i].window, preedit_callback); + glfwSetIMEStatusCallback(slots[i].window, ime_callback); glfwSetDropCallback(slots[i].window, drop_callback); glfwMakeContextCurrent(slots[i].window);