mirror of
https://github.com/hajimehoshi/ebiten.git
synced 2024-09-19 21:02:18 +02:00
314 lines
7.2 KiB
Go
314 lines
7.2 KiB
Go
// Copyright 2024 The Ebitengine Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package textinput
|
|
|
|
import (
|
|
"sync"
|
|
"unsafe"
|
|
|
|
"golang.org/x/sys/windows"
|
|
|
|
"github.com/hajimehoshi/ebiten/v2/internal/microsoftgdk"
|
|
"github.com/hajimehoshi/ebiten/v2/internal/ui"
|
|
)
|
|
|
|
type textInput struct {
|
|
session *session
|
|
|
|
origWndProc uintptr
|
|
wndProcCallback uintptr
|
|
window windows.HWND
|
|
immContext uintptr
|
|
|
|
highSurrogate uint16
|
|
|
|
initOnce sync.Once
|
|
|
|
err error
|
|
}
|
|
|
|
var theTextInput textInput
|
|
|
|
func (t *textInput) Start(x, y int) (chan State, func()) {
|
|
if microsoftgdk.IsXbox() {
|
|
return nil, nil
|
|
}
|
|
|
|
var session *session
|
|
var err error
|
|
ui.Get().RunOnMainThread(func() {
|
|
t.end()
|
|
err = t.start(x, y)
|
|
session = newSession()
|
|
t.session = session
|
|
})
|
|
if err != nil {
|
|
session.ch <- State{Error: err}
|
|
session.end()
|
|
}
|
|
return session.ch, func() {
|
|
ui.Get().RunOnMainThread(func() {
|
|
// Disable IME again.
|
|
if t.immContext != 0 {
|
|
return
|
|
}
|
|
c, err := _ImmAssociateContext(t.window, 0)
|
|
if err != nil {
|
|
t.err = err
|
|
return
|
|
}
|
|
t.immContext = c
|
|
t.end()
|
|
})
|
|
}
|
|
}
|
|
|
|
// start must be called from the main thread.
|
|
func (t *textInput) start(x, y int) error {
|
|
if t.err != nil {
|
|
return t.err
|
|
}
|
|
|
|
if t.window == 0 {
|
|
t.window = _GetActiveWindow()
|
|
}
|
|
if t.origWndProc == 0 {
|
|
if t.wndProcCallback == 0 {
|
|
t.wndProcCallback = windows.NewCallback(t.wndProc)
|
|
}
|
|
// Note that a Win32API GetActiveWindow doesn't work on Xbox.
|
|
h, err := _SetWindowLongPtrW(t.window, _GWL_WNDPROC, t.wndProcCallback)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.origWndProc = h
|
|
}
|
|
|
|
// By default, IME was disabled by setting 0 as the IMM context.
|
|
// Restore the context once.
|
|
var err error
|
|
t.initOnce.Do(func() {
|
|
err = ui.Get().RestoreIMMContextOnMainThread()
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if t.immContext != 0 {
|
|
if _, err := _ImmAssociateContext(t.window, t.immContext); err != nil {
|
|
return err
|
|
}
|
|
t.immContext = 0
|
|
}
|
|
h := _ImmGetContext(t.window)
|
|
if err := _ImmSetCandidateWindow(h, &_CANDIDATEFORM{
|
|
dwIndex: 0,
|
|
dwStyle: _CFS_CANDIDATEPOS,
|
|
ptCurrentPos: _POINT{
|
|
x: int32(x),
|
|
y: int32(y),
|
|
},
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
if err := _ImmReleaseContext(t.window, h); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (t *textInput) wndProc(hWnd uintptr, uMsg uint32, wParam, lParam uintptr) uintptr {
|
|
if t.session == nil {
|
|
return _CallWindowProcW(t.origWndProc, hWnd, uMsg, wParam, lParam)
|
|
}
|
|
|
|
switch uMsg {
|
|
case _WM_IME_SETCONTEXT:
|
|
// Draw preedit text by an application side.
|
|
if lParam&_ISC_SHOWUICOMPOSITIONWINDOW != 0 {
|
|
lParam &^= _ISC_SHOWUICOMPOSITIONWINDOW
|
|
}
|
|
case _WM_IME_COMPOSITION:
|
|
if lParam&(_GCS_RESULTSTR|_GCS_COMPSTR) != 0 {
|
|
if lParam&_GCS_RESULTSTR != 0 {
|
|
if err := t.commit(); err != nil {
|
|
t.session.ch <- State{Error: err}
|
|
t.end()
|
|
}
|
|
}
|
|
if lParam&_GCS_COMPSTR != 0 {
|
|
if err := t.update(); err != nil {
|
|
t.session.ch <- State{Error: err}
|
|
t.end()
|
|
}
|
|
}
|
|
return 1
|
|
}
|
|
case _WM_CHAR, _WM_SYSCHAR:
|
|
if wParam >= 0xd800 && wParam <= 0xdbff {
|
|
t.highSurrogate = uint16(wParam)
|
|
} else {
|
|
var c rune
|
|
if wParam >= 0xdc00 && wParam <= 0xdfff {
|
|
if t.highSurrogate != 0 {
|
|
c += (rune(t.highSurrogate) - 0xd800) << 10
|
|
c += (rune(wParam) & 0xffff) - 0xdc00
|
|
c += 0x10000
|
|
}
|
|
} else {
|
|
c = rune(wParam) & 0xffff
|
|
}
|
|
t.highSurrogate = 0
|
|
if c >= 0x20 {
|
|
str := string(c)
|
|
t.send(str, 0, len(str), true)
|
|
}
|
|
}
|
|
case _WM_UNICHAR:
|
|
if wParam == _UNICODE_NOCHAR {
|
|
// WM_UNICHAR is not sent by Windows, but is sent by some third-party input method engine.
|
|
// Returning TRUE here announces support for this message.
|
|
return 1
|
|
}
|
|
if r := rune(wParam); r >= 0x20 {
|
|
str := string(r)
|
|
t.send(str, 0, len(str), true)
|
|
}
|
|
}
|
|
|
|
return _CallWindowProcW(t.origWndProc, hWnd, uMsg, wParam, lParam)
|
|
}
|
|
|
|
// send must be called from the main thread.
|
|
func (t *textInput) send(text string, startInBytes, endInBytes int, committed bool) {
|
|
if t.session != nil {
|
|
t.session.trySend(State{
|
|
Text: text,
|
|
CompositionSelectionStartInBytes: startInBytes,
|
|
CompositionSelectionEndInBytes: endInBytes,
|
|
Committed: committed,
|
|
})
|
|
}
|
|
if committed {
|
|
t.end()
|
|
}
|
|
}
|
|
|
|
// end must be called from the main thread.
|
|
func (t *textInput) end() {
|
|
if t.session == nil {
|
|
return
|
|
}
|
|
|
|
t.session.end()
|
|
t.session = nil
|
|
}
|
|
|
|
// update must be called from the main thread.
|
|
func (t *textInput) update() (ferr error) {
|
|
if t.err != nil {
|
|
return t.err
|
|
}
|
|
|
|
hIMC := _ImmGetContext(t.window)
|
|
defer func() {
|
|
if err := _ImmReleaseContext(t.window, hIMC); err != nil && ferr != nil {
|
|
ferr = err
|
|
}
|
|
}()
|
|
|
|
bufferLen, err := _ImmGetCompositionStringW(hIMC, _GCS_COMPSTR, nil, 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if bufferLen == 0 {
|
|
return nil
|
|
}
|
|
|
|
buffer16 := make([]uint16, bufferLen/uint32(unsafe.Sizeof(uint16(0))))
|
|
if _, err := _ImmGetCompositionStringW(hIMC, _GCS_COMPSTR, unsafe.Pointer(&buffer16[0]), bufferLen); err != nil {
|
|
return err
|
|
}
|
|
|
|
attrLen, err := _ImmGetCompositionStringW(hIMC, _GCS_COMPATTR, nil, 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
attr := make([]byte, attrLen)
|
|
if _, err := _ImmGetCompositionStringW(hIMC, _GCS_COMPATTR, unsafe.Pointer(&attr[0]), attrLen); err != nil {
|
|
return err
|
|
}
|
|
|
|
clauseLen, err := _ImmGetCompositionStringW(hIMC, _GCS_COMPCLAUSE, nil, 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
clause := make([]uint32, clauseLen/uint32(unsafe.Sizeof(uint32(0))))
|
|
if _, err := _ImmGetCompositionStringW(hIMC, _GCS_COMPCLAUSE, unsafe.Pointer(&clause[0]), clauseLen); err != nil {
|
|
return err
|
|
}
|
|
|
|
var start16 int
|
|
var end16 int
|
|
if len(clause) > 0 {
|
|
for i, c := range clause[:len(clause)-1] {
|
|
if int(c) == len(attr) {
|
|
break
|
|
}
|
|
if attr[c] == _ATTR_TARGET_CONVERTED || attr[c] == _ATTR_TARGET_NOTCONVERTED {
|
|
start16 = int(c)
|
|
end16 = int(clause[i+1])
|
|
break
|
|
}
|
|
}
|
|
}
|
|
text := windows.UTF16ToString(buffer16)
|
|
t.send(text, convertUTF16CountToByteCount(text, start16), convertUTF16CountToByteCount(text, end16), false)
|
|
|
|
return nil
|
|
}
|
|
|
|
// commit must be called from the main thread.
|
|
func (t *textInput) commit() (ferr error) {
|
|
if t.err != nil {
|
|
return t.err
|
|
}
|
|
|
|
hIMC := _ImmGetContext(t.window)
|
|
defer func() {
|
|
if err := _ImmReleaseContext(t.window, hIMC); err != nil && ferr != nil {
|
|
ferr = err
|
|
}
|
|
}()
|
|
|
|
bufferLen, err := _ImmGetCompositionStringW(hIMC, _GCS_RESULTSTR, nil, 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if bufferLen == 0 {
|
|
return nil
|
|
}
|
|
|
|
buffer16 := make([]uint16, bufferLen/uint32(unsafe.Sizeof(uint16(0))))
|
|
if _, err := _ImmGetCompositionStringW(hIMC, _GCS_RESULTSTR, unsafe.Pointer(&buffer16[0]), bufferLen); err != nil {
|
|
return err
|
|
}
|
|
|
|
text := windows.UTF16ToString(buffer16)
|
|
t.send(text, 0, len(text), true)
|
|
|
|
return nil
|
|
}
|