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);
}
HRESULT WeaselIME::_Initialize()
{
LPINPUTCONTEXT lpIMC = ImmLockIMC(m_hIMC);
if(!lpIMC)
return E_FAIL;
lpIMC->fOpen = TRUE;
HIMCC& hIMCC = lpIMC->hCompStr;
if (!hIMCC)
hIMCC = ImmCreateIMCC(sizeof(CompositionInfo));
else
hIMCC = ImmReSizeIMCC(hIMCC, sizeof(CompositionInfo));
if(!hIMCC)
{
ImmUnlockIMC(m_hIMC);
return E_FAIL;
}
CompositionInfo* pInfo = (CompositionInfo*)ImmLockIMCC(hIMCC);
if (!pInfo)
{
ImmUnlockIMC(m_hIMC);
return E_FAIL;
}
pInfo->Reset();
ImmUnlockIMCC(hIMCC);
ImmUnlockIMC(m_hIMC);
return S_OK;
}
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;
}
static HIMCC ImeCreateBlankCompStr(void)
{
HIMCC rc;
LPCOMPOSITIONSTRING ptr;
rc = ImmCreateIMCC(sizeof(COMPOSITIONSTRING));
ptr = ImmLockIMCC(rc);
memset(ptr,0,sizeof(COMPOSITIONSTRING));
ptr->dwSize = sizeof(COMPOSITIONSTRING);
ImmUnlockIMCC(rc);
return rc;
}
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 CompString::create()
{
HIMCC& handle = imc_->hCompStr;
if (!handle) {
handle = ImmCreateIMCC(sizeof(myCompStr));
if (!handle)
return false;
} else if (ImmGetIMCCSize(handle) < sizeof(myCompStr)) {
HIMCC temp = ImmReSizeIMCC(handle, sizeof(myCompStr));
if (!temp)
return false;
handle = temp;
}
cs_ = (COMPOSITIONSTRING*)ImmLockIMCC(handle);
if (!cs_)
return false;
ZeroMemory(cs_, sizeof(myCompStr));
cs_->dwSize = sizeof(myCompStr);
cs_->dwCompReadAttrOffset = (DWORD)(UINT_PTR)&((myCompStr*)0)->compReadAttr;
cs_->dwCompReadClauseOffset = (DWORD)(UINT_PTR)&((myCompStr*)0)->compReadClause;
cs_->dwCompReadStrOffset = (DWORD)(UINT_PTR)&((myCompStr*)0)->compReadStr;
cs_->dwCompAttrOffset = (DWORD)(UINT_PTR)&((myCompStr*)0)->compAttr;
cs_->dwCompClauseOffset = (DWORD)(UINT_PTR)&((myCompStr*)0)->compClause;
cs_->dwCompStrOffset = (DWORD)(UINT_PTR)&((myCompStr*)0)->compStr;
cs_->dwResultReadClauseOffset = (DWORD)(UINT_PTR)&((myCompStr*)0)->resultReadClause;
cs_->dwResultReadStrOffset = (DWORD)(UINT_PTR)&((myCompStr*)0)->resultReadStr;
cs_->dwResultClauseOffset = (DWORD)(UINT_PTR)&((myCompStr*)0)->resultClause;
cs_->dwResultStrOffset = (DWORD)(UINT_PTR)&((myCompStr*)0)->resultStr;
ImmUnlockIMCC(handle);
return true;
}
static HIMCC updateResultStr(HIMCC old, LPWSTR resultstr, DWORD len)
{
/* we need to make sure the ResultStr and ResultClause fields are all
* set and correct */
int needed_size;
HIMCC rc;
LPBYTE newdata = NULL;
LPBYTE olddata = NULL;
LPCOMPOSITIONSTRING new_one;
LPCOMPOSITIONSTRING lpcs = NULL;
INT current_offset = 0;
TRACE("%s, %i\n",debugstr_wn(resultstr,len),len);
if (old == NULL && resultstr == NULL && len == 0)
return NULL;
if (resultstr == NULL && len != 0)
{
ERR("resultstr is NULL however we have a len! Please report\n");
len = 0;
}
if (old != NULL)
{
olddata = ImmLockIMCC(old);
lpcs = (LPCOMPOSITIONSTRING)olddata;
}
needed_size = sizeof(COMPOSITIONSTRING) + len * sizeof(WCHAR) +
sizeof(DWORD) * 2;
if (lpcs != NULL)
{
needed_size += lpcs->dwCompReadAttrLen;
needed_size += lpcs->dwCompReadClauseLen;
needed_size += lpcs->dwCompReadStrLen * sizeof(DWORD);
needed_size += lpcs->dwCompAttrLen;
needed_size += lpcs->dwCompClauseLen;
needed_size += lpcs->dwCompStrLen * sizeof(DWORD);
needed_size += lpcs->dwResultReadClauseLen;
needed_size += lpcs->dwResultReadStrLen * sizeof(DWORD);
needed_size += lpcs->dwPrivateSize;
}
rc = ImmCreateIMCC(needed_size);
newdata = ImmLockIMCC(rc);
new_one = (LPCOMPOSITIONSTRING)newdata;
new_one->dwSize = needed_size;
current_offset = sizeof(COMPOSITIONSTRING);
if (lpcs != NULL)
{
current_offset = updateField(lpcs->dwCompReadAttrLen,
lpcs->dwCompReadAttrOffset,
current_offset, newdata, olddata,
&new_one->dwCompReadAttrLen,
&new_one->dwCompReadAttrOffset, FALSE);
current_offset = updateField(lpcs->dwCompReadClauseLen,
lpcs->dwCompReadClauseOffset,
current_offset, newdata, olddata,
&new_one->dwCompReadClauseLen,
&new_one->dwCompReadClauseOffset, FALSE);
current_offset = updateField(lpcs->dwCompReadStrLen,
lpcs->dwCompReadStrOffset,
current_offset, newdata, olddata,
&new_one->dwCompReadStrLen,
&new_one->dwCompReadStrOffset, TRUE);
current_offset = updateField(lpcs->dwCompAttrLen,
lpcs->dwCompAttrOffset,
current_offset, newdata, olddata,
&new_one->dwCompAttrLen,
&new_one->dwCompAttrOffset, FALSE);
current_offset = updateField(lpcs->dwCompClauseLen,
lpcs->dwCompClauseOffset,
current_offset, newdata, olddata,
&new_one->dwCompClauseLen,
&new_one->dwCompClauseOffset, FALSE);
current_offset = updateField(lpcs->dwCompStrLen,
lpcs->dwCompStrOffset,
current_offset, newdata, olddata,
&new_one->dwCompStrLen,
&new_one->dwCompStrOffset, TRUE);
new_one->dwCursorPos = lpcs->dwCursorPos;
new_one->dwDeltaStart = 0;
current_offset = updateField(lpcs->dwResultReadClauseLen,
lpcs->dwResultReadClauseOffset,
current_offset, newdata, olddata,
&new_one->dwResultReadClauseLen,
&new_one->dwResultReadClauseOffset, FALSE);
current_offset = updateField(lpcs->dwResultReadStrLen,
lpcs->dwResultReadStrOffset,
current_offset, newdata, olddata,
&new_one->dwResultReadStrLen,
&new_one->dwResultReadStrOffset, TRUE);
/* new ResultClause , ResultStr */
current_offset = updateField(lpcs->dwPrivateSize,
lpcs->dwPrivateOffset,
current_offset, newdata, olddata,
&new_one->dwPrivateSize,
&new_one->dwPrivateOffset, FALSE);
}
/* set new data */
/* ResultClause */
if (len > 0)
{
new_one->dwResultClauseLen = sizeof(DWORD) * 2;
new_one->dwResultClauseOffset = current_offset;
*(DWORD*)(&newdata[current_offset]) = 0;
current_offset += sizeof(DWORD);
*(DWORD*)(&newdata[current_offset]) = len;
current_offset += sizeof(DWORD);
}
/* ResultStr */
new_one->dwResultStrLen = len;
if (len > 0)
{
new_one->dwResultStrOffset = current_offset;
memcpy(&newdata[current_offset],resultstr,len*sizeof(WCHAR));
}
ImmUnlockIMCC(rc);
if (lpcs)
ImmUnlockIMCC(old);
return rc;
}
