static void test_ImmDestroyIMCC(void) { HIMCC imcc; DWORD ret, count, size; VOID *p; imcc = ImmCreateIMCC(sizeof(CANDIDATEINFO)); count = ImmGetIMCCLockCount(imcc); ok(count == 0, "expect 0, returned %d\n", count); p = ImmLockIMCC(imcc); ok(p != NULL, "ImmLockIMCC failed!\n"); count = ImmGetIMCCLockCount(imcc); ok(count == 1, "expect 1, returned %d\n", count); size = ImmGetIMCCSize(imcc); ok(size == sizeof(CANDIDATEINFO), "returned %d\n", size); p = ImmDestroyIMCC(imcc); ok(p == NULL, "Destroy a locked IMCC should success!\n"); p = ImmLockIMCC(imcc); ok(p == NULL, "Lock a destroyed IMCC should fail!\n"); ret = ImmUnlockIMCC(imcc); ok(ret == FALSE, "Unlock a destroyed IMCC should return FALSE!\n"); count = ImmGetIMCCLockCount(imcc); ok(count == 0, "Get lock count of a destroyed IMCC should return 0!\n"); size = ImmGetIMCCSize(imcc); ok(size == 0, "Get size of a destroyed IMCC should return 0!\n"); SetLastError(0xdeadbeef); p = ImmDestroyIMCC(imcc); ok(p != NULL, "returned NULL\n"); ret = GetLastError(); ok(ret == ERROR_INVALID_HANDLE, "wrong last error %08x!\n", ret); }
void IME_SetCompositionStatus(BOOL fOpen) { HIMC imc; LPINPUTCONTEXT lpIMC; LPIMEPRIVATE myPrivate; imc = RealIMC(FROM_X11); lpIMC = ImmLockIMC(imc); if (lpIMC == NULL) return; myPrivate = ImmLockIMCC(lpIMC->hPrivate); if (fOpen && !myPrivate->bInComposition) { GenerateIMEMessage(imc, WM_IME_STARTCOMPOSITION, 0, 0); } else if (!fOpen && myPrivate->bInComposition) { ShowWindow(myPrivate->hwndDefault, SW_HIDE); ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = ImeCreateBlankCompStr(); GenerateIMEMessage(imc, WM_IME_ENDCOMPOSITION, 0, 0); } myPrivate->bInComposition = fOpen; ImmUnlockIMCC(lpIMC->hPrivate); ImmUnlockIMC(imc); }
static void DefaultIMEComposition(HIMC hIMC, HWND hwnd, LPARAM lParam) { TRACE("IME message WM_IME_COMPOSITION 0x%lx\n", lParam); if (lParam & GCS_RESULTSTR) { LPCOMPOSITIONSTRING compstr; LPBYTE compdata; LPWSTR ResultStr; HIMCC newCompStr; LPINPUTCONTEXT lpIMC; lpIMC = LockRealIMC(hIMC); if (lpIMC == NULL) return; TRACE("Posting result as IME_CHAR\n"); compdata = ImmLockIMCC(lpIMC->hCompStr); compstr = (LPCOMPOSITIONSTRING)compdata; ResultStr = (LPWSTR)(compdata + compstr->dwResultStrOffset); GenerateIMECHARMessages(hIMC, ResultStr, compstr->dwResultStrLen); ImmUnlockIMCC(lpIMC->hCompStr); /* clear the buffer */ newCompStr = updateResultStr(lpIMC->hCompStr, NULL, 0); ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = newCompStr; UnlockRealIMC(hIMC); } else UpdateDefaultIMEWindow(hIMC, hwnd); }
void IME_SetResultString(LPWSTR lpResult, DWORD dwResultLen) { HIMC imc; LPINPUTCONTEXT lpIMC; HIMCC newCompStr; LPIMEPRIVATE myPrivate; imc = RealIMC(FROM_X11); lpIMC = ImmLockIMC(imc); if (lpIMC == NULL) return; newCompStr = updateResultStr(lpIMC->hCompStr, lpResult, dwResultLen); ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = newCompStr; myPrivate = ImmLockIMCC(lpIMC->hPrivate); if (!myPrivate->bInComposition) GenerateIMEMessage(imc, WM_IME_STARTCOMPOSITION, 0, 0); GenerateIMEMessage(imc, WM_IME_COMPOSITION, 0, GCS_RESULTSTR); if (!myPrivate->bInComposition) GenerateIMEMessage(imc, WM_IME_ENDCOMPOSITION, 0, 0); ImmUnlockIMCC(lpIMC->hPrivate); ImmUnlockIMC(imc); }
bool fill_result(input_context& ic, const wstring& wstr_result) { HIMCC hMem; LPCOMPOSITIONSTRING lpCompStr; DWORD dwSize; dwSize = sizeof(COMPOSITIONSTRING) + (wstr_result.size() + 1) * sizeof(WORD); if (!ic->hCompStr) { ic->hCompStr = ImmCreateIMCC(dwSize); if (!ic->hCompStr) { return false; } lpCompStr = (LPCOMPOSITIONSTRING) ImmLockIMCC(ic->hCompStr); if (!lpCompStr) { return false; } lpCompStr->dwSize = dwSize; ImmUnlockIMCC(ic->hCompStr); } lpCompStr = (LPCOMPOSITIONSTRING) ImmLockIMCC(ic->hCompStr); if (!lpCompStr) { return false; } if (dwSize > lpCompStr->dwSize) { ImmUnlockIMCC(ic->hCompStr); hMem = ImmReSizeIMCC(ic->hCompStr, dwSize); if (!hMem) { return false; } if (ic->hCompStr != hMem) { ImmDestroyIMCC(ic->hCompStr); ic->hCompStr = hMem; } lpCompStr = (LPCOMPOSITIONSTRING) ImmLockIMCC(ic->hCompStr); if (!lpCompStr) { return false; } lpCompStr->dwSize = dwSize; } dwSize = lpCompStr->dwSize; //save it memset(lpCompStr, 0, dwSize); lpCompStr->dwSize = dwSize; lpCompStr->dwResultStrLen = wstr_result.size(); lpCompStr->dwResultStrOffset = sizeof(COMPOSITIONSTRING); memcpy((char *)lpCompStr+sizeof(COMPOSITIONSTRING), wstr_result.c_str(), wstr_result.size() * sizeof(wchar_t)); ImmUnlockIMCC(ic->hCompStr); return true; }
void IME_SetResultString(LPWSTR lpResult, DWORD dwResultLen) { HIMC imc; LPINPUTCONTEXT lpIMC; HIMCC newCompStr; LPIMEPRIVATE myPrivate; BOOL inComp; imc = RealIMC(FROM_X11); lpIMC = ImmLockIMC(imc); if (lpIMC == NULL) return; newCompStr = updateCompStr(lpIMC->hCompStr, NULL, 0); ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = newCompStr; newCompStr = updateResultStr(lpIMC->hCompStr, lpResult, dwResultLen); ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = newCompStr; myPrivate = ImmLockIMCC(lpIMC->hPrivate); inComp = myPrivate->bInComposition; ImmUnlockIMCC(lpIMC->hPrivate); if (!inComp) { ImmSetOpenStatus(imc, TRUE); GenerateIMEMessage(imc, WM_IME_STARTCOMPOSITION, 0, 0); } GenerateIMEMessage(imc, WM_IME_COMPOSITION, 0, GCS_COMPSTR); GenerateIMEMessage(imc, WM_IME_COMPOSITION, lpResult[0], GCS_RESULTSTR|GCS_RESULTCLAUSE); GenerateIMEMessage(imc, WM_IME_ENDCOMPOSITION, 0, 0); if (!inComp) ImmSetOpenStatus(imc, FALSE); ImmUnlockIMC(imc); }
HRESULT WeaselIME::_Finalize() { LPINPUTCONTEXT lpIMC = ImmLockIMC(m_hIMC); if (lpIMC) { lpIMC->fOpen = FALSE; if (lpIMC->hCompStr) { ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = NULL; } } ImmUnlockIMC(m_hIMC); return S_OK; }
bool input_context::enlarge_msg_buf(u32 n) { HIMCC hMem; if (m_num_msg < m_msg_buf_size) { // this function must not be called when there's still space bhjerr(" Error: enlarge_msg_buf called when still have space!"); } if (m_num_msg == m_msg_buf_size) { // this should be the first time we are called n += m_num_msg; } if (!m_ic->hMsgBuf) { m_ic->dwNumMsgBuf = 0; m_ic->hMsgBuf = ImmCreateIMCC( (n + m_num_msg) * sizeof(TRANSMSG)); if (m_ic->hMsgBuf) { if (!copy_old_msg()) { return false; } m_ic->dwNumMsgBuf = n; return true; } else { return false; } } if (hMem = ImmReSizeIMCC(m_ic->hMsgBuf, (m_ic->dwNumMsgBuf + n) * sizeof(TRANSMSG))) { if (hMem != m_ic->hMsgBuf) { ImmDestroyIMCC(m_ic->hMsgBuf); m_ic->hMsgBuf = hMem; } if (m_num_msg == m_msg_buf_size && m_num_msg > 0) { // copy the old messages over if (!copy_old_msg()) { return false; } m_num_msg += m_ic->dwNumMsgBuf; //number of valid messages } m_ic->dwNumMsgBuf += n; //this last n messages are not valid yet! return true; } else { // resize failed return false; } }
static void test_ImmGetIMCCLockCount(void) { HIMCC imcc; DWORD count, g_count, ret, i; VOID *p; imcc = ImmCreateIMCC(sizeof(CANDIDATEINFO)); count = ImmGetIMCCLockCount(imcc); ok(count == 0, "expect 0, returned %d\n", count); ImmLockIMCC(imcc); count = ImmGetIMCCLockCount(imcc); ok(count == 1, "expect 1, returned %d\n", count); ret = ImmUnlockIMCC(imcc); ok(ret == FALSE, "expect FALSE, ret %d\n", ret); count = ImmGetIMCCLockCount(imcc); ok(count == 0, "expect 0, returned %d\n", count); ret = ImmUnlockIMCC(imcc); ok(ret == FALSE, "expect FALSE, ret %d\n", ret); count = ImmGetIMCCLockCount(imcc); ok(count == 0, "expect 0, returned %d\n", count); p = ImmLockIMCC(imcc); ok(GlobalHandle(p) == imcc, "expect %p, returned %p\n", imcc, GlobalHandle(p)); for (i = 0; i < GMEM_LOCKCOUNT * 2; i++) { ImmLockIMCC(imcc); count = ImmGetIMCCLockCount(imcc); g_count = GlobalFlags(imcc) & GMEM_LOCKCOUNT; ok(count == g_count, "count %d, g_count %d\n", count, g_count); } count = ImmGetIMCCLockCount(imcc); ok(count == GMEM_LOCKCOUNT, "expect GMEM_LOCKCOUNT, returned %d\n", count); for (i = 0; i < GMEM_LOCKCOUNT - 1; i++) GlobalUnlock(imcc); count = ImmGetIMCCLockCount(imcc); ok(count == 1, "expect 1, returned %d\n", count); GlobalUnlock(imcc); count = ImmGetIMCCLockCount(imcc); ok(count == 0, "expect 0, returned %d\n", count); ImmDestroyIMCC(imcc); }
BOOL WINAPI ImeSetCompositionString(HIMC hIMC, DWORD dwIndex, LPCVOID lpComp, DWORD dwCompLen, LPCVOID lpRead, DWORD dwReadLen) { LPINPUTCONTEXT lpIMC; DWORD flags = 0; WCHAR wParam = 0; LPIMEPRIVATE myPrivate; TRACE("(%p, %d, %p, %d, %p, %d):\n", hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen); if (hIMC != FROM_X11) FIXME("PROBLEM: This only sets the wine level string\n"); /* * Explanation: * this sets the composition string in the imm32.dll level * of the composition buffer. we cannot manipulate the xim level * buffer, which means that once the xim level buffer changes again * any call to this function from the application will be lost */ if (lpRead && dwReadLen) FIXME("Reading string unimplemented\n"); lpIMC = LockRealIMC(hIMC); if (lpIMC == NULL) return FALSE; myPrivate = ImmLockIMCC(lpIMC->hPrivate); if (dwIndex == SCS_SETSTR) { HIMCC newCompStr; if (!myPrivate->bInComposition) { GenerateIMEMessage(hIMC, WM_IME_STARTCOMPOSITION, 0, 0); myPrivate->bInComposition = TRUE; } flags = GCS_COMPSTR; if (dwCompLen && lpComp) { newCompStr = updateCompStr(lpIMC->hCompStr, (LPCWSTR)lpComp, dwCompLen / sizeof(WCHAR)); ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = newCompStr; wParam = ((const WCHAR*)lpComp)[0]; flags |= GCS_COMPCLAUSE | GCS_COMPATTR | GCS_DELTASTART; } else { newCompStr = updateCompStr(lpIMC->hCompStr, NULL, 0); ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = newCompStr; } } GenerateIMEMessage(hIMC, WM_IME_COMPOSITION, wParam, flags); ImmUnlockIMCC(lpIMC->hPrivate); UnlockRealIMC(hIMC); return TRUE; }
BOOL WINAPI NotifyIME(HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue) { BOOL bRet = FALSE; LPINPUTCONTEXT lpIMC; TRACE("%p %i %i %i\n",hIMC,dwAction,dwIndex,dwValue); lpIMC = LockRealIMC(hIMC); if (lpIMC == NULL) return FALSE; switch (dwAction) { case NI_OPENCANDIDATE: FIXME("NI_OPENCANDIDATE\n"); break; case NI_CLOSECANDIDATE: FIXME("NI_CLOSECANDIDATE\n"); break; case NI_SELECTCANDIDATESTR: FIXME("NI_SELECTCANDIDATESTR\n"); break; case NI_CHANGECANDIDATELIST: FIXME("NI_CHANGECANDIDATELIST\n"); break; case NI_SETCANDIDATE_PAGESTART: FIXME("NI_SETCANDIDATE_PAGESTART\n"); break; case NI_SETCANDIDATE_PAGESIZE: FIXME("NI_SETCANDIDATE_PAGESIZE\n"); break; case NI_CONTEXTUPDATED: switch (dwValue) { case IMC_SETCOMPOSITIONWINDOW: FIXME("IMC_SETCOMPOSITIONWINDOW\n"); break; case IMC_SETCONVERSIONMODE: FIXME("IMC_SETCONVERSIONMODE\n"); break; case IMC_SETSENTENCEMODE: FIXME("IMC_SETSENTENCEMODE\n"); break; case IMC_SETCANDIDATEPOS: FIXME("IMC_SETCANDIDATEPOS\n"); break; case IMC_SETCOMPOSITIONFONT: { LPIMEPRIVATE myPrivate; TRACE("IMC_SETCOMPOSITIONFONT\n"); myPrivate = ImmLockIMCC(lpIMC->hPrivate); if (myPrivate->textfont) { DeleteObject(myPrivate->textfont); myPrivate->textfont = NULL; } myPrivate->textfont = CreateFontIndirectW(&lpIMC->lfFont.W); ImmUnlockIMCC(lpIMC->hPrivate); } break; case IMC_SETOPENSTATUS: TRACE("IMC_SETOPENSTATUS\n"); bRet = TRUE; X11DRV_SetPreeditState(lpIMC->hWnd, lpIMC->fOpen); if (!lpIMC->fOpen) { LPIMEPRIVATE myPrivate; myPrivate = ImmLockIMCC(lpIMC->hPrivate); if (myPrivate->bInComposition) { X11DRV_ForceXIMReset(lpIMC->hWnd); GenerateIMEMessage(hIMC, WM_IME_ENDCOMPOSITION, 0, 0); myPrivate->bInComposition = FALSE; } ImmUnlockIMCC(lpIMC->hPrivate); } break; default: FIXME("Unknown\n"); break; } break; case NI_COMPOSITIONSTR: switch (dwIndex) { case CPS_COMPLETE: { HIMCC newCompStr; DWORD cplen = 0; LPWSTR cpstr; LPCOMPOSITIONSTRING cs = NULL; LPBYTE cdata = NULL; LPIMEPRIVATE myPrivate; TRACE("CPS_COMPLETE\n"); /* clear existing result */ newCompStr = updateResultStr(lpIMC->hCompStr, NULL, 0); ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = newCompStr; if (lpIMC->hCompStr) { cdata = ImmLockIMCC(lpIMC->hCompStr); cs = (LPCOMPOSITIONSTRING)cdata; cplen = cs->dwCompStrLen; cpstr = (LPWSTR)&(cdata[cs->dwCompStrOffset]); ImmUnlockIMCC(lpIMC->hCompStr); } if (cplen > 0) { WCHAR param = cpstr[0]; newCompStr = updateResultStr(lpIMC->hCompStr, cpstr, cplen); ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = newCompStr; newCompStr = updateCompStr(lpIMC->hCompStr, NULL, 0); ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = newCompStr; GenerateIMEMessage(hIMC, WM_IME_COMPOSITION, 0, GCS_COMPSTR); GenerateIMEMessage(hIMC, WM_IME_COMPOSITION, param, GCS_RESULTSTR|GCS_RESULTCLAUSE); } GenerateIMEMessage(hIMC,WM_IME_ENDCOMPOSITION, 0, 0); myPrivate = ImmLockIMCC(lpIMC->hPrivate); myPrivate->bInComposition = FALSE; ImmUnlockIMCC(lpIMC->hPrivate); bRet = TRUE; } break; case CPS_CONVERT: FIXME("CPS_CONVERT\n"); break; case CPS_REVERT: FIXME("CPS_REVERT\n"); break; case CPS_CANCEL: { LPIMEPRIVATE myPrivate; TRACE("CPS_CANCEL\n"); X11DRV_ForceXIMReset(lpIMC->hWnd); if (lpIMC->hCompStr) ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = ImeCreateBlankCompStr(); myPrivate = ImmLockIMCC(lpIMC->hPrivate); if (myPrivate->bInComposition) { GenerateIMEMessage(hIMC, WM_IME_ENDCOMPOSITION, 0, 0); myPrivate->bInComposition = FALSE; } ImmUnlockIMCC(lpIMC->hPrivate); bRet = TRUE; } break; default: FIXME("Unknown\n"); break; } break; default: FIXME("Unknown Message\n"); break; } UnlockRealIMC(hIMC); return bRet; }