src/video/windows/SDL_windowskeyboard.c
author Sam Lantinga
Tue, 08 Feb 2011 16:50:51 -0800
changeset 5229 c015d3e63631
parent 5220 1fbe1c202501
child 5262 b530ef003506
permissions -rw-r--r--
Fixed setting the texture unit, still doesn't work.
     1 /*
     2     SDL - Simple DirectMedia Layer
     3     Copyright (C) 1997-2010 Sam Lantinga
     4 
     5     This library is free software; you can redistribute it and/or
     6     modify it under the terms of the GNU Lesser General Public
     7     License as published by the Free Software Foundation; either
     8     version 2.1 of the License, or (at your option) any later version.
     9 
    10     This library is distributed in the hope that it will be useful,
    11     but WITHOUT ANY WARRANTY; without even the implied warranty of
    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    13     Lesser General Public License for more details.
    14 
    15     You should have received a copy of the GNU Lesser General Public
    16     License along with this library; if not, write to the Free Software
    17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    18 
    19     Sam Lantinga
    20     slouken@libsdl.org
    21 */
    22 #include "SDL_config.h"
    23 
    24 #ifdef _WIN32_WCE
    25 #define SDL_DISABLE_WINDOWS_IME
    26 #endif
    27 
    28 #include "SDL_windowsvideo.h"
    29 
    30 #include "../../events/SDL_keyboard_c.h"
    31 #include "../../events/scancodes_windows.h"
    32 
    33 #include <imm.h>
    34 #include <oleauto.h>
    35 
    36 #ifndef SDL_DISABLE_WINDOWS_IME
    37 static void IME_Init(SDL_VideoData *videodata, HWND hwnd);
    38 static void IME_Enable(SDL_VideoData *videodata, HWND hwnd);
    39 static void IME_Disable(SDL_VideoData *videodata, HWND hwnd);
    40 static void IME_Quit(SDL_VideoData *videodata);
    41 #endif /* !SDL_DISABLE_WINDOWS_IME */
    42 
    43 #ifndef MAPVK_VK_TO_VSC
    44 #define MAPVK_VK_TO_VSC     0
    45 #endif
    46 #ifndef MAPVK_VSC_TO_VK
    47 #define MAPVK_VSC_TO_VK     1
    48 #endif
    49 #ifndef MAPVK_VK_TO_CHAR
    50 #define MAPVK_VK_TO_CHAR    2
    51 #endif
    52 
    53 /* Alphabetic scancodes for PC keyboards */
    54 BYTE alpha_scancodes[26] = {
    55     30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38, 50, 49, 24,
    56     25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44
    57 };
    58 
    59 BYTE keypad_scancodes[10] = {
    60     82, 79, 80, 81, 75, 76, 77, 71, 72, 73
    61 };
    62 
    63 void
    64 WIN_InitKeyboard(_THIS)
    65 {
    66     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
    67     int i;
    68 
    69     /* Make sure the alpha scancodes are correct.  T isn't usually remapped */
    70     if (MapVirtualKey('T', MAPVK_VK_TO_VSC) != alpha_scancodes['T' - 'A']) {
    71 #if 0
    72         printf
    73             ("Fixing alpha scancode map, assuming US QWERTY layout!\nPlease send the following 26 lines of output to the SDL mailing list <sdl@libsdl.org>, including a description of your keyboard hardware.\n");
    74 #endif
    75         for (i = 0; i < SDL_arraysize(alpha_scancodes); ++i) {
    76             alpha_scancodes[i] = MapVirtualKey('A' + i, MAPVK_VK_TO_VSC);
    77 #if 0
    78             printf("%d = %d\n", i, alpha_scancodes[i]);
    79 #endif
    80         }
    81     }
    82     if (MapVirtualKey(VK_NUMPAD0, MAPVK_VK_TO_VSC) != keypad_scancodes[0]) {
    83 #if 0
    84         printf
    85             ("Fixing keypad scancode map!\nPlease send the following 10 lines of output to the SDL mailing list <sdl@libsdl.org>, including a description of your keyboard hardware.\n");
    86 #endif
    87         for (i = 0; i < SDL_arraysize(keypad_scancodes); ++i) {
    88             keypad_scancodes[i] =
    89                 MapVirtualKey(VK_NUMPAD0 + i, MAPVK_VK_TO_VSC);
    90 #if 0
    91             printf("%d = %d\n", i, keypad_scancodes[i]);
    92 #endif
    93         }
    94     }
    95 
    96     data->key_layout = windows_scancode_table;
    97 
    98     data->ime_com_initialized = SDL_FALSE;
    99     data->ime_threadmgr = 0;
   100     data->ime_initialized = SDL_FALSE;
   101     data->ime_enabled = SDL_FALSE;
   102     data->ime_available = SDL_FALSE;
   103     data->ime_hwnd_main = 0;
   104     data->ime_hwnd_current = 0;
   105     data->ime_himc = 0;
   106     data->ime_composition[0] = 0;
   107     data->ime_readingstring[0] = 0;
   108     data->ime_cursor = 0;
   109 
   110     data->ime_candlist = SDL_FALSE;
   111     SDL_memset(data->ime_candidates, 0, sizeof(data->ime_candidates));
   112     data->ime_candcount = 0;
   113     data->ime_candref = 0;
   114     data->ime_candsel = 0;
   115     data->ime_candpgsize = 0;
   116     data->ime_candlistindexbase = 0;
   117     data->ime_candvertical = SDL_TRUE;
   118 
   119     data->ime_dirty = SDL_FALSE;
   120     SDL_memset(&data->ime_rect, 0, sizeof(data->ime_rect));
   121     SDL_memset(&data->ime_candlistrect, 0, sizeof(data->ime_candlistrect));
   122     data->ime_winwidth = 0;
   123     data->ime_winheight = 0;
   124 
   125     data->ime_hkl = 0;
   126     data->ime_himm32 = 0;
   127     data->GetReadingString = 0;
   128     data->ShowReadingWindow = 0;
   129     data->ImmLockIMC = 0;
   130     data->ImmUnlockIMC = 0;
   131     data->ImmLockIMCC = 0;
   132     data->ImmUnlockIMCC = 0;
   133     data->ime_uiless = SDL_FALSE;
   134     data->ime_threadmgrex = 0;
   135     data->ime_uielemsinkcookie = TF_INVALID_COOKIE;
   136     data->ime_alpnsinkcookie = TF_INVALID_COOKIE;
   137     data->ime_openmodesinkcookie = TF_INVALID_COOKIE;
   138     data->ime_convmodesinkcookie = TF_INVALID_COOKIE;
   139     data->ime_uielemsink = 0;
   140     data->ime_ippasink = 0;
   141 
   142     WIN_UpdateKeymap();
   143 
   144     SDL_SetScancodeName(SDL_SCANCODE_APPLICATION, "Menu");
   145     SDL_SetScancodeName(SDL_SCANCODE_LGUI, "Left Windows");
   146     SDL_SetScancodeName(SDL_SCANCODE_RGUI, "Right Windows");
   147 }
   148 
   149 void
   150 WIN_UpdateKeymap()
   151 {
   152     int i;
   153     SDL_Scancode scancode;
   154     SDL_Keycode keymap[SDL_NUM_SCANCODES];
   155 
   156     SDL_GetDefaultKeymap(keymap);
   157 
   158     for (i = 0; i < SDL_arraysize(windows_scancode_table); i++) {
   159 
   160         /* Make sure this scancode is a valid character scancode */
   161         scancode = windows_scancode_table[i];
   162         if (scancode == SDL_SCANCODE_UNKNOWN || keymap[scancode] >= 127) {
   163             continue;
   164         }
   165 
   166         /* Alphabetic keys are handled specially, since Windows remaps them */
   167         if (i >= 'A' && i <= 'Z') {
   168             BYTE vsc = alpha_scancodes[i - 'A'];
   169             keymap[scancode] = MapVirtualKey(vsc, MAPVK_VSC_TO_VK) + 0x20;
   170         } else {
   171             keymap[scancode] = (MapVirtualKey(i, MAPVK_VK_TO_CHAR) & 0x7FFF);
   172         }
   173     }
   174     SDL_SetKeymap(0, keymap, SDL_NUM_SCANCODES);
   175 }
   176 
   177 void
   178 WIN_QuitKeyboard(_THIS)
   179 {
   180 #ifndef SDL_DISABLE_WINDOWS_IME
   181     IME_Quit((SDL_VideoData *)_this->driverdata);
   182 #endif
   183 }
   184 
   185 void
   186 WIN_StartTextInput(_THIS)
   187 {
   188 #ifndef SDL_DISABLE_WINDOWS_IME
   189     SDL_Window *window = SDL_GetKeyboardFocus();
   190     if (window) {
   191         HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
   192         SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
   193         SDL_GetWindowSize(window, &videodata->ime_winwidth, &videodata->ime_winheight);
   194         IME_Init(videodata, hwnd);
   195         IME_Enable(videodata, hwnd);
   196     }
   197 #endif /* !SDL_DISABLE_WINDOWS_IME */
   198 }
   199 
   200 void
   201 WIN_StopTextInput(_THIS)
   202 {
   203 #ifndef SDL_DISABLE_WINDOWS_IME
   204     SDL_Window *window = SDL_GetKeyboardFocus();
   205     if (window) {
   206         HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;
   207         SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
   208         IME_Init(videodata, hwnd);
   209         IME_Disable(videodata, hwnd);
   210     }
   211 #endif /* !SDL_DISABLE_WINDOWS_IME */
   212 }
   213 
   214 void
   215 WIN_SetTextInputRect(_THIS, SDL_Rect *rect)
   216 {
   217     SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
   218     videodata->ime_rect = *rect;
   219 }
   220 
   221 #ifdef SDL_DISABLE_WINDOWS_IME
   222 
   223 
   224 SDL_bool
   225 IME_HandleMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM *lParam, SDL_VideoData *videodata)
   226 {
   227     return SDL_FALSE;
   228 }
   229 
   230 void IME_Present(SDL_VideoData *videodata)
   231 {
   232 }
   233 
   234 #else
   235 
   236 #ifdef __GNUC__
   237 #undef DEFINE_GUID
   238 #define DEFINE_GUID(n,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) static const GUID n = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}
   239 DEFINE_GUID(IID_ITfInputProcessorProfileActivationSink,        0x71C6E74E,0x0F28,0x11D8,0xA8,0x2A,0x00,0x06,0x5B,0x84,0x43,0x5C);
   240 DEFINE_GUID(IID_ITfUIElementSink,                              0xEA1EA136,0x19DF,0x11D7,0xA6,0xD2,0x00,0x06,0x5B,0x84,0x43,0x5C);
   241 DEFINE_GUID(GUID_TFCAT_TIP_KEYBOARD,                           0x34745C63,0xB2F0,0x4784,0x8B,0x67,0x5E,0x12,0xC8,0x70,0x1A,0x31);
   242 DEFINE_GUID(IID_ITfSource,                                     0x4EA48A35,0x60AE,0x446F,0x8F,0xD6,0xE6,0xA8,0xD8,0x24,0x59,0xF7);
   243 DEFINE_GUID(IID_ITfUIElementMgr,                               0xEA1EA135,0x19DF,0x11D7,0xA6,0xD2,0x00,0x06,0x5B,0x84,0x43,0x5C);
   244 DEFINE_GUID(IID_ITfCandidateListUIElement,                     0xEA1EA138,0x19DF,0x11D7,0xA6,0xD2,0x00,0x06,0x5B,0x84,0x43,0x5C);
   245 DEFINE_GUID(IID_ITfReadingInformationUIElement,                0xEA1EA139,0x19DF,0x11D7,0xA6,0xD2,0x00,0x06,0x5B,0x84,0x43,0x5C);
   246 DEFINE_GUID(IID_ITfThreadMgr,                                  0xAA80E801,0x2021,0x11D2,0x93,0xE0,0x00,0x60,0xB0,0x67,0xB8,0x6E);
   247 DEFINE_GUID(CLSID_TF_ThreadMgr,                                0x529A9E6B,0x6587,0x4F23,0xAB,0x9E,0x9C,0x7D,0x68,0x3E,0x3C,0x50);
   248 DEFINE_GUID(IID_ITfThreadMgrEx,                                0x3E90ADE3,0x7594,0x4CB0,0xBB,0x58,0x69,0x62,0x8F,0x5F,0x45,0x8C);
   249 #endif
   250 
   251 #define LANG_CHT MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL)
   252 #define LANG_CHS MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED)
   253 
   254 #define MAKEIMEVERSION(major,minor) ((DWORD) (((BYTE)(major) << 24) | ((BYTE)(minor) << 16) ))
   255 #define IMEID_VER(id) ((id) & 0xffff0000)
   256 #define IMEID_LANG(id) ((id) & 0x0000ffff)
   257 
   258 #define CHT_HKL_DAYI            ((HKL)0xE0060404)
   259 #define CHT_HKL_NEW_PHONETIC    ((HKL)0xE0080404)
   260 #define CHT_HKL_NEW_CHANG_JIE   ((HKL)0xE0090404)
   261 #define CHT_HKL_NEW_QUICK       ((HKL)0xE00A0404)
   262 #define CHT_HKL_HK_CANTONESE    ((HKL)0xE00B0404)
   263 #define CHT_IMEFILENAME1        "TINTLGNT.IME"
   264 #define CHT_IMEFILENAME2        "CINTLGNT.IME"
   265 #define CHT_IMEFILENAME3        "MSTCIPHA.IME"
   266 #define IMEID_CHT_VER42         (LANG_CHT | MAKEIMEVERSION(4, 2))
   267 #define IMEID_CHT_VER43         (LANG_CHT | MAKEIMEVERSION(4, 3))
   268 #define IMEID_CHT_VER44         (LANG_CHT | MAKEIMEVERSION(4, 4))
   269 #define IMEID_CHT_VER50         (LANG_CHT | MAKEIMEVERSION(5, 0))
   270 #define IMEID_CHT_VER51         (LANG_CHT | MAKEIMEVERSION(5, 1))
   271 #define IMEID_CHT_VER52         (LANG_CHT | MAKEIMEVERSION(5, 2))
   272 #define IMEID_CHT_VER60         (LANG_CHT | MAKEIMEVERSION(6, 0))
   273 #define IMEID_CHT_VER_VISTA     (LANG_CHT | MAKEIMEVERSION(7, 0))
   274 
   275 #define CHS_HKL                 ((HKL)0xE00E0804)
   276 #define CHS_IMEFILENAME1        "PINTLGNT.IME"
   277 #define CHS_IMEFILENAME2        "MSSCIPYA.IME"
   278 #define IMEID_CHS_VER41         (LANG_CHS | MAKEIMEVERSION(4, 1))
   279 #define IMEID_CHS_VER42         (LANG_CHS | MAKEIMEVERSION(4, 2))
   280 #define IMEID_CHS_VER53         (LANG_CHS | MAKEIMEVERSION(5, 3))
   281 
   282 #define LANG() LOWORD((videodata->ime_hkl))
   283 #define PRIMLANG() ((WORD)PRIMARYLANGID(LANG()))
   284 #define SUBLANG() SUBLANGID(LANG())
   285 
   286 static void IME_UpdateInputLocale(SDL_VideoData *videodata);
   287 static void IME_ClearComposition(SDL_VideoData *videodata);
   288 static void IME_SetWindow(SDL_VideoData* videodata, HWND hwnd);
   289 static void IME_SetupAPI(SDL_VideoData *videodata);
   290 static DWORD IME_GetId(SDL_VideoData *videodata, UINT uIndex);
   291 static void IME_SendEditingEvent(SDL_VideoData *videodata);
   292 static void IME_DestroyTextures(SDL_VideoData *videodata);
   293 
   294 #define SDL_IsEqualIID(riid1, riid2) SDL_IsEqualGUID(riid1, riid2)
   295 #define SDL_IsEqualGUID(rguid1, rguid2) (!SDL_memcmp(rguid1, rguid2, sizeof(GUID)))
   296 
   297 static SDL_bool UILess_SetupSinks(SDL_VideoData *videodata);
   298 static void UILess_ReleaseSinks(SDL_VideoData *videodata);
   299 static void UILess_EnableUIUpdates(SDL_VideoData *videodata);
   300 static void UILess_DisableUIUpdates(SDL_VideoData *videodata);
   301 
   302 static void
   303 IME_Init(SDL_VideoData *videodata, HWND hwnd)
   304 {
   305     if (videodata->ime_initialized)
   306         return;
   307 
   308     videodata->ime_hwnd_main = hwnd;
   309     if (SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED))) {
   310         videodata->ime_com_initialized = SDL_TRUE;
   311         CoCreateInstance(&CLSID_TF_ThreadMgr, NULL, CLSCTX_INPROC_SERVER, &IID_ITfThreadMgr, (LPVOID *)&videodata->ime_threadmgr);
   312     }
   313     videodata->ime_initialized = SDL_TRUE;
   314     videodata->ime_himm32 = SDL_LoadObject("imm32.dll");
   315     if (!videodata->ime_himm32) {
   316         videodata->ime_available = SDL_FALSE;
   317         return;
   318     }
   319     videodata->ImmLockIMC = (LPINPUTCONTEXT2 (WINAPI *)(HIMC))SDL_LoadFunction(videodata->ime_himm32, "ImmLockIMC");
   320     videodata->ImmUnlockIMC = (BOOL (WINAPI *)(HIMC))SDL_LoadFunction(videodata->ime_himm32, "ImmUnlockIMC");
   321     videodata->ImmLockIMCC = (LPVOID (WINAPI *)(HIMCC))SDL_LoadFunction(videodata->ime_himm32, "ImmLockIMCC");
   322     videodata->ImmUnlockIMCC = (BOOL (WINAPI *)(HIMCC))SDL_LoadFunction(videodata->ime_himm32, "ImmUnlockIMCC");
   323 
   324     IME_SetWindow(videodata, hwnd);
   325     videodata->ime_himc = ImmGetContext(hwnd);
   326     ImmReleaseContext(hwnd, videodata->ime_himc);
   327     if (!videodata->ime_himc) {
   328         videodata->ime_available = SDL_FALSE;
   329         IME_Disable(videodata, hwnd);
   330         return;
   331     }
   332     videodata->ime_available = SDL_TRUE;
   333     IME_UpdateInputLocale(videodata);
   334     IME_SetupAPI(videodata);
   335     videodata->ime_uiless = UILess_SetupSinks(videodata);
   336     IME_UpdateInputLocale(videodata);
   337     IME_Disable(videodata, hwnd);
   338 }
   339 
   340 static void
   341 IME_Enable(SDL_VideoData *videodata, HWND hwnd)
   342 {
   343     if (!videodata->ime_initialized || !videodata->ime_hwnd_current)
   344         return;
   345 
   346     if (!videodata->ime_available) {
   347         IME_Disable(videodata, hwnd);
   348         return;
   349     }
   350     if (videodata->ime_hwnd_current == videodata->ime_hwnd_main)
   351         ImmAssociateContext(videodata->ime_hwnd_current, videodata->ime_himc);
   352 
   353     videodata->ime_enabled = SDL_TRUE;
   354     IME_UpdateInputLocale(videodata);
   355     UILess_EnableUIUpdates(videodata);
   356 }
   357 
   358 static void
   359 IME_Disable(SDL_VideoData *videodata, HWND hwnd)
   360 {
   361     if (!videodata->ime_initialized || !videodata->ime_hwnd_current)
   362         return;
   363 
   364     IME_ClearComposition(videodata);
   365     if (videodata->ime_hwnd_current == videodata->ime_hwnd_main)
   366         ImmAssociateContext(videodata->ime_hwnd_current, (HIMC)0);
   367 
   368     videodata->ime_enabled = SDL_FALSE;
   369     UILess_DisableUIUpdates(videodata);
   370 }
   371 
   372 static void
   373 IME_Quit(SDL_VideoData *videodata)
   374 {
   375     if (!videodata->ime_initialized)
   376         return;
   377 
   378     UILess_ReleaseSinks(videodata);
   379     if (videodata->ime_hwnd_main)
   380         ImmAssociateContext(videodata->ime_hwnd_main, videodata->ime_himc);
   381 
   382     videodata->ime_hwnd_main = 0;
   383     videodata->ime_himc = 0;
   384     if (videodata->ime_himm32) {
   385         SDL_UnloadObject(videodata->ime_himm32);
   386         videodata->ime_himm32 = 0;
   387     }
   388     if (videodata->ime_threadmgr) {
   389         videodata->ime_threadmgr->lpVtbl->Release(videodata->ime_threadmgr);
   390         videodata->ime_threadmgr = 0;
   391     }
   392     if (videodata->ime_com_initialized) {
   393         CoUninitialize();
   394         videodata->ime_com_initialized = SDL_FALSE;
   395     }
   396     IME_DestroyTextures(videodata);
   397     videodata->ime_initialized = SDL_FALSE;
   398 }
   399 
   400 static void
   401 IME_GetReadingString(SDL_VideoData *videodata, HWND hwnd)
   402 {
   403     DWORD id = 0;
   404     HIMC himc = 0;
   405     WCHAR buffer[16];
   406     WCHAR *s = buffer;
   407     DWORD len = 0;
   408     INT err = 0;
   409     BOOL vertical = FALSE;
   410     UINT maxuilen = 0;
   411     static OSVERSIONINFOA osversion = {0};
   412     if (videodata->ime_uiless)
   413         return;
   414 
   415     videodata->ime_readingstring[0] = 0;
   416     if (!osversion.dwOSVersionInfoSize) {
   417         osversion.dwOSVersionInfoSize = sizeof(osversion);
   418         GetVersionExA(&osversion);
   419     }
   420     id = IME_GetId(videodata, 0);
   421     if (!id)
   422         return;
   423 
   424     himc = ImmGetContext(hwnd);
   425     if (!himc)
   426         return;
   427 
   428     if (videodata->GetReadingString) {
   429         len = videodata->GetReadingString(himc, 0, 0, &err, &vertical, &maxuilen);
   430         if (len) {
   431             if (len > SDL_arraysize(buffer))
   432                 len = SDL_arraysize(buffer);
   433 
   434             len = videodata->GetReadingString(himc, len, s, &err, &vertical, &maxuilen);
   435         }
   436         SDL_wcslcpy(videodata->ime_readingstring, s, len);
   437     }
   438     else {
   439         LPINPUTCONTEXT2 lpimc = videodata->ImmLockIMC(himc);
   440         LPBYTE p = 0;
   441         s = 0;
   442         switch (id)
   443         {
   444         case IMEID_CHT_VER42:
   445         case IMEID_CHT_VER43:
   446         case IMEID_CHT_VER44:
   447             p = *(LPBYTE *)((LPBYTE)videodata->ImmLockIMCC(lpimc->hPrivate) + 24);
   448             if (!p)
   449                 break;
   450 
   451             len = *(DWORD *)(p + 7*4 + 32*4);
   452             s = (WCHAR *)(p + 56);
   453             break;
   454         case IMEID_CHT_VER51:
   455         case IMEID_CHT_VER52:
   456         case IMEID_CHS_VER53:
   457             p = *(LPBYTE *)((LPBYTE)videodata->ImmLockIMCC(lpimc->hPrivate) + 4);
   458             if (!p)
   459                 break;
   460 
   461             p = *(LPBYTE *)((LPBYTE)p + 1*4 + 5*4);
   462             if (!p)
   463                 break;
   464 
   465             len = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16*2);
   466             s = (WCHAR *)(p + 1*4 + (16*2+2*4) + 5*4);
   467             break;
   468         case IMEID_CHS_VER41:
   469             {
   470                 int offset = (IME_GetId(videodata, 1) >= 0x00000002) ? 8 : 7;
   471                 p = *(LPBYTE *)((LPBYTE)videodata->ImmLockIMCC(lpimc->hPrivate) + offset * 4);
   472                 if (!p)
   473                     break;
   474 
   475                 len = *(DWORD *)(p + 7*4 + 16*2*4);
   476                 s = (WCHAR *)(p + 6*4 + 16*2*1);
   477             }
   478             break;
   479         case IMEID_CHS_VER42:
   480             if (osversion.dwPlatformId != VER_PLATFORM_WIN32_NT)
   481                 break;
   482 
   483             p = *(LPBYTE *)((LPBYTE)videodata->ImmLockIMCC(lpimc->hPrivate) + 1*4 + 1*4 + 6*4);
   484             if (!p)
   485                 break;
   486 
   487             len = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16*2);
   488             s = (WCHAR *)(p + 1*4 + (16*2+2*4) + 5*4);
   489             break;
   490         }
   491         if (s)
   492             SDL_wcslcpy(videodata->ime_readingstring, s, len + 1);
   493 
   494         videodata->ImmUnlockIMCC(lpimc->hPrivate);
   495         videodata->ImmUnlockIMC(himc);
   496     }
   497     ImmReleaseContext(hwnd, himc);
   498     IME_SendEditingEvent(videodata);
   499 }
   500 
   501 static void
   502 IME_InputLangChanged(SDL_VideoData *videodata)
   503 {
   504     UINT lang = PRIMLANG();
   505     IME_UpdateInputLocale(videodata);
   506     if (!videodata->ime_uiless)
   507         videodata->ime_candlistindexbase = (videodata->ime_hkl == CHT_HKL_DAYI) ? 0 : 1;
   508 
   509     IME_SetupAPI(videodata);
   510     if (lang != PRIMLANG()) {
   511         IME_ClearComposition(videodata);
   512     }
   513 }
   514 
   515 static DWORD
   516 IME_GetId(SDL_VideoData *videodata, UINT uIndex)
   517 {
   518     static HKL hklprev = 0;
   519     static DWORD dwRet[2] = {0};
   520     DWORD dwVerSize = 0;
   521     DWORD dwVerHandle = 0;
   522     LPVOID lpVerBuffer = 0;
   523     LPVOID lpVerData = 0;
   524     UINT cbVerData = 0;
   525     char szTemp[256];
   526     HKL hkl = 0;
   527     DWORD dwLang = 0;
   528     if (uIndex >= sizeof(dwRet) / sizeof(dwRet[0]))
   529         return 0;
   530 
   531     hkl = videodata->ime_hkl;
   532     if (hklprev == hkl)
   533         return dwRet[uIndex];
   534 
   535     hklprev = hkl;
   536     dwLang = ((DWORD_PTR)hkl & 0xffff);
   537     if (videodata->ime_uiless && LANG() == LANG_CHT) {
   538         dwRet[0] = IMEID_CHT_VER_VISTA;
   539         dwRet[1] = 0;
   540         return dwRet[0];
   541     }
   542     if (hkl != CHT_HKL_NEW_PHONETIC
   543         && hkl != CHT_HKL_NEW_CHANG_JIE
   544         && hkl != CHT_HKL_NEW_QUICK
   545         && hkl != CHT_HKL_HK_CANTONESE
   546         && hkl != CHS_HKL) {
   547         dwRet[0] = dwRet[1] = 0;
   548         return dwRet[uIndex];
   549     }
   550     if (ImmGetIMEFileNameA(hkl, szTemp, sizeof(szTemp) - 1) <= 0) {
   551         dwRet[0] = dwRet[1] = 0;
   552         return dwRet[uIndex];
   553     }
   554     if (!videodata->GetReadingString) {
   555         #define LCID_INVARIANT MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT)
   556         if (CompareStringA(LCID_INVARIANT, NORM_IGNORECASE, szTemp, -1, CHT_IMEFILENAME1, -1) != 2
   557             && CompareStringA(LCID_INVARIANT, NORM_IGNORECASE, szTemp, -1, CHT_IMEFILENAME2, -1) != 2
   558             && CompareStringA(LCID_INVARIANT, NORM_IGNORECASE, szTemp, -1, CHT_IMEFILENAME3, -1) != 2
   559             && CompareStringA(LCID_INVARIANT, NORM_IGNORECASE, szTemp, -1, CHS_IMEFILENAME1, -1) != 2
   560             && CompareStringA(LCID_INVARIANT, NORM_IGNORECASE, szTemp, -1, CHS_IMEFILENAME2, -1) != 2) {
   561             dwRet[0] = dwRet[1] = 0;
   562             return dwRet[uIndex];
   563         }
   564         #undef LCID_INVARIANT
   565         dwVerSize = GetFileVersionInfoSizeA(szTemp, &dwVerHandle);
   566         if (dwVerSize) {
   567             lpVerBuffer = SDL_malloc(dwVerSize);
   568             if (lpVerBuffer) {
   569                 if (GetFileVersionInfoA(szTemp, dwVerHandle, dwVerSize, lpVerBuffer)) {
   570                     if (VerQueryValueA(lpVerBuffer, "\\", &lpVerData, &cbVerData)) {
   571                         #define pVerFixedInfo   ((VS_FIXEDFILEINFO FAR*)lpVerData)
   572                         DWORD dwVer = pVerFixedInfo->dwFileVersionMS;
   573                         dwVer = (dwVer & 0x00ff0000) << 8 | (dwVer & 0x000000ff) << 16;
   574                         if (videodata->GetReadingString ||
   575                             dwLang == LANG_CHT && (
   576                             dwVer == MAKEIMEVERSION(4, 2) ||
   577                             dwVer == MAKEIMEVERSION(4, 3) ||
   578                             dwVer == MAKEIMEVERSION(4, 4) ||
   579                             dwVer == MAKEIMEVERSION(5, 0) ||
   580                             dwVer == MAKEIMEVERSION(5, 1) ||
   581                             dwVer == MAKEIMEVERSION(5, 2) ||
   582                             dwVer == MAKEIMEVERSION(6, 0))
   583                             ||
   584                             dwLang == LANG_CHS && (
   585                             dwVer == MAKEIMEVERSION(4, 1) ||
   586                             dwVer == MAKEIMEVERSION(4, 2) ||
   587                             dwVer == MAKEIMEVERSION(5, 3))) {
   588                             dwRet[0] = dwVer | dwLang;
   589                             dwRet[1] = pVerFixedInfo->dwFileVersionLS;
   590                             SDL_free(lpVerBuffer);
   591                             return dwRet[0];
   592                         }
   593                         #undef pVerFixedInfo
   594                     }
   595                 }
   596             }
   597             SDL_free(lpVerBuffer);
   598         }
   599     }
   600     dwRet[0] = dwRet[1] = 0;
   601     return dwRet[uIndex];
   602 }
   603 
   604 static void
   605 IME_SetupAPI(SDL_VideoData *videodata)
   606 {
   607     char ime_file[MAX_PATH + 1];
   608     void* hime = 0;
   609     HKL hkl = 0;
   610     videodata->GetReadingString = 0;
   611     videodata->ShowReadingWindow = 0;
   612     if (videodata->ime_uiless)
   613         return;
   614 
   615     hkl = videodata->ime_hkl;
   616     if (ImmGetIMEFileNameA(hkl, ime_file, sizeof(ime_file) - 1) <= 0)
   617         return;
   618 
   619     hime = SDL_LoadObject(ime_file);
   620     if (!hime)
   621         return;
   622 
   623     videodata->GetReadingString = (UINT (WINAPI *)(HIMC, UINT, LPWSTR, PINT, BOOL*, PUINT))
   624         SDL_LoadFunction(hime, "GetReadingString");
   625     videodata->ShowReadingWindow = (BOOL (WINAPI *)(HIMC, BOOL))
   626         SDL_LoadFunction(hime, "ShowReadingWindow");
   627 
   628     if (videodata->ShowReadingWindow) {
   629         HIMC himc = ImmGetContext(videodata->ime_hwnd_current);
   630         if (himc) {
   631             videodata->ShowReadingWindow(himc, FALSE);
   632             ImmReleaseContext(videodata->ime_hwnd_current, himc);
   633         }
   634     }
   635 }
   636 
   637 static void
   638 IME_SetWindow(SDL_VideoData* videodata, HWND hwnd)
   639 {
   640     videodata->ime_hwnd_current = hwnd;
   641     if (videodata->ime_threadmgr) {
   642         struct ITfDocumentMgr *document_mgr = 0;
   643         if (SUCCEEDED(videodata->ime_threadmgr->lpVtbl->AssociateFocus(videodata->ime_threadmgr, hwnd, NULL, &document_mgr))) {
   644             if (document_mgr)
   645                 document_mgr->lpVtbl->Release(document_mgr);
   646         }
   647     }
   648 }
   649 
   650 static void
   651 IME_UpdateInputLocale(SDL_VideoData *videodata)
   652 {
   653     static HKL hklprev = 0;
   654     videodata->ime_hkl = GetKeyboardLayout(0);
   655     if (hklprev == videodata->ime_hkl)
   656         return;
   657 
   658     hklprev = videodata->ime_hkl;
   659     switch (PRIMLANG()) {
   660     case LANG_CHINESE:
   661         videodata->ime_candvertical = SDL_TRUE;
   662         if (SUBLANG() == SUBLANG_CHINESE_SIMPLIFIED)
   663             videodata->ime_candvertical = SDL_FALSE;
   664 
   665         break;
   666     case LANG_JAPANESE:
   667         videodata->ime_candvertical = SDL_TRUE;
   668         break;
   669     case LANG_KOREAN:
   670         videodata->ime_candvertical = SDL_FALSE;
   671         break;
   672     }
   673 }
   674 
   675 static void
   676 IME_ClearComposition(SDL_VideoData *videodata)
   677 {
   678     HIMC himc = 0;
   679     if (!videodata->ime_initialized)
   680         return;
   681 
   682     himc = ImmGetContext(videodata->ime_hwnd_current);
   683     if (!himc)
   684         return;
   685 
   686     ImmNotifyIME(himc, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
   687     if (videodata->ime_uiless)
   688         ImmSetCompositionString(himc, SCS_SETSTR, TEXT(""), sizeof(TCHAR), TEXT(""), sizeof(TCHAR));
   689 
   690     ImmNotifyIME(himc, NI_CLOSECANDIDATE, 0, 0);
   691     ImmReleaseContext(videodata->ime_hwnd_current, himc);
   692     SDL_SendEditingText("", 0, 0);
   693 }
   694 
   695 static void
   696 IME_GetCompositionString(SDL_VideoData *videodata, HIMC himc, DWORD string)
   697 {
   698     LONG length = ImmGetCompositionStringW(himc, string, videodata->ime_composition, sizeof(videodata->ime_composition));
   699     if (length < 0)
   700         length = 0;
   701 
   702     length /= sizeof(videodata->ime_composition[0]);
   703     videodata->ime_cursor = LOWORD(ImmGetCompositionStringW(himc, GCS_CURSORPOS, 0, 0));
   704     if (videodata->ime_composition[videodata->ime_cursor] == 0x3000) {
   705         int i;
   706         for (i = videodata->ime_cursor + 1; i < length; ++i)
   707             videodata->ime_composition[i - 1] = videodata->ime_composition[i];
   708 
   709         --length;
   710     }
   711     videodata->ime_composition[length] = 0;
   712 }
   713 
   714 static void
   715 IME_SendInputEvent(SDL_VideoData *videodata)
   716 {
   717     char *s = 0;
   718     s = WIN_StringToUTF8(videodata->ime_composition);
   719     SDL_SendKeyboardText(s);
   720     SDL_free(s);
   721 
   722     videodata->ime_composition[0] = 0;
   723     videodata->ime_readingstring[0] = 0;
   724     videodata->ime_cursor = 0;
   725 }
   726 
   727 static void
   728 IME_SendEditingEvent(SDL_VideoData *videodata)
   729 {
   730     char *s = 0;
   731     WCHAR buffer[SDL_TEXTEDITINGEVENT_TEXT_SIZE];
   732     buffer[0] = 0;
   733     if (videodata->ime_readingstring[0]) {
   734         size_t len = SDL_min(SDL_wcslen(videodata->ime_composition), (size_t)videodata->ime_cursor);
   735         SDL_wcslcpy(buffer, videodata->ime_composition, len + 1);
   736         SDL_wcslcat(buffer, videodata->ime_readingstring, sizeof(buffer));
   737         SDL_wcslcat(buffer, &videodata->ime_composition[len], sizeof(buffer) - len);
   738     }
   739     else {
   740         SDL_wcslcpy(buffer, videodata->ime_composition, sizeof(videodata->ime_composition));
   741     }
   742     s = WIN_StringToUTF8(buffer);
   743     SDL_SendEditingText(s, videodata->ime_cursor + SDL_wcslen(videodata->ime_readingstring), 0);
   744     SDL_free(s);
   745 }
   746 
   747 static void
   748 IME_AddCandidate(SDL_VideoData *videodata, UINT i, LPCWSTR candidate)
   749 {
   750     LPWSTR dst = videodata->ime_candidates[i];
   751     *dst++ = (WCHAR)(TEXT('0') + ((i + videodata->ime_candlistindexbase) % 10));
   752     if (videodata->ime_candvertical)
   753         *dst++ = TEXT(' ');
   754 
   755     while (*candidate && (SDL_arraysize(videodata->ime_candidates[i]) > (dst - videodata->ime_candidates[i])))
   756         *dst++ = *candidate++;
   757 
   758     *dst = (WCHAR)'\0';
   759 }
   760 
   761 static void
   762 IME_GetCandidateList(HIMC himc, SDL_VideoData *videodata)
   763 {
   764     LPCANDIDATELIST cand_list = 0;
   765     DWORD size = ImmGetCandidateListW(himc, 0, 0, 0);
   766     if (size) {
   767         cand_list = (LPCANDIDATELIST)SDL_malloc(size);
   768         if (cand_list) {
   769             size = ImmGetCandidateListW(himc, 0, cand_list, size);
   770             if (size) {
   771                 int i = 0;
   772                 int j = 0;
   773                 int page_start = 0;
   774                 videodata->ime_candsel = cand_list->dwSelection;
   775                 videodata->ime_candcount = cand_list->dwCount;
   776 
   777                 if (LANG() == LANG_CHS && IME_GetId(videodata, 0)) {
   778                     const UINT maxcandchar = 18;
   779                     UINT i = 0;
   780                     UINT cchars = 0;
   781 
   782                     for (; i < videodata->ime_candcount; ++i) {
   783                         UINT len = SDL_wcslen((LPWSTR)((DWORD_PTR)cand_list + cand_list->dwOffset[i])) + 1;
   784                         if (len + cchars > maxcandchar) {
   785                             if (i > cand_list->dwSelection)
   786                                 break;
   787 
   788                             page_start = i;
   789                             cchars = len;
   790                         }
   791                         else {
   792                             cchars += len;
   793                         }
   794                     }
   795                     videodata->ime_candpgsize = i - page_start;
   796                 }
   797                 else {
   798                     videodata->ime_candpgsize = SDL_min(cand_list->dwPageSize, MAX_CANDLIST);
   799                     page_start = (cand_list->dwSelection / videodata->ime_candpgsize) * videodata->ime_candpgsize;
   800                 }
   801                 SDL_memset(&videodata->ime_candidates, 0, sizeof(videodata->ime_candidates));
   802                 for (i = page_start, j = 0; (DWORD)i < cand_list->dwCount && j < (int)videodata->ime_candpgsize; i++, j++) {
   803                     LPCWSTR candidate = (LPCWSTR)((DWORD_PTR)cand_list + cand_list->dwOffset[i]);
   804                     IME_AddCandidate(videodata, j, candidate);
   805                 }
   806                 if (PRIMLANG() == LANG_KOREAN || (PRIMLANG() == LANG_CHT && !IME_GetId(videodata, 0)))
   807                     videodata->ime_candsel = -1;
   808 
   809             }
   810             SDL_free(cand_list);
   811         }
   812     }
   813 }
   814 
   815 static void
   816 IME_ShowCandidateList(SDL_VideoData *videodata)
   817 {
   818     videodata->ime_dirty = SDL_TRUE;
   819     videodata->ime_candlist = SDL_TRUE;
   820     IME_DestroyTextures(videodata);
   821     IME_SendEditingEvent(videodata);
   822 }
   823 
   824 static void
   825 IME_HideCandidateList(SDL_VideoData *videodata)
   826 {
   827     videodata->ime_dirty = SDL_FALSE;
   828     videodata->ime_candlist = SDL_FALSE;
   829     IME_DestroyTextures(videodata);
   830     IME_SendEditingEvent(videodata);
   831 }
   832 
   833 SDL_bool
   834 IME_HandleMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM *lParam, SDL_VideoData *videodata)
   835 {
   836     SDL_bool trap = SDL_FALSE;
   837     HIMC himc = 0;
   838     if (!videodata->ime_initialized || !videodata->ime_available || !videodata->ime_enabled)
   839         return SDL_FALSE;
   840 
   841     switch (msg) {
   842     case WM_INPUTLANGCHANGE:
   843         IME_InputLangChanged(videodata);
   844         break;
   845     case WM_IME_SETCONTEXT:
   846         *lParam = 0;
   847         break;
   848     case WM_IME_STARTCOMPOSITION:
   849         trap = SDL_TRUE;
   850         break;
   851     case WM_IME_COMPOSITION:
   852         trap = SDL_TRUE;
   853         himc = ImmGetContext(hwnd);
   854         if (*lParam & GCS_RESULTSTR) {
   855             IME_GetCompositionString(videodata, himc, GCS_RESULTSTR);
   856             IME_SendInputEvent(videodata);
   857         }
   858         if (*lParam & GCS_COMPSTR) {
   859             if (!videodata->ime_uiless)
   860                 videodata->ime_readingstring[0] = 0;
   861 
   862             IME_GetCompositionString(videodata, himc, GCS_COMPSTR);
   863             IME_SendEditingEvent(videodata);
   864         }
   865         ImmReleaseContext(hwnd, himc);
   866         break;
   867     case WM_IME_ENDCOMPOSITION:
   868         videodata->ime_composition[0] = 0;
   869         videodata->ime_readingstring[0] = 0;
   870         videodata->ime_cursor = 0;
   871         SDL_SendEditingText("", 0, 0);
   872         break;
   873     case WM_IME_NOTIFY:
   874         switch (wParam) {
   875         case IMN_SETCONVERSIONMODE:
   876         case IMN_SETOPENSTATUS:
   877             IME_UpdateInputLocale(videodata);
   878             break;
   879         case IMN_OPENCANDIDATE:
   880         case IMN_CHANGECANDIDATE:
   881             if (videodata->ime_uiless)
   882                 break;
   883 
   884             trap = SDL_TRUE;
   885             IME_ShowCandidateList(videodata);
   886             himc = ImmGetContext(hwnd);
   887             if (!himc)
   888                 break;
   889 
   890             IME_GetCandidateList(himc, videodata);
   891             ImmReleaseContext(hwnd, himc);
   892             break;
   893         case IMN_CLOSECANDIDATE:
   894             trap = SDL_TRUE;
   895             IME_HideCandidateList(videodata);
   896             break;
   897         case IMN_PRIVATE:
   898             {
   899                 DWORD dwId = IME_GetId(videodata, 0);
   900                 IME_GetReadingString(videodata, hwnd);
   901                 switch (dwId)
   902                 {
   903                 case IMEID_CHT_VER42:
   904                 case IMEID_CHT_VER43:
   905                 case IMEID_CHT_VER44:
   906                 case IMEID_CHS_VER41:
   907                 case IMEID_CHS_VER42:
   908                     if (*lParam == 1 || *lParam == 2)
   909                         trap = SDL_TRUE;
   910 
   911                     break;
   912                 case IMEID_CHT_VER50:
   913                 case IMEID_CHT_VER51:
   914                 case IMEID_CHT_VER52:
   915                 case IMEID_CHT_VER60:
   916                 case IMEID_CHS_VER53:
   917                     if (*lParam == 16
   918                         || *lParam == 17
   919                         || *lParam == 26
   920                         || *lParam == 27
   921                         || *lParam == 28)
   922                         trap = SDL_TRUE;
   923                     break;
   924                 }
   925             }
   926             break;
   927         default:
   928             trap = SDL_TRUE;
   929             break;
   930         }
   931         break;
   932     }
   933     return trap;
   934 }
   935 
   936 static void
   937 IME_CloseCandidateList(SDL_VideoData *videodata)
   938 {
   939     IME_HideCandidateList(videodata);
   940     videodata->ime_candcount = 0;
   941     SDL_memset(videodata->ime_candidates, 0, sizeof(videodata->ime_candidates));
   942 }
   943 
   944 static void
   945 UILess_GetCandidateList(SDL_VideoData *videodata, ITfCandidateListUIElement *pcandlist)
   946 {
   947     UINT selection = 0;
   948     UINT count = 0;
   949     UINT page = 0;
   950     UINT pgcount = 0;
   951     DWORD pgstart = 0;
   952     DWORD pgsize = 0;
   953     UINT i, j;
   954     pcandlist->lpVtbl->GetSelection(pcandlist, &selection);
   955     pcandlist->lpVtbl->GetCount(pcandlist, &count);
   956     pcandlist->lpVtbl->GetCurrentPage(pcandlist, &page);
   957 
   958     videodata->ime_candsel = selection;
   959     videodata->ime_candcount = count;
   960     IME_ShowCandidateList(videodata);
   961 
   962     pcandlist->lpVtbl->GetPageIndex(pcandlist, 0, 0, &pgcount);
   963     if (pgcount > 0) {
   964         UINT *idxlist = SDL_malloc(sizeof(UINT) * pgcount);
   965         if (idxlist) {
   966             pcandlist->lpVtbl->GetPageIndex(pcandlist, idxlist, pgcount, &pgcount);
   967             pgstart = idxlist[page];
   968             if (page < pgcount - 1)
   969                 pgsize = SDL_min(count, idxlist[page + 1]) - pgstart;
   970             else
   971                 pgsize = count - pgstart;
   972 
   973             SDL_free(idxlist);
   974         }
   975     }
   976     videodata->ime_candpgsize = SDL_min(pgsize, MAX_CANDLIST);
   977     videodata->ime_candsel = videodata->ime_candsel - pgstart;
   978 
   979     SDL_memset(videodata->ime_candidates, 0, sizeof(videodata->ime_candidates));
   980     for (i = pgstart, j = 0; (DWORD)i < count && j < videodata->ime_candpgsize; i++, j++) {
   981         BSTR bstr;
   982         if (SUCCEEDED(pcandlist->lpVtbl->GetString(pcandlist, i, &bstr))) {
   983             if (bstr) {
   984                 IME_AddCandidate(videodata, j, bstr);
   985                 SysFreeString(bstr);
   986             }
   987         }
   988     }
   989     if (PRIMLANG() == LANG_KOREAN)
   990         videodata->ime_candsel = -1;
   991 }
   992 
   993 STDMETHODIMP_(ULONG) TSFSink_AddRef(TSFSink *sink)
   994 {
   995     return ++sink->refcount;
   996 }
   997 
   998 STDMETHODIMP_(ULONG)TSFSink_Release(TSFSink *sink)
   999 {
  1000     --sink->refcount;
  1001     if (sink->refcount == 0) {
  1002         SDL_free(sink);
  1003         return 0;
  1004     }
  1005     return sink->refcount;
  1006 }
  1007 
  1008 STDMETHODIMP UIElementSink_QueryInterface(TSFSink *sink, REFIID riid, PVOID *ppv)
  1009 {
  1010     if (!ppv)
  1011         return E_INVALIDARG;
  1012 
  1013     *ppv = 0;
  1014     if (SDL_IsEqualIID(riid, &IID_IUnknown))
  1015         *ppv = (IUnknown *)sink;
  1016     else if (SDL_IsEqualIID(riid, &IID_ITfUIElementSink))
  1017         *ppv = (ITfUIElementSink *)sink;
  1018 
  1019     if (*ppv) {
  1020         TSFSink_AddRef(sink);
  1021         return S_OK;
  1022     }
  1023     return E_NOINTERFACE;
  1024 }
  1025 
  1026 ITfUIElement *UILess_GetUIElement(SDL_VideoData *videodata, DWORD dwUIElementId)
  1027 {
  1028     ITfUIElementMgr *puiem = 0;
  1029     ITfUIElement *pelem = 0;
  1030     ITfThreadMgrEx *threadmgrex = videodata->ime_threadmgrex;
  1031 
  1032     if (SUCCEEDED(threadmgrex->lpVtbl->QueryInterface(threadmgrex, &IID_ITfUIElementMgr, (LPVOID *)&puiem))) {
  1033         puiem->lpVtbl->GetUIElement(puiem, dwUIElementId, &pelem);
  1034         puiem->lpVtbl->Release(puiem);
  1035     }
  1036     return pelem;
  1037 }
  1038 
  1039 STDMETHODIMP UIElementSink_BeginUIElement(TSFSink *sink, DWORD dwUIElementId, BOOL *pbShow)
  1040 {
  1041     ITfUIElement *element = UILess_GetUIElement((SDL_VideoData *)sink->data, dwUIElementId);
  1042     ITfReadingInformationUIElement *preading = 0;
  1043     ITfCandidateListUIElement *pcandlist = 0;
  1044     SDL_VideoData *videodata = (SDL_VideoData *)sink->data;
  1045     if (!element)
  1046         return E_INVALIDARG;
  1047 
  1048     *pbShow = FALSE;
  1049     if (SUCCEEDED(element->lpVtbl->QueryInterface(element, &IID_ITfReadingInformationUIElement, (LPVOID *)&preading))) {
  1050         BSTR bstr;
  1051         if (SUCCEEDED(preading->lpVtbl->GetString(preading, &bstr)) && bstr) {
  1052             WCHAR *s = (WCHAR *)bstr;
  1053             SysFreeString(bstr);
  1054         }
  1055         preading->lpVtbl->Release(preading);
  1056     }
  1057     else if (SUCCEEDED(element->lpVtbl->QueryInterface(element, &IID_ITfCandidateListUIElement, (LPVOID *)&pcandlist)))	{
  1058         videodata->ime_candref++;
  1059         UILess_GetCandidateList(videodata, pcandlist);
  1060         pcandlist->lpVtbl->Release(pcandlist);
  1061     }
  1062     return S_OK;
  1063 }
  1064 
  1065 STDMETHODIMP UIElementSink_UpdateUIElement(TSFSink *sink, DWORD dwUIElementId)
  1066 {
  1067     ITfUIElement *element = UILess_GetUIElement((SDL_VideoData *)sink->data, dwUIElementId);
  1068     ITfReadingInformationUIElement *preading = 0;
  1069     ITfCandidateListUIElement *pcandlist = 0;
  1070     SDL_VideoData *videodata = (SDL_VideoData *)sink->data;
  1071     if (!element)
  1072         return E_INVALIDARG;
  1073 
  1074     if (SUCCEEDED(element->lpVtbl->QueryInterface(element, &IID_ITfReadingInformationUIElement, (LPVOID *)&preading))) {
  1075         BSTR bstr;
  1076         if (SUCCEEDED(preading->lpVtbl->GetString(preading, &bstr)) && bstr) {
  1077             WCHAR *s = (WCHAR *)bstr;
  1078             SDL_wcslcpy(videodata->ime_readingstring, s, sizeof(videodata->ime_readingstring));
  1079             IME_SendEditingEvent(videodata);
  1080             SysFreeString(bstr);
  1081         }
  1082         preading->lpVtbl->Release(preading);
  1083     }
  1084     else if (SUCCEEDED(element->lpVtbl->QueryInterface(element, &IID_ITfCandidateListUIElement, (LPVOID *)&pcandlist)))	{
  1085         UILess_GetCandidateList(videodata, pcandlist);
  1086         pcandlist->lpVtbl->Release(pcandlist);
  1087     }
  1088     return S_OK;
  1089 }
  1090 
  1091 STDMETHODIMP UIElementSink_EndUIElement(TSFSink *sink, DWORD dwUIElementId)
  1092 {
  1093     ITfUIElement *element = UILess_GetUIElement((SDL_VideoData *)sink->data, dwUIElementId);
  1094     ITfReadingInformationUIElement *preading = 0;
  1095     ITfCandidateListUIElement *pcandlist = 0;
  1096     SDL_VideoData *videodata = (SDL_VideoData *)sink->data;
  1097     if (!element)
  1098         return E_INVALIDARG;
  1099 
  1100     if (SUCCEEDED(element->lpVtbl->QueryInterface(element, &IID_ITfReadingInformationUIElement, (LPVOID *)&preading))) {
  1101         videodata->ime_readingstring[0] = 0;
  1102         IME_SendEditingEvent(videodata);
  1103         preading->lpVtbl->Release(preading);
  1104     }
  1105     if (SUCCEEDED(element->lpVtbl->QueryInterface(element, &IID_ITfCandidateListUIElement, (LPVOID *)&pcandlist))) {
  1106         videodata->ime_candref--;
  1107         if (videodata->ime_candref == 0)
  1108             IME_CloseCandidateList(videodata);
  1109 
  1110         pcandlist->lpVtbl->Release(pcandlist);
  1111     }
  1112     return S_OK;
  1113 }
  1114 
  1115 STDMETHODIMP IPPASink_QueryInterface(TSFSink *sink, REFIID riid, PVOID *ppv)
  1116 {
  1117     if (!ppv)
  1118         return E_INVALIDARG;
  1119 
  1120     *ppv = 0;
  1121     if (SDL_IsEqualIID(riid, &IID_IUnknown))
  1122         *ppv = (IUnknown *)sink;
  1123     else if (SDL_IsEqualIID(riid, &IID_ITfInputProcessorProfileActivationSink))
  1124         *ppv = (ITfInputProcessorProfileActivationSink *)sink;
  1125 
  1126     if (*ppv) {
  1127         TSFSink_AddRef(sink);
  1128         return S_OK;
  1129     }
  1130     return E_NOINTERFACE;
  1131 }
  1132 
  1133 STDMETHODIMP IPPASink_OnActivated(TSFSink *sink, DWORD dwProfileType, LANGID langid, REFCLSID clsid, REFGUID catid, REFGUID guidProfile, HKL hkl, DWORD dwFlags)
  1134 {
  1135     static GUID TF_PROFILE_DAYI = {0x037B2C25, 0x480C, 0x4D7F, 0xB0, 0x27, 0xD6, 0xCA, 0x6B, 0x69, 0x78, 0x8A};
  1136     SDL_VideoData *videodata = (SDL_VideoData *)sink->data;
  1137     videodata->ime_candlistindexbase = SDL_IsEqualGUID(&TF_PROFILE_DAYI, guidProfile) ? 0 : 1;
  1138     if (SDL_IsEqualIID(catid, &GUID_TFCAT_TIP_KEYBOARD) && (dwFlags & TF_IPSINK_FLAG_ACTIVE))
  1139         IME_InputLangChanged((SDL_VideoData *)sink->data);
  1140 
  1141     IME_HideCandidateList(videodata);
  1142     return S_OK;
  1143 }
  1144 
  1145 static void *vtUIElementSink[] = {
  1146     (void *)(UIElementSink_QueryInterface),
  1147     (void *)(TSFSink_AddRef),
  1148     (void *)(TSFSink_Release),
  1149     (void *)(UIElementSink_BeginUIElement),
  1150     (void *)(UIElementSink_UpdateUIElement),
  1151     (void *)(UIElementSink_EndUIElement)
  1152 };
  1153 
  1154 static void *vtIPPASink[] = {
  1155     (void *)(IPPASink_QueryInterface),
  1156     (void *)(TSFSink_AddRef),
  1157     (void *)(TSFSink_Release),
  1158     (void *)(IPPASink_OnActivated)
  1159 };
  1160 
  1161 static void
  1162 UILess_EnableUIUpdates(SDL_VideoData *videodata)
  1163 {
  1164     ITfSource *source = 0;
  1165     if (!videodata->ime_threadmgrex || videodata->ime_uielemsinkcookie != TF_INVALID_COOKIE)
  1166         return;
  1167 
  1168     if (SUCCEEDED(videodata->ime_threadmgrex->lpVtbl->QueryInterface(videodata->ime_threadmgrex, &IID_ITfSource, (LPVOID *)&source))) {
  1169         source->lpVtbl->AdviseSink(source, &IID_ITfUIElementSink, (IUnknown *)videodata->ime_uielemsink, &videodata->ime_uielemsinkcookie);
  1170         source->lpVtbl->Release(source);
  1171     }
  1172 }
  1173 
  1174 static void
  1175 UILess_DisableUIUpdates(SDL_VideoData *videodata)
  1176 {
  1177     ITfSource *source = 0;
  1178     if (!videodata->ime_threadmgrex || videodata->ime_uielemsinkcookie == TF_INVALID_COOKIE)
  1179         return;
  1180 
  1181     if (SUCCEEDED(videodata->ime_threadmgrex->lpVtbl->QueryInterface(videodata->ime_threadmgrex, &IID_ITfSource, (LPVOID *)&source))) {
  1182         source->lpVtbl->UnadviseSink(source, videodata->ime_uielemsinkcookie);
  1183         videodata->ime_uielemsinkcookie = TF_INVALID_COOKIE;
  1184         source->lpVtbl->Release(source);
  1185     }
  1186 }
  1187 
  1188 static SDL_bool
  1189 UILess_SetupSinks(SDL_VideoData *videodata)
  1190 {
  1191     TfClientId clientid = 0;
  1192     SDL_bool result = SDL_FALSE;
  1193     ITfSource *source = 0;
  1194     if (FAILED(CoCreateInstance(&CLSID_TF_ThreadMgr, NULL, CLSCTX_INPROC_SERVER, &IID_ITfThreadMgrEx, (LPVOID *)&videodata->ime_threadmgrex)))
  1195         return SDL_FALSE;
  1196 
  1197     if (FAILED(videodata->ime_threadmgrex->lpVtbl->ActivateEx(videodata->ime_threadmgrex, &clientid, TF_TMAE_UIELEMENTENABLEDONLY)))
  1198         return SDL_FALSE;
  1199 
  1200     videodata->ime_uielemsink = SDL_malloc(sizeof(TSFSink));
  1201     videodata->ime_ippasink = SDL_malloc(sizeof(TSFSink));
  1202 
  1203     videodata->ime_uielemsink->lpVtbl = vtUIElementSink;
  1204     videodata->ime_uielemsink->refcount = 1;
  1205     videodata->ime_uielemsink->data = videodata;
  1206 
  1207     videodata->ime_ippasink->lpVtbl = vtIPPASink;
  1208     videodata->ime_ippasink->refcount = 1;
  1209     videodata->ime_ippasink->data = videodata;
  1210 
  1211     if (SUCCEEDED(videodata->ime_threadmgrex->lpVtbl->QueryInterface(videodata->ime_threadmgrex, &IID_ITfSource, (LPVOID *)&source))) {
  1212         if (SUCCEEDED(source->lpVtbl->AdviseSink(source, &IID_ITfUIElementSink, (IUnknown *)videodata->ime_uielemsink, &videodata->ime_uielemsinkcookie))) {
  1213             if (SUCCEEDED(source->lpVtbl->AdviseSink(source, &IID_ITfInputProcessorProfileActivationSink, (IUnknown *)videodata->ime_ippasink, &videodata->ime_alpnsinkcookie))) {
  1214                 result = SDL_TRUE;
  1215             }
  1216         }
  1217         source->lpVtbl->Release(source);
  1218     }
  1219     return result;
  1220 }
  1221 
  1222 #define SAFE_RELEASE(p)                             \
  1223 {                                                   \
  1224     if (p) {                                        \
  1225         (p)->lpVtbl->Release((p));                  \
  1226         (p) = 0;                                    \
  1227     }                                               \
  1228 }
  1229 
  1230 static void
  1231 UILess_ReleaseSinks(SDL_VideoData *videodata)
  1232 {
  1233     ITfSource *source = 0;
  1234     if (videodata->ime_threadmgrex && SUCCEEDED(videodata->ime_threadmgrex->lpVtbl->QueryInterface(videodata->ime_threadmgrex, &IID_ITfSource, (LPVOID *)&source))) {
  1235         source->lpVtbl->UnadviseSink(source, videodata->ime_uielemsinkcookie);
  1236         source->lpVtbl->UnadviseSink(source, videodata->ime_alpnsinkcookie);
  1237         SAFE_RELEASE(source);
  1238         videodata->ime_threadmgrex->lpVtbl->Deactivate(videodata->ime_threadmgrex);
  1239         SAFE_RELEASE(videodata->ime_threadmgrex);
  1240         TSFSink_Release(videodata->ime_uielemsink);
  1241         videodata->ime_uielemsink = 0;
  1242         TSFSink_Release(videodata->ime_ippasink);
  1243         videodata->ime_ippasink = 0;
  1244     }
  1245 }
  1246 
  1247 static void *
  1248 StartDrawToBitmap(HDC hdc, HBITMAP *hhbm, int width, int height)
  1249 {
  1250     BITMAPINFO info = {0};
  1251     BITMAPINFOHEADER *infoHeader = &info.bmiHeader;
  1252     BYTE *bits = NULL;
  1253     if (hhbm) {
  1254         infoHeader->biSize = sizeof(BITMAPINFOHEADER);
  1255         infoHeader->biWidth = width;
  1256         infoHeader->biHeight = -1 * SDL_abs(height);
  1257         infoHeader->biPlanes = 1;
  1258         infoHeader->biBitCount = 32;
  1259         infoHeader->biCompression = BI_RGB;
  1260         *hhbm = CreateDIBSection(hdc, &info, DIB_RGB_COLORS, (void **)&bits, 0, 0);
  1261         if (*hhbm)
  1262             SelectObject(hdc, *hhbm);
  1263     }
  1264     return bits;
  1265 }
  1266 
  1267 static void
  1268 StopDrawToBitmap(HDC hdc, HBITMAP *hhbm)
  1269 {
  1270     if (hhbm && *hhbm) {
  1271         DeleteObject(*hhbm);
  1272         *hhbm = NULL;
  1273     }
  1274 }
  1275 
  1276 /* This draws only within the specified area and fills the entire region. */
  1277 static void
  1278 DrawRect(HDC hdc, int left, int top, int right, int bottom, int pensize)
  1279 {
  1280     /* The case of no pen (PenSize = 0) is automatically taken care of. */
  1281     const int penadjust = (int)SDL_floor(pensize / 2.0f - 0.5f);
  1282     left += pensize / 2;
  1283     top += pensize / 2;
  1284     right -= penadjust;
  1285     bottom -= penadjust;
  1286     Rectangle(hdc, left, top, right, bottom);
  1287 }
  1288 
  1289 static void
  1290 IME_DestroyTextures(SDL_VideoData *videodata)
  1291 {
  1292 }
  1293 
  1294 #define SDL_swap(a,b) { \
  1295     int c = (a);        \
  1296     (a) = (b);          \
  1297     (b) = c;            \
  1298     }
  1299 
  1300 static void
  1301 IME_PositionCandidateList(SDL_VideoData *videodata, SIZE size)
  1302 {
  1303     int left, top, right, bottom;
  1304     SDL_bool ok = SDL_FALSE;
  1305     int winw = videodata->ime_winwidth;
  1306     int winh = videodata->ime_winheight;
  1307 
  1308     /* Bottom */
  1309     left = videodata->ime_rect.x;
  1310     top = videodata->ime_rect.y + videodata->ime_rect.h;
  1311     right = left + size.cx;
  1312     bottom = top + size.cy;
  1313     if (right >= winw) {
  1314         left -= right - winw;
  1315         right = winw;
  1316     }
  1317     if (bottom < winh)
  1318         ok = SDL_TRUE;
  1319 
  1320     /* Top */
  1321     if (!ok) {
  1322         left = videodata->ime_rect.x;
  1323         top = videodata->ime_rect.y - size.cy;
  1324         right = left + size.cx;
  1325         bottom = videodata->ime_rect.y;
  1326         if (right >= winw) {
  1327             left -= right - winw;
  1328             right = winw;
  1329         }
  1330         if (top >= 0)
  1331             ok = SDL_TRUE;
  1332     }
  1333 
  1334     /* Right */
  1335     if (!ok) {
  1336         left = videodata->ime_rect.x + size.cx;
  1337         top = 0;
  1338         right = left + size.cx;
  1339         bottom = size.cy;
  1340         if (right < winw)
  1341             ok = SDL_TRUE;
  1342     }
  1343 
  1344     /* Left */
  1345     if (!ok) {
  1346         left = videodata->ime_rect.x - size.cx;
  1347         top = 0;
  1348         right = videodata->ime_rect.x;
  1349         bottom = size.cy;
  1350         if (right >= 0)
  1351             ok = SDL_TRUE;
  1352     }
  1353 
  1354     /* Window too small, show at (0,0) */
  1355     if (!ok) {
  1356         left = 0;
  1357         top = 0;
  1358         right = size.cx;
  1359         bottom = size.cy;
  1360     }
  1361 
  1362     videodata->ime_candlistrect.x = left;
  1363     videodata->ime_candlistrect.y = top;
  1364     videodata->ime_candlistrect.w = right - left;
  1365     videodata->ime_candlistrect.h = bottom - top;
  1366 }
  1367 
  1368 static void
  1369 IME_RenderCandidateList(SDL_VideoData *videodata, HDC hdc)
  1370 {
  1371     int i, j;
  1372     SIZE size = {0};
  1373     SIZE candsizes[MAX_CANDLIST];
  1374     SIZE maxcandsize = {0};
  1375     HBITMAP hbm = NULL;
  1376     BYTE *bits = NULL;
  1377     const int candcount = SDL_min(SDL_min(MAX_CANDLIST, videodata->ime_candcount), videodata->ime_candpgsize);
  1378     SDL_bool vertical = videodata->ime_candvertical;
  1379 
  1380     const int listborder = 1;
  1381     const int listpadding = 0;
  1382     const int listbordercolor = RGB(0xB4, 0xC7, 0xAA);
  1383     const int listfillcolor = RGB(255, 255, 255);
  1384 
  1385     const int candborder = 1;
  1386     const int candpadding = 0;
  1387     const int candmargin = 1;
  1388     const COLORREF candbordercolor = RGB(255, 255, 255);
  1389     const COLORREF candfillcolor = RGB(255, 255, 255);
  1390     const COLORREF candtextcolor = RGB(0, 0, 0);
  1391     const COLORREF selbordercolor = RGB(0x84, 0xAC, 0xDD);
  1392     const COLORREF selfillcolor = RGB(0xD2, 0xE6, 0xFF);
  1393     const COLORREF seltextcolor = RGB(0, 0, 0);
  1394     const int horzcandspacing = 5;
  1395 
  1396     HPEN listpen = listborder != 0 ? CreatePen(PS_SOLID, listborder, listbordercolor) : (HPEN)GetStockObject(NULL_PEN);
  1397     HBRUSH listbrush = CreateSolidBrush(listfillcolor);
  1398     HPEN candpen = candborder != 0 ? CreatePen(PS_SOLID, candborder, candbordercolor) : (HPEN)GetStockObject(NULL_PEN);
  1399     HBRUSH candbrush = CreateSolidBrush(candfillcolor);
  1400     HPEN selpen = candborder != 0 ? CreatePen(PS_DOT, candborder, selbordercolor) : (HPEN)GetStockObject(NULL_PEN);
  1401     HBRUSH selbrush = CreateSolidBrush(selfillcolor);
  1402     HFONT font = CreateFont((int)(1 + videodata->ime_rect.h * 0.75f), 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_CHARACTER_PRECIS, CLIP_DEFAULT_PRECIS, PROOF_QUALITY, VARIABLE_PITCH | FF_SWISS, TEXT("Microsoft Sans Serif"));
  1403 
  1404     SetBkMode(hdc, TRANSPARENT);
  1405     SelectObject(hdc, font);
  1406 
  1407     for (i = 0; i < candcount; ++i) {
  1408         const WCHAR *s = videodata->ime_candidates[i];
  1409         if (!*s)
  1410             break;
  1411 
  1412         GetTextExtentPoint32W(hdc, s, SDL_wcslen(s), &candsizes[i]);
  1413         maxcandsize.cx = SDL_max(maxcandsize.cx, candsizes[i].cx);
  1414         maxcandsize.cy = SDL_max(maxcandsize.cy, candsizes[i].cy);
  1415 
  1416     }
  1417     if (vertical) {
  1418         size.cx =
  1419             (listborder * 2) +
  1420             (listpadding * 2) +
  1421             (candmargin * 2) +
  1422             (candborder * 2) +
  1423             (candpadding * 2) +
  1424             (maxcandsize.cx)
  1425             ;
  1426         size.cy =
  1427             (listborder * 2) +
  1428             (listpadding * 2) +
  1429             ((candcount + 1) * candmargin) +
  1430             (candcount * candborder * 2) +
  1431             (candcount * candpadding * 2) +
  1432             (candcount * maxcandsize.cy)
  1433             ;
  1434     }
  1435     else {
  1436         size.cx =
  1437             (listborder * 2) +
  1438             (listpadding * 2) +
  1439             ((candcount + 1) * candmargin) +
  1440             (candcount * candborder * 2) +
  1441             (candcount * candpadding * 2) +
  1442             ((candcount - 1) * horzcandspacing);
  1443         ;
  1444 
  1445         for (i = 0; i < candcount; ++i)
  1446             size.cx += candsizes[i].cx;
  1447 
  1448         size.cy =
  1449             (listborder * 2) +
  1450             (listpadding * 2) +
  1451             (candmargin * 2) +
  1452             (candborder * 2) +
  1453             (candpadding * 2) +
  1454             (maxcandsize.cy)
  1455             ;
  1456     }
  1457 
  1458     bits = StartDrawToBitmap(hdc, &hbm, size.cx, size.cy);
  1459 
  1460     SelectObject(hdc, listpen);
  1461     SelectObject(hdc, listbrush);
  1462     DrawRect(hdc, 0, 0, size.cx, size.cy, listborder);
  1463 
  1464     SelectObject(hdc, candpen);
  1465     SelectObject(hdc, candbrush);
  1466     SetTextColor(hdc, candtextcolor);
  1467     SetBkMode(hdc, TRANSPARENT);
  1468 
  1469     for (i = 0; i < candcount; ++i) {
  1470         const WCHAR *s = videodata->ime_candidates[i];
  1471         int left, top, right, bottom;
  1472         if (!*s)
  1473             break;
  1474 
  1475         if (vertical) {
  1476             left = listborder + listpadding + candmargin;
  1477             top = listborder + listpadding + (i * candborder * 2) + (i * candpadding * 2) + ((i + 1) * candmargin) + (i * maxcandsize.cy);
  1478             right = size.cx - listborder - listpadding - candmargin;
  1479             bottom = top + maxcandsize.cy + (candpadding * 2) + (candborder * 2);
  1480         }
  1481         else {
  1482             left = listborder + listpadding + (i * candborder * 2) + (i * candpadding * 2) + ((i + 1) * candmargin) + (i * horzcandspacing);
  1483 
  1484             for (j = 0; j < i; ++j)
  1485                 left += candsizes[j].cx;
  1486 
  1487             top = listborder + listpadding + candmargin;
  1488             right = left + candsizes[i].cx + (candpadding * 2) + (candborder * 2);
  1489             bottom = size.cy - listborder - listpadding - candmargin;
  1490         }
  1491 
  1492         if (i == videodata->ime_candsel) {
  1493             SelectObject(hdc, selpen);
  1494             SelectObject(hdc, selbrush);
  1495             SetTextColor(hdc, seltextcolor);
  1496         }
  1497         else {
  1498             SelectObject(hdc, candpen);
  1499             SelectObject(hdc, candbrush);
  1500             SetTextColor(hdc, candtextcolor);
  1501         }
  1502 
  1503         DrawRect(hdc, left, top, right, bottom, candborder);
  1504         ExtTextOutW(hdc, left + candborder + candpadding, top + candborder + candpadding, 0, NULL, s, SDL_wcslen(s), NULL);
  1505     }
  1506     StopDrawToBitmap(hdc, &hbm);
  1507 
  1508     DeleteObject(listpen);
  1509     DeleteObject(listbrush);
  1510     DeleteObject(candpen);
  1511     DeleteObject(candbrush);
  1512     DeleteObject(selpen);
  1513     DeleteObject(selbrush);
  1514     DeleteObject(font);
  1515 
  1516     IME_PositionCandidateList(videodata, size);
  1517 }
  1518 
  1519 static void
  1520 IME_Render(SDL_VideoData *videodata)
  1521 {
  1522     HDC hdc = CreateCompatibleDC(NULL);
  1523 
  1524     if (videodata->ime_candlist)
  1525         IME_RenderCandidateList(videodata, hdc);
  1526 
  1527     DeleteDC(hdc);
  1528 
  1529     videodata->ime_dirty = SDL_FALSE;
  1530 }
  1531 
  1532 void IME_Present(SDL_VideoData *videodata)
  1533 {
  1534     if (videodata->ime_dirty)
  1535         IME_Render(videodata);
  1536 
  1537     // FIXME: Need to show the IME bitmap
  1538 }
  1539 
  1540 #endif /* SDL_DISABLE_WINDOWS_IME */
  1541 
  1542 /* vi: set ts=4 sw=4 expandtab: */