[ros-diffs] [winesync] 29034: Autosyncing with Wine HEAD

Author: winesync
Date: Fri Sep 14 12:03:04 2007
New Revision: 29034

URL: http://svn.reactos.org/svn/reactos?rev=29034&view=rev
Log:
Autosyncing with Wine HEAD

Modified:
    trunk/reactos/dll/win32/imm32/imm.c
    trunk/reactos/dll/win32/imm32/imm32.rbuild
    trunk/reactos/dll/win32/imm32/imm32.spec

Modified: trunk/reactos/dll/win32/imm32/imm.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/imm32/imm.c?rev=…
==============================================================================
--- trunk/reactos/dll/win32/imm32/imm.c (original)
+++ trunk/reactos/dll/win32/imm32/imm.c Fri Sep 14 12:03:04 2007
@@ -2,7 +2,7 @@
  * IMM32 library
  *
  * Copyright 1998 Patrik Stridvall
- * Copyright 2002, 2003 CodeWeavers, Aric Stewart
+ * Copyright 2002, 2003, 2007 CodeWeavers, Aric Stewart
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -28,6 +28,7 @@
 #include "winerror.h"
 #include "wine/debug.h"
 #include "imm.h"
+#include "ddk/imm.h"
 #include "winnls.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(imm);
@@ -36,25 +37,21 @@
 
 static void (*pX11DRV_ForceXIMReset)(HWND);
 
+typedef struct tagIMCCInternal
+{
+    DWORD dwLock;
+    DWORD dwSize;
+} IMCCInternal;
+
 typedef struct tagInputContextData
 {
-        LPBYTE          CompositionString;
-        LPBYTE          CompositionReadingString;
-        LPBYTE          ResultString;
-        LPBYTE          ResultReadingString;
-        DWORD           dwCompStringSize;   /* buffer size */
-        DWORD           dwCompStringLength; /* string length (in bytes) */
-        DWORD           dwCompReadStringSize;
-        DWORD           dwResultStringSize;
-        DWORD           dwResultReadStringSize;
-        HWND            hwnd;
-        BOOL            bOpen;
         BOOL            bInternalState;
         BOOL            bRead;
         BOOL            bInComposition;
-        LOGFONTW        font;
         HFONT           textfont;
-        COMPOSITIONFORM CompForm;
+
+        DWORD           dwLock;
+        INPUTCONTEXT    IMC;
 } InputContextData;
 
 static InputContextData *root_context = NULL;
@@ -77,24 +74,33 @@
  */
 static LRESULT WINAPI IME_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
                                           LPARAM lParam);
-static void UpdateDataInDefaultIMEWindow(HWND hwnd);
+static void UpdateDataInDefaultIMEWindow(HWND hwnd, BOOL showable);
 static void ImmInternalPostIMEMessage(UINT, WPARAM, LPARAM);
 static void ImmInternalSetOpenStatus(BOOL fOpen);
+static HIMCC updateResultStr(HIMCC old, LPWSTR resultstr, DWORD len);
 
 static VOID IMM_PostResult(InputContextData *data)
 {
     unsigned int i;
+    LPCOMPOSITIONSTRING compstr;
+    LPBYTE compdata;
+    LPWSTR ResultStr;
+    HIMCC newCompStr;
+
     TRACE("Posting result as IME_CHAR\n");
-
-    for (i = 0; i < data->dwResultStringSize / sizeof (WCHAR); i++)
-        ImmInternalPostIMEMessage (WM_IME_CHAR, ((WCHAR*)data->ResultString)[i],
-                     1);
+    compdata = ImmLockIMCC(root_context->IMC.hCompStr);
+    compstr = (LPCOMPOSITIONSTRING)compdata;
+    ResultStr = (LPWSTR)(compdata + compstr->dwResultStrOffset);
+
+    for (i = 0; i < compstr->dwResultStrLen; i++)
+        ImmInternalPostIMEMessage (WM_IME_CHAR, ResultStr[i], 1);
+
+    ImmUnlockIMCC(root_context->IMC.hCompStr);
 
     /* clear the buffer */
-    if (data->dwResultStringSize)
-        HeapFree(GetProcessHeap(),0,data->ResultString);
-    data->dwResultStringSize = 0;
-    data->ResultString = NULL;
+    newCompStr = updateResultStr(root_context->IMC.hCompStr, NULL, 0);
+    ImmDestroyIMCC(root_context->IMC.hCompStr);
+    root_context->IMC.hCompStr = newCompStr;
 }
 
 static void IMM_Register(void)
@@ -164,8 +170,8 @@
 {
     HWND target = GetFocus();
     if (!target)
-       PostMessageW(root_context->hwnd,msg,wParam,lParam);
-    else 
+       PostMessageW(root_context->IMC.hWnd,msg,wParam,lParam);
+    else
        PostMessageW(target, msg, wParam, lParam);
 }
 
@@ -173,7 +179,7 @@
 {
     HWND target;
 
-    target = root_context->hwnd;
+    target = root_context->IMC.hWnd;
     if (!target) target = GetFocus();
 
     if (target)
@@ -186,36 +192,302 @@
 {
     TRACE("Setting internal state to
%s\n",(fOpen)?"OPEN":"CLOSED");
 
-   root_context->bOpen = fOpen;
+   root_context->IMC.fOpen = fOpen;
    root_context->bInternalState = fOpen;
 
    if (fOpen == FALSE)
    {
         ShowWindow(hwndDefault,SW_HIDE);
-
-        if (root_context->dwCompStringSize)
-            HeapFree(GetProcessHeap(),0,root_context->CompositionString);
-        if (root_context->dwCompReadStringSize)
-            HeapFree(GetProcessHeap(),0,root_context->CompositionReadingString);
-        if (root_context->dwResultStringSize)
-            HeapFree(GetProcessHeap(),0,root_context->ResultString);
-        if (root_context->dwResultReadStringSize)
-            HeapFree(GetProcessHeap(),0,root_context->ResultReadingString);
-        root_context->dwCompStringSize = 0;
-        root_context->dwCompStringLength = 0;
-        root_context->CompositionString = NULL;
-        root_context->dwCompReadStringSize = 0;
-        root_context->CompositionReadingString = NULL;
-        root_context->dwResultStringSize = 0;
-        root_context->ResultString = NULL;
-        root_context->dwResultReadStringSize = 0;
-        root_context->ResultReadingString = NULL;
+        ImmDestroyIMCC(root_context->IMC.hCompStr);
+        root_context->IMC.hCompStr = NULL;
     }
     else
         ShowWindow(hwndDefault, SW_SHOWNOACTIVATE);
 
    ImmInternalSendIMENotify(IMN_SETOPENSTATUS, 0);
 }
+
+static int updateField(DWORD origLen, DWORD origOffset, DWORD currentOffset,
+                       LPBYTE target, LPBYTE source, DWORD* lenParam,
+                       DWORD* offsetParam, BOOL wchars )
+{
+     if (origLen > 0 && origOffset > 0)
+     {
+        int truelen = origLen;
+        if (wchars)
+            truelen *= sizeof(WCHAR);
+
+        memcpy(&target[currentOffset], &source[origOffset], truelen);
+
+        *lenParam = origLen;
+        *offsetParam = currentOffset;
+        currentOffset += truelen;
+     }
+     return currentOffset;
+}
+
+static HIMCC updateCompStr(HIMCC old, LPWSTR compstr, DWORD len)
+{
+    /* we need to make sure the CompStr, CompClaus and CompAttr 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(compstr,len),len);
+
+    if (old != NULL)
+    {
+        olddata = ImmLockIMCC(old);
+        lpcs = (LPCOMPOSITIONSTRING)olddata;
+    }
+
+    needed_size = sizeof(COMPOSITIONSTRING) + len * sizeof(WCHAR) +
+                  len + sizeof(DWORD) * 2;
+
+    if (lpcs != NULL)
+    {
+        needed_size += lpcs->dwCompReadAttrLen;
+        needed_size += lpcs->dwCompReadClauseLen;
+        needed_size += lpcs->dwCompReadStrLen * sizeof(DWORD);
+        needed_size += lpcs->dwResultReadClauseLen;
+        needed_size += lpcs->dwResultReadStrLen * sizeof(DWORD);
+        needed_size += lpcs->dwResultClauseLen;
+        needed_size += lpcs->dwResultStrLen * 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);
+
+        /* new CompAttr, CompClause, CompStr, 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);
+
+        current_offset = updateField(lpcs->dwResultClauseLen,
+                                     lpcs->dwResultClauseOffset,
+                                     current_offset, newdata, olddata,
+                                     &new_one->dwResultClauseLen,
+                                     &new_one->dwResultClauseOffset, FALSE);
+
+        current_offset = updateField(lpcs->dwResultStrLen,
+                                     lpcs->dwResultStrOffset,
+                                     current_offset, newdata, olddata,
+                                     &new_one->dwResultStrLen,
+                                     &new_one->dwResultStrOffset, TRUE);
+
+        current_offset = updateField(lpcs->dwPrivateSize,
+                                     lpcs->dwPrivateOffset,
+                                     current_offset, newdata, olddata,
+                                     &new_one->dwPrivateSize,
+                                     &new_one->dwPrivateOffset, FALSE);
+    }
+
+    /* set new data */
+    /* CompAttr */
+    new_one->dwCompAttrLen = len;
+    if (len > 0)
+    {
+        new_one->dwCompAttrOffset = current_offset;
+        memset(&newdata[current_offset],ATTR_INPUT,len);
+        current_offset += len;
+    }
+
+    /* CompClause */
+    if (len > 0)
+    {
+        new_one->dwCompClauseLen = sizeof(DWORD) * 2;
+        new_one->dwCompClauseOffset = current_offset;
+        *(DWORD*)(&newdata[current_offset]) = 0;
+        current_offset += sizeof(DWORD);
+        *(DWORD*)(&newdata[current_offset]) = len;
+        current_offset += sizeof(DWORD);
+    }
+
+    /* CompStr */
+    new_one->dwCompStrLen = len;
+    if (len > 0)
+    {
+        new_one->dwCompStrOffset = current_offset;
+        memcpy(&newdata[current_offset],compstr,len*sizeof(WCHAR));
+    }
+
+    /* CursorPos */
+    new_one->dwCursorPos = len;
+
+    ImmUnlockIMCC(rc);
+    if (lpcs)
+        ImmUnlockIMCC(old);
+
+    return rc;
+}
+
+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)
+    {
+        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;
+}
+
 
 
 /***********************************************************************
@@ -242,25 +514,25 @@
     /*
      * If already associated just return
      */
-    if (data->hwnd == hWnd)
+    if (data->IMC.hWnd == hWnd)
         return hIMC;
 
-    if (IsWindow(data->hwnd))
+    if (IsWindow(data->IMC.hWnd))
     {
         /*
          * Post a message that your context is switching
          */
-        SendMessageW(data->hwnd, WM_IME_SETCONTEXT, FALSE, ISC_SHOWUIALL);
-    }
-
-    data->hwnd = hWnd;
-
-    if (IsWindow(data->hwnd))
+        SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, FALSE, ISC_SHOWUIALL);
+    }
+
+    data->IMC.hWnd = hWnd;
+
+    if (IsWindow(data->IMC.hWnd))
     {
         /*
          * Post a message that your context is switching
          */
-        SendMessageW(data->hwnd, WM_IME_SETCONTEXT, TRUE, ISC_SHOWUIALL);
+        SendMessageW(data->IMC.hWnd, WM_IME_SETCONTEXT, TRUE, ISC_SHOWUIALL);
     }
 
     /*
@@ -313,8 +585,7 @@
 {
     InputContextData *new_context;
 
-    new_context = HeapAlloc(GetProcessHeap(),0,sizeof(InputContextData));
-    ZeroMemory(new_context,sizeof(InputContextData));
+    new_context = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(InputContextData));
 
     return (HIMC)new_context;
 }
@@ -330,14 +601,11 @@
 
     if (hIMC)
     {
-        if (data->dwCompStringSize)
-            HeapFree(GetProcessHeap(),0,data->CompositionString);
-        if (data->dwCompReadStringSize)
-            HeapFree(GetProcessHeap(),0,data->CompositionReadingString);
-        if (data->dwResultStringSize)
-            HeapFree(GetProcessHeap(),0,data->ResultString);
-        if (data->dwResultReadStringSize)
-            HeapFree(GetProcessHeap(),0,data->ResultReadingString);
+        ImmDestroyIMCC(root_context->IMC.hCompStr);
+        ImmDestroyIMCC(root_context->IMC.hCandInfo);
+        ImmDestroyIMCC(root_context->IMC.hGuideLine);
+        ImmDestroyIMCC(root_context->IMC.hPrivate);
+        ImmDestroyIMCC(root_context->IMC.hMsgBuf);
 
         if (data->textfont)
         {
@@ -513,88 +781,99 @@
     CHAR *buf;
     LONG rc = 0;
     InputContextData *data = (InputContextData*)hIMC;
+    LPCOMPOSITIONSTRING compstr;
+    LPBYTE compdata;
 
     TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
 
     if (!data)
        return FALSE;
 
-    if (dwIndex == GCS_RESULTSTR)
-    {
-        TRACE("GSC_RESULTSTR %p %i\n",data->ResultString,
-                                    data->dwResultStringSize);
-
-        buf = HeapAlloc( GetProcessHeap(), 0, data->dwResultStringSize * 3 );
-        rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)data->ResultString,
-                                 data->dwResultStringSize / sizeof(WCHAR), buf,
-                                 data->dwResultStringSize * 3, NULL, NULL);
+    if (!data->IMC.hCompStr)
+       return FALSE;
+
+    compdata = ImmLockIMCC(data->IMC.hCompStr);
+    compstr = (LPCOMPOSITIONSTRING)compdata;
+
+    if (dwIndex == GCS_RESULTSTR && compstr->dwResultStrLen > 0 &&
+        compstr->dwResultStrOffset > 0)
+    {
+        LPWSTR ResultStr = (LPWSTR)(compdata + compstr->dwResultStrOffset);
+
+        TRACE("GSC_RESULTSTR %p %i\n",ResultStr,
+                                    compstr->dwResultStrLen);
+
+        buf = HeapAlloc( GetProcessHeap(), 0, compstr->dwResultStrLen * 3 );
+        rc = WideCharToMultiByte(CP_ACP, 0, ResultStr,
+                                 compstr->dwResultStrLen , buf,
+                                 compstr->dwResultStrLen * 3, NULL, NULL);
         if (dwBufLen >= rc)
             memcpy(lpBuf,buf,rc);
 
         data->bRead = TRUE;
         HeapFree( GetProcessHeap(), 0, buf );
     }
-    else if (dwIndex == GCS_COMPSTR)
-    {
-         TRACE("GSC_COMPSTR %p %i\n", data->CompositionString,
data->dwCompStringLength);
-
-        buf = HeapAlloc( GetProcessHeap(), 0, data->dwCompStringLength * 3 );
-        rc = WideCharToMultiByte(CP_ACP, 0,(LPWSTR)data->CompositionString,
-                                 data->dwCompStringLength/ sizeof(WCHAR), buf,
-                                 data->dwCompStringLength* 3, NULL, NULL);
+    else if (dwIndex == GCS_COMPSTR && compstr->dwCompStrLen > 0
&&
+              compstr->dwCompStrOffset > 0)
+    {
+        LPWSTR CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
+
+        TRACE("GSC_COMPSTR %p %i\n", CompString, compstr->dwCompStrLen);
+
+        buf = HeapAlloc( GetProcessHeap(), 0, compstr->dwCompStrLen * 3 );
+        rc = WideCharToMultiByte(CP_ACP, 0, CompString,
+                                 compstr->dwCompStrLen, buf,
+                                 compstr->dwCompStrLen * 3, NULL, NULL);
         if (dwBufLen >= rc)
             memcpy(lpBuf,buf,rc);
         HeapFree( GetProcessHeap(), 0, buf );
     }
-    else if (dwIndex == GCS_COMPATTR)
-    {
-        TRACE("GSC_COMPATTR %p %i\n", data->CompositionString,
data->dwCompStringLength);
-
-        rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)data->CompositionString,
-                                 data->dwCompStringLength/ sizeof(WCHAR), NULL,
-                                 0, NULL, NULL);
- 
+    else if (dwIndex == GCS_COMPATTR && compstr->dwCompAttrLen > 0
&&
+             compstr->dwCompAttrOffset > 0)
+    {
+        LPWSTR Compattr = (LPWSTR)(compdata + compstr->dwCompAttrOffset);
+        TRACE("GSC_COMPATTR %p %i\n", Compattr , compstr->dwCompAttrLen);
+
+        rc = compstr->dwCompAttrLen;
         if (dwBufLen >= rc)
-        {
-            int i=0;
-            for (i = 0;  i < rc; i++)
-                ((LPBYTE)lpBuf)[i] = ATTR_INPUT;
-    }
-    }
-    else if (dwIndex == GCS_COMPCLAUSE)
-    {
-        TRACE("GSC_COMPCLAUSE %p %i\n", data->CompositionString,
data->dwCompStringLength);
- 
-        rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)data->CompositionString,
-                                 data->dwCompStringLength/ sizeof(WCHAR), NULL,
-                                 0, NULL, NULL);
-
-        if (dwBufLen >= sizeof(DWORD)*2)
-        {
-            ((LPDWORD)lpBuf)[0] = 0;
-            ((LPDWORD)lpBuf)[1] = rc;
-        }
-        rc = sizeof(DWORD)*2;
-    }
-    else if (dwIndex == GCS_RESULTCLAUSE)
-    {
-        TRACE("GSC_RESULTCLAUSE %p %i\n", data->ResultString,
data->dwResultStringSize);
-
-        rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)data->ResultString,
-                                 data->dwResultStringSize/ sizeof(WCHAR), NULL,
-                                 0, NULL, NULL);
-
-        if (dwBufLen >= sizeof(DWORD)*2)
-        {
-            ((LPDWORD)lpBuf)[0] = 0;
-            ((LPDWORD)lpBuf)[1] = rc;
-        }
-        rc = sizeof(DWORD)*2;
+            memcpy(lpBuf,Compattr,rc);
+    }
+    else if (dwIndex == GCS_COMPCLAUSE && compstr->dwCompClauseLen > 0
&&
+             compstr->dwCompClauseOffset > 0)
+    {
+        LPWSTR Compclause = (LPWSTR)(compdata + compstr->dwCompClauseOffset);
+        TRACE("GSC_COMPCLAUSE %p %i\n", Compclause,
compstr->dwCompClauseLen);
+
+        rc = compstr->dwCompClauseLen;
+        if (dwBufLen >= compstr->dwCompClauseLen)
+            memcpy(lpBuf,Compclause,rc);
+    }
+    else if (dwIndex == GCS_RESULTCLAUSE && compstr->dwResultClauseLen > 0
&&
+             compstr->dwResultClauseOffset > 0)
+    {
+        LPWSTR Resultclause = (LPWSTR)(compdata + compstr->dwResultClauseOffset);
+        TRACE("GSC_RESULTCLAUSE %p %i\n", Resultclause,
compstr->dwResultClauseLen);
+
+        rc = compstr->dwResultClauseLen;
+        if (dwBufLen >= compstr->dwResultClauseLen)
+            memcpy(lpBuf,Resultclause,rc);
+    }
+    else if (dwIndex == GCS_CURSORPOS)
+    {
+        TRACE("GSC_CURSORPOS\n");
+        rc = compstr->dwCursorPos;
+    }
+    else if (dwIndex == GCS_DELTASTART)
+    {
+        TRACE("GCS_DELTASTART\n");
+        rc = compstr->dwDeltaStart;
     }
     else
     {
         FIXME("Unhandled index 0x%x\n",dwIndex);
     }
+
+    ImmUnlockIMCC(data->IMC.hCompStr);
 
     return rc;
 }
@@ -608,71 +887,93 @@
 {
     LONG rc = 0;
     InputContextData *data = (InputContextData*)hIMC;
+    LPCOMPOSITIONSTRING compstr;
+    LPBYTE compdata;
 
     TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
 
     if (!data)
        return FALSE;
 
-    if (dwIndex == GCS_RESULTSTR)
-    {
+    if (!data->IMC.hCompStr)
+       return FALSE;
+
+    compdata = ImmLockIMCC(data->IMC.hCompStr);
+    compstr = (LPCOMPOSITIONSTRING)compdata;
+
+    if (dwIndex == GCS_RESULTSTR && compstr->dwResultStrLen > 0 &&
+        compstr->dwResultStrOffset > 0)
+    {
+        LPWSTR ResultStr = (LPWSTR)(compdata + compstr->dwResultStrOffset);
         data->bRead = TRUE;
-
-        if (dwBufLen >= data->dwResultStringSize)
-            memcpy(lpBuf,data->ResultString,data->dwResultStringSize);
-        
-        rc =  data->dwResultStringSize;
-    }
-    else if (dwIndex == GCS_RESULTREADSTR)
-    {
-        if (dwBufLen >= data->dwResultReadStringSize)
-            memcpy(lpBuf,data->ResultReadingString,
-                    data->dwResultReadStringSize);
-        
-        rc = data->dwResultReadStringSize;
-    }   
-    else if (dwIndex == GCS_COMPSTR)
-    {
-        if (dwBufLen >= data->dwCompStringLength)
-            memcpy(lpBuf,data->CompositionString,data->dwCompStringLength);
-
-        rc = data->dwCompStringLength;
-    }
-    else if (dwIndex == GCS_COMPATTR)
-    {
-        unsigned int len = data->dwCompStringLength;
-        
-        if (dwBufLen >= len)
-        {
-            unsigned int i=0;
-            for (i = 0;  i < len; i++)
-                ((LPBYTE)lpBuf)[i] = ATTR_INPUT;
-        }
-
-        rc = len;
-    }
-    else if (dwIndex == GCS_COMPCLAUSE)
-    {
-        if (dwBufLen >= sizeof(DWORD)*2)
-        {
-            ((LPDWORD)lpBuf)[0] = 0;
-            ((LPDWORD)lpBuf)[1] = data->dwCompStringLength/sizeof(WCHAR);
-        }
-        rc = sizeof(DWORD)*2;
-    }
-    else if (dwIndex == GCS_COMPREADSTR)
-    {
-        if (dwBufLen >= data->dwCompReadStringSize)
-            memcpy(lpBuf,data->CompositionReadingString,
-                    data->dwCompReadStringSize);
-        
-        rc = data->dwCompReadStringSize;
-    }   
+        rc =  compstr->dwResultStrLen * sizeof(WCHAR);
+
+        if (dwBufLen >= rc)
+            memcpy(lpBuf,ResultStr,rc);
+    }
+    else if (dwIndex == GCS_RESULTREADSTR && compstr->dwResultReadStrLen >
0 &&
+             compstr->dwResultReadStrOffset > 0)
+    {
+        LPWSTR ResultReadString = (LPWSTR)(compdata +
compstr->dwResultReadStrOffset);
+
+        rc = compstr->dwResultReadStrLen * sizeof(WCHAR);
+        if (dwBufLen >= rc)
+            memcpy(lpBuf,ResultReadString,rc);
+    }
+    else if (dwIndex == GCS_COMPSTR && compstr->dwCompStrLen > 0
&&
+              compstr->dwCompStrOffset > 0)
+    {
+        LPWSTR CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
+        rc = compstr->dwCompStrLen * sizeof(WCHAR);
+        if (dwBufLen >= rc)
+            memcpy(lpBuf,CompString,rc);
+    }
+    else if (dwIndex == GCS_COMPATTR && compstr->dwCompAttrLen > 0
&&
+             compstr->dwCompAttrOffset > 0)
+    {
+
+        LPWSTR Compattr = (LPWSTR)(compdata + compstr->dwCompAttrOffset);
+
+        rc = compstr->dwCompAttrLen;
+        if (dwBufLen >= rc)
+            memcpy(lpBuf,Compattr,rc);
+    }
+    else if (dwIndex == GCS_COMPCLAUSE && compstr->dwCompClauseLen > 0
&&
+             compstr->dwCompClauseOffset > 0)
+    {
+        LPWSTR Compclause = (LPWSTR)(compdata + compstr->dwCompClauseOffset);
+
+        rc = compstr->dwCompClauseLen;
+        if (dwBufLen >= compstr->dwCompClauseLen)
+            memcpy(lpBuf,Compclause,rc);
+    }
+    else if (dwIndex == GCS_COMPREADSTR && compstr->dwCompReadStrLen > 0
&&
+              compstr->dwCompReadStrOffset > 0)
+    {
+        LPWSTR CompReadString = (LPWSTR)(compdata + compstr->dwCompReadStrOffset);
+
+        rc = compstr->dwCompReadStrLen * sizeof(WCHAR);
+
+        if (dwBufLen >= rc)
+            memcpy(lpBuf,CompReadString,rc);
+    }
+    else if (dwIndex == GCS_CURSORPOS)
+    {
+        TRACE("GSC_CURSORPOS\n");
+        rc = compstr->dwCursorPos;
+    }
+    else if (dwIndex == GCS_DELTASTART)
+    {
+        TRACE("GCS_DELTASTART\n");
+        rc = compstr->dwDeltaStart;
+    }
     else
     {
         FIXME("Unhandled index 0x%x\n",dwIndex);
     }   
 
+    ImmUnlockIMCC(data->IMC.hCompStr);
+
     return rc;
 }
 
@@ -688,7 +989,7 @@
     if (!data)
         return FALSE;
 
-    memcpy(lpCompForm,&(data->CompForm),sizeof(COMPOSITIONFORM));
+    memcpy(lpCompForm,&(data->IMC.cfCompForm),sizeof(COMPOSITIONFORM));
     return 1;
 }
 
@@ -703,7 +1004,7 @@
     if (!root_context)
         return NULL;
 
-    root_context->hwnd = hWnd;
+    root_context->IMC.hWnd = hWnd;
     return (HIMC)root_context;
 }
 
@@ -876,7 +1177,7 @@
         return FALSE;
   FIXME("(%p): semi-stub\n", hIMC);
 
-  return data->bOpen;
+  return data->IMC.fOpen;
 }
 
 /***********************************************************************
@@ -1022,7 +1323,7 @@
 {
     BOOL rc = FALSE;
 
-    TRACE("(%p, %x, %d, %ld)\n", hWndIME, msg, wParam, lParam);
+    TRACE("(%p, %x, %ld, %ld)\n", hWndIME, msg, wParam, lParam);
     if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
         (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
         (msg == WM_MSIME_SERVICE) ||
@@ -1052,7 +1353,7 @@
   HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
 {
     BOOL rc = FALSE;
-    TRACE("(%p, %d, %d, %ld): stub\n", hWndIME, msg, wParam, lParam);
+    TRACE("(%p, %d, %ld, %ld): stub\n", hWndIME, msg, wParam, lParam);
     if ((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
         (msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP) ||
         (msg == WM_MSIME_SERVICE) ||
@@ -1093,56 +1394,60 @@
             {
                 case CPS_CANCEL:
                     TRACE("%s -
%s\n","NI_COMPOSITIONSTR","CPS_CANCEL");
-                    if (pX11DRV_ForceXIMReset)
-                        pX11DRV_ForceXIMReset(root_context->hwnd);
-                    if (root_context->dwCompStringSize)
                     {
-                        HeapFree(GetProcessHeap(),0,
-                                 root_context->CompositionString);
-                        root_context->dwCompStringSize = 0;
-                        root_context->dwCompStringLength = 0;
-                        root_context->CompositionString = NULL;
+                        HIMCC newCompStr;
+                        if (pX11DRV_ForceXIMReset)
+                            pX11DRV_ForceXIMReset(root_context->IMC.hWnd);
+
+                        newCompStr = updateCompStr(root_context->IMC.hCompStr, NULL,
0);
+                        ImmDestroyIMCC(root_context->IMC.hCompStr);
+                        root_context->IMC.hCompStr = newCompStr;
+
                         ImmInternalPostIMEMessage(WM_IME_COMPOSITION, 0,
                                                   GCS_COMPSTR);
+                        rc = TRUE;
                     }
-                    rc = TRUE;
                     break;
                 case CPS_COMPLETE:
                     TRACE("%s -
%s\n","NI_COMPOSITIONSTR","CPS_COMPLETE");
                     if (hIMC != (HIMC)FROM_IME && pX11DRV_ForceXIMReset)
-                        pX11DRV_ForceXIMReset(root_context->hwnd);
-
-                    if (root_context->dwResultStringSize)
+                        pX11DRV_ForceXIMReset(root_context->IMC.hWnd);
                     {
-                        HeapFree(GetProcessHeap(),0,root_context->ResultString);
-                        root_context->dwResultStringSize = 0;
-                        root_context->ResultString = NULL;
-                    }
-                    if (root_context->dwCompStringLength)
-                    {
-                        root_context->ResultString = HeapAlloc(
-                        GetProcessHeap(), 0, root_context->dwCompStringLength);
-                        root_context->dwResultStringSize =
-                                        root_context->dwCompStringLength;
-
-                        memcpy(root_context->ResultString,
-                               root_context->CompositionString,
-                               root_context->dwCompStringLength);
-
-                        HeapFree(GetProcessHeap(),0,
-                                 root_context->CompositionString);
-
-                        root_context->dwCompStringSize = 0;
-                        root_context->dwCompStringLength = 0;
-                        root_context->CompositionString = NULL;
-                        root_context->bRead = FALSE;
-
-                        ImmInternalPostIMEMessage(WM_IME_COMPOSITION, 0,
+                        HIMCC newCompStr;
+                        DWORD cplen;
+                        LPWSTR cpstr;
+                        LPCOMPOSITIONSTRING cs = NULL;
+                        LPBYTE cdata = NULL;
+
+                        /* clear existing result */
+                        newCompStr = updateResultStr(root_context->IMC.hCompStr, NULL,
0);
+                        ImmDestroyIMCC(root_context->IMC.hCompStr);
+                        root_context->IMC.hCompStr = newCompStr;
+
+                        cdata = ImmLockIMCC(root_context->IMC.hCompStr);
+                        cs = (LPCOMPOSITIONSTRING)cdata;
+                        cplen = cs->dwCompStrLen;
+                        cpstr = (LPWSTR)&(cdata[cs->dwCompStrOffset]);
+                        ImmUnlockIMCC(root_context->IMC.hCompStr);
+                        if (cplen > 0)
+                        {
+                            WCHAR param = cpstr[0];
+                            newCompStr = updateResultStr(root_context->IMC.hCompStr,
cpstr, cplen);
+                            ImmDestroyIMCC(root_context->IMC.hCompStr);
+                            root_context->IMC.hCompStr = newCompStr;
+                            newCompStr = updateCompStr(root_context->IMC.hCompStr,
NULL, 0);
+                            ImmDestroyIMCC(root_context->IMC.hCompStr);
+                            root_context->IMC.hCompStr = newCompStr;
+
+                            root_context->bRead = FALSE;
+
+                            ImmInternalPostIMEMessage(WM_IME_COMPOSITION, 0,
                                                   GCS_COMPSTR);
 
-                        ImmInternalPostIMEMessage(WM_IME_COMPOSITION,
-                                            root_context->ResultString[0],
+                            ImmInternalPostIMEMessage(WM_IME_COMPOSITION,
+                                            param,
                                             GCS_RESULTSTR|GCS_RESULTCLAUSE);
+                        }
 
                         ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION, 0, 0);
                         root_context->bInComposition = FALSE;
@@ -1177,7 +1482,7 @@
         default:
             ERR("Unknown\n");
     }
-  
+
     return rc;
 }
 
@@ -1239,8 +1544,8 @@
     if (!data)
         return FALSE;
 
-    memcpy(&data->font,lplf,sizeof(LOGFONTA));
-    MultiByteToWideChar(CP_ACP, 0, lplf->lfFaceName, -1, data->font.lfFaceName,
+    memcpy(&data->IMC.lfFont.W,lplf,sizeof(LOGFONTA));
+    MultiByteToWideChar(CP_ACP, 0, lplf->lfFaceName, -1,
data->IMC.lfFont.W.lfFaceName,
                         LF_FACESIZE);
 
     ImmInternalSendIMENotify(IMN_SETCOMPOSITIONFONT, 0);
@@ -1251,7 +1556,7 @@
         data->textfont = NULL;
     }
 
-    data->textfont = CreateFontIndirectW(&data->font); 
+    data->textfont = CreateFontIndirectW(&data->IMC.lfFont.W);
     return TRUE;
 }
 
@@ -1266,7 +1571,7 @@
     if (!data)
         return FALSE;
 
-    memcpy(&data->font,lplf,sizeof(LOGFONTW));
+    memcpy(&data->IMC.lfFont.W,lplf,sizeof(LOGFONTW));
     ImmInternalSendIMENotify(IMN_SETCOMPOSITIONFONT, 0);
 
     if (data->textfont)
@@ -1274,7 +1579,7 @@
         DeleteObject(data->textfont);
         data->textfont = NULL;
     }
-    data->textfont = CreateFontIndirectW(&data->font); 
+    data->textfont = CreateFontIndirectW(&data->IMC.lfFont.W);
     return TRUE;
 }
 
@@ -1353,35 +1658,33 @@
 
     if (dwIndex == SCS_SETSTR)
     {
-	if (!root_context->bInComposition)
-	{
+        HIMCC newCompStr;
+        if (!root_context->bInComposition)
+        {
             ImmInternalPostIMEMessage(WM_IME_STARTCOMPOSITION, 0, 0);
             root_context->bInComposition = TRUE;
-	}
-
-         flags = GCS_COMPSTR;
-
-         if (root_context->dwCompStringLength)
-             HeapFree(GetProcessHeap(),0,root_context->CompositionString);
-
-         root_context->dwCompStringLength = dwCompLen;
-         root_context->dwCompStringSize = dwCompLen;
-
-         if (dwCompLen && lpComp)
-         {
-             root_context->CompositionString = HeapAlloc(GetProcessHeap(), 0,
-                                                     dwCompLen);
-             memcpy(root_context->CompositionString,lpComp,dwCompLen);
+        }
+
+        flags = GCS_COMPSTR;
+
+        if (dwCompLen && lpComp)
+        {
+            newCompStr = updateCompStr(root_context->IMC.hCompStr, (LPWSTR)lpComp,
dwCompLen / sizeof(WCHAR));
+            ImmDestroyIMCC(root_context->IMC.hCompStr);
+            root_context->IMC.hCompStr = newCompStr;
 
              wParam = ((const WCHAR*)lpComp)[0];
-             flags |= GCS_COMPCLAUSE | GCS_COMPATTR;
-         }
-         else
-             root_context->CompositionString = NULL;
-
-    }
-
-     UpdateDataInDefaultIMEWindow(hwndDefault);
+             flags |= GCS_COMPCLAUSE | GCS_COMPATTR | GCS_DELTASTART;
+        }
+        else
+        {
+            newCompStr = updateCompStr(root_context->IMC.hCompStr, NULL, 0);
+            ImmDestroyIMCC(root_context->IMC.hCompStr);
+            root_context->IMC.hCompStr = newCompStr;
+        }
+    }
+
+     UpdateDataInDefaultIMEWindow(hwndDefault,FALSE);
 
      ImmInternalPostIMEMessage(WM_IME_COMPOSITION, wParam, flags);
 
@@ -1405,7 +1708,7 @@
     if (!data)
         return FALSE;
 
-    memcpy(&data->CompForm,lpCompForm,sizeof(COMPOSITIONFORM));
+    memcpy(&data->IMC.cfCompForm,lpCompForm,sizeof(COMPOSITIONFORM));
 
     if (IsWindowVisible(hwndDefault))
     {
@@ -1457,7 +1760,7 @@
     if (fOpen != data->bInternalState)
     {
         if (fOpen == FALSE && pX11DRV_ForceXIMReset)
-            pX11DRV_ForceXIMReset(data->hwnd);
+            pX11DRV_ForceXIMReset(data->IMC.hWnd);
 
         if (fOpen == FALSE)
             ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION,0,0);
@@ -1467,7 +1770,7 @@
         ImmInternalSetOpenStatus(fOpen);
         ImmInternalSetOpenStatus(!fOpen);
 
-        if (data->bOpen == FALSE)
+        if (data->IMC.fOpen == FALSE)
             ImmInternalPostIMEMessage(WM_IME_ENDCOMPOSITION,0,0);
         else
             ImmInternalPostIMEMessage(WM_IME_STARTCOMPOSITION,0,0);
@@ -1547,6 +1850,125 @@
   return 0;
 }
 
+/***********************************************************************
+*		ImmLockIMC(IMM32.@)
+*/
+LPINPUTCONTEXT WINAPI ImmLockIMC(HIMC hIMC)
+{
+    InputContextData *data = (InputContextData*)hIMC;
+
+    if (!data)
+        return NULL;
+    data->dwLock++;
+    return &data->IMC;
+}
+
+/***********************************************************************
+*		ImmUnlockIMC(IMM32.@)
+*/
+BOOL WINAPI ImmUnlockIMC(HIMC hIMC)
+{
+    InputContextData *data = (InputContextData*)hIMC;
+    data->dwLock--;
+    return (data->dwLock!=0);
+}
+
+/***********************************************************************
+*		ImmGetIMCLockCount(IMM32.@)
+*/
+DWORD WINAPI ImmGetIMCLockCount(HIMC hIMC)
+{
+    InputContextData *data = (InputContextData*)hIMC;
+    return data->dwLock;
+}
+
+/***********************************************************************
+*		ImmCreateIMCC(IMM32.@)
+*/
+HIMCC  WINAPI ImmCreateIMCC(DWORD size)
+{
+    IMCCInternal *internal;
+    int real_size = size + sizeof(IMCCInternal);
+
+    internal = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, real_size);
+    if (internal == NULL)
+        return NULL;
+
+    internal->dwSize = size;
+    return  (HIMCC)internal;
+}
+
+/***********************************************************************
+*       ImmDestroyIMCC(IMM32.@)
+*/
+HIMCC WINAPI ImmDestroyIMCC(HIMCC block)
+{
+    HeapFree(GetProcessHeap(),0,block);
+    return NULL;
+}
+
+/***********************************************************************
+*		ImmLockIMCC(IMM32.@)
+*/
+LPVOID WINAPI ImmLockIMCC(HIMCC imcc)
+{
+    IMCCInternal *internal;
+    internal = (IMCCInternal*) imcc;
+
+    internal->dwLock ++;
+    return internal + 1;
+}
+
+/***********************************************************************
+*		ImmUnlockIMCC(IMM32.@)
+*/
+BOOL WINAPI ImmUnlockIMCC(HIMCC imcc)
+{
+    IMCCInternal *internal;
+    internal = (IMCCInternal*) imcc;
+
+    internal->dwLock --;
+    return (internal->dwLock!=0);
+}
+
+/***********************************************************************
+*		ImmGetIMCCLockCount(IMM32.@)
+*/
+DWORD WINAPI ImmGetIMCCLockCount(HIMCC imcc)
+{
+    IMCCInternal *internal;
+    internal = (IMCCInternal*) imcc;
+
+    return internal->dwLock;
+}
+
+/***********************************************************************
+*		ImmReSizeIMCC(IMM32.@)
+*/
+HIMCC  WINAPI ImmReSizeIMCC(HIMCC imcc, DWORD size)
+{
+    IMCCInternal *internal,*newone;
+    int real_size = size + sizeof(IMCCInternal);
+
+    internal = (IMCCInternal*) imcc;
+
+    newone = HeapReAlloc(GetProcessHeap(), 0, internal, real_size);
+    newone->dwSize = size;
+
+    return newone;
+}
+
+/***********************************************************************
+*		ImmGetIMCCSize(IMM32.@)
+*/
+DWORD WINAPI ImmGetIMCCSize(HIMCC imcc)
+{
+    IMCCInternal *internal;
+    internal = (IMCCInternal*) imcc;
+
+    return internal->dwSize;
+}
+
 /*****
  * Internal functions to help with IME window management
  */
@@ -1555,69 +1977,137 @@
     PAINTSTRUCT ps;
     RECT rect;
     HDC hdc = BeginPaint(hwnd,&ps);
+    LPCOMPOSITIONSTRING compstr;
+    LPBYTE compdata = NULL;
+    HMONITOR monitor;
+    MONITORINFO mon_info;
+    INT offX=0, offY=0;
+
     GetClientRect(hwnd,&rect);
     FillRect(hdc, &rect, (HBRUSH)(COLOR_WINDOW + 1));
 
-    if (root_context->dwCompStringLength &&
root_context->CompositionString)
+    compdata = ImmLockIMCC(root_context->IMC.hCompStr);
+    compstr = (LPCOMPOSITIONSTRING)compdata;
+
+    if (compstr->dwCompStrLen && compstr->dwCompStrOffset)
     {
         SIZE size;
         POINT pt;
         HFONT oldfont = NULL;
-
+        LPWSTR CompString;
+
+        CompString = (LPWSTR)(compdata + compstr->dwCompStrOffset);
         if (root_context->textfont)
             oldfont = SelectObject(hdc,root_context->textfont);
 
 
-        GetTextExtentPoint32W(hdc, (LPWSTR)root_context->CompositionString,
-                              root_context->dwCompStringLength / sizeof(WCHAR),
-                              &size);
+        GetTextExtentPoint32W(hdc, CompString, compstr->dwCompStrLen, &size);
         pt.x = size.cx;
         pt.y = size.cy;
         LPtoDP(hdc,&pt,1);
 
-        if (root_context->CompForm.dwStyle == CFS_POINT ||
-            root_context->CompForm.dwStyle == CFS_FORCE_POSITION)
+        /*
+         * How this works based on tests on windows:
+         * CFS_POINT: then we start our window at the point and grow it as large
+         *    as it needs to be for the string.
+         * CFS_RECT:  we still use the ptCurrentPos as a starting point and our
+         *    window is only as large as we need for the string, but we do not
+         *    grow such that our window exceeds the given rect.  Wrapping if
+         *    needed and possible.   If our ptCurrentPos is outside of our rect
+         *    then no window is displayed.
+         * CFS_FORCE_POSITION: appears to behave just like CFS_POINT
+         *    maybe becase the default MSIME does not do any IME adjusting.
+         */
+        if (root_context->IMC.cfCompForm.dwStyle != CFS_DEFAULT)
         {
-            POINT cpt = root_context->CompForm.ptCurrentPos;
-            ClientToScreen(root_context->hwnd,&cpt);
+            POINT cpt = root_context->IMC.cfCompForm.ptCurrentPos;
+            ClientToScreen(root_context->IMC.hWnd,&cpt);
             rect.left = cpt.x;
             rect.top = cpt.y;
+            rect.right = rect.left + pt.x;
+            rect.bottom = rect.top + pt.y;
+            offX=offY=10;
+            monitor = MonitorFromPoint(cpt, MONITOR_DEFAULTTOPRIMARY);
+        }
+        else /* CFS_DEFAULT */
+        {
+            /* Windows places the default IME window in the bottom left */
+            HWND target = root_context->IMC.hWnd;
+            if (!target) target = GetFocus();
+
+            GetWindowRect(target,&rect);
+            rect.top = rect.bottom;
             rect.right = rect.left + pt.x + 20;
             rect.bottom = rect.top + pt.y + 20;
+            offX=offY=10;
+            monitor = MonitorFromWindow(target, MONITOR_DEFAULTTOPRIMARY);
         }
-        else if (root_context->CompForm.dwStyle == CFS_RECT)
+
+        if (root_context->IMC.cfCompForm.dwStyle == CFS_RECT)
         {
-            POINT cpt;
-            cpt.x = root_context->CompForm.rcArea.left;
-            cpt.y = root_context->CompForm.rcArea.top;
-            ClientToScreen(root_context->hwnd,&cpt);
-            rect.left = cpt.x;
-            rect.top = cpt.y;
-            cpt.x = root_context->CompForm.rcArea.right;
-            cpt.y = root_context->CompForm.rcArea.bottom;
-            ClientToScreen(root_context->hwnd,&cpt);
-            rect.right = cpt.x;
-            rect.bottom = cpt.y;
+            RECT client;
+            client =root_context->IMC.cfCompForm.rcArea;
+            MapWindowPoints( root_context->IMC.hWnd, 0, (POINT *)&client, 2 );
+            IntersectRect(&rect,&rect,&client);
+            /* TODO:  Wrap the input if needed */
         }
-        else
+
+        if (root_context->IMC.cfCompForm.dwStyle == CFS_DEFAULT)
         {
-            rect.right = rect.left + pt.x + 20;
-            rect.bottom = rect.top + pt.y + 20;
+            /* make sure we are on the desktop */
+            mon_info.cbSize = sizeof(mon_info);
+            GetMonitorInfoW(monitor, &mon_info);
+
+            if (rect.bottom > mon_info.rcWork.bottom)
+            {
+                int shift = rect.bottom - mon_info.rcWork.bottom;
+                rect.top -= shift;
+                rect.bottom -= shift;
+            }
+            if (rect.left < 0)
+            {
+                rect.right -= rect.left;
+                rect.left = 0;
+            }
+            if (rect.right > mon_info.rcWork.right)
+            {
+                int shift = rect.right - mon_info.rcWork.right;
+                rect.left -= shift;
+                rect.right -= shift;
+            }
         }
-        MoveWindow(hwnd, rect.left, rect.top, rect.right - rect.left ,
-                   rect.bottom - rect.top, FALSE);
-        TextOutW(hdc, 10,10,(LPWSTR)root_context->CompositionString,
-                 root_context->dwCompStringLength / sizeof(WCHAR));
+
+        SetWindowPos(hwnd, HWND_TOPMOST, rect.left, rect.top, rect.right - rect.left,
rect.bottom - rect.top, SWP_NOACTIVATE);
+
+        TextOutW(hdc, offX,offY, CompString, compstr->dwCompStrLen);
 
         if (oldfont)
             SelectObject(hdc,oldfont);
     }
+
+    ImmUnlockIMCC(root_context->IMC.hCompStr);
+
     EndPaint(hwnd,&ps);
 }
 
-static void UpdateDataInDefaultIMEWindow(HWND hwnd)
-{
+static void UpdateDataInDefaultIMEWindow(HWND hwnd, BOOL showable)
+{
+    LPCOMPOSITIONSTRING compstr;
+
+    if (root_context->IMC.hCompStr)
+        compstr = ImmLockIMCC(root_context->IMC.hCompStr);
+    else
+        compstr = NULL;
+
+    if (compstr == NULL || compstr->dwCompStrLen == 0)
+        ShowWindow(hwndDefault,SW_HIDE);
+    else if (showable)
+        ShowWindow(hwndDefault,SW_SHOWNOACTIVATE);
+
     RedrawWindow(hwnd,NULL,NULL,RDW_ERASENOW|RDW_INVALIDATE);
+
+    if (compstr != NULL)
+        ImmUnlockIMCC(root_context->IMC.hCompStr);
 }
 
 /*
@@ -1657,12 +2147,12 @@
             if (lParam & GCS_RESULTSTR)
                     IMM_PostResult(root_context);
             else
-                 UpdateDataInDefaultIMEWindow(hwnd);
+                 UpdateDataInDefaultIMEWindow(hwnd,TRUE);
             break;
         case WM_IME_STARTCOMPOSITION:
             TRACE("IME message %s, 0x%x, 0x%x\n",
                     "WM_IME_STARTCOMPOSITION", (UINT)wParam, (UINT)lParam);
-            root_context->hwnd = GetFocus();
+            root_context->IMC.hWnd = GetFocus();
             ShowWindow(hwndDefault,SW_SHOWNOACTIVATE);
             break;
         case WM_IME_ENDCOMPOSITION:
@@ -1677,7 +2167,7 @@
         case WM_IME_CONTROL:
             TRACE("IME message %s, 0x%x, 0x%x\n","WM_IME_CONTROL",
                 (UINT)wParam, (UINT)lParam);
-            rc = 1; 
+            rc = 1;
             break;
         case WM_IME_NOTIFY:
             TRACE("!! IME NOTIFY\n");

Modified: trunk/reactos/dll/win32/imm32/imm32.rbuild
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/imm32/imm32.rbui…
==============================================================================
--- trunk/reactos/dll/win32/imm32/imm32.rbuild (original)
+++ trunk/reactos/dll/win32/imm32/imm32.rbuild Fri Sep 14 12:03:04 2007
@@ -1,4 +1,4 @@
-<module name="imm32" type="win32dll"
baseaddress="${BASEADDRESS_IMM32}" installbase="system32"
installname="imm32.dll" allowwarnings="true">
+<module name="imm32" type="win32dll"
baseaddress="${BASEADDRESS_IMM32}" installbase="system32"
installname="imm32.dll" allowwarnings="true"
entrypoint="0">
 	<importlibrary definition="imm32.spec.def" />
 	<include base="imm32">.</include>
 	<include base="ReactOS">include/reactos/wine</include>

Modified: trunk/reactos/dll/win32/imm32/imm32.spec
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/imm32/imm32.spec…
==============================================================================
--- trunk/reactos/dll/win32/imm32/imm32.spec (original)
+++ trunk/reactos/dll/win32/imm32/imm32.spec Fri Sep 14 12:03:04 2007
@@ -4,10 +4,10 @@
 @ stdcall ImmConfigureIMEA(long long long ptr)
 @ stdcall ImmConfigureIMEW(long long long ptr)
 @ stdcall ImmCreateContext()
-@ stub ImmCreateIMCC
+@ stdcall ImmCreateIMCC(long)
 @ stub ImmCreateSoftKeyboard
 @ stdcall ImmDestroyContext(long)
-@ stub ImmDestroyIMCC
+@ stdcall ImmDestroyIMCC(long)
 @ stub ImmDestroySoftKeyboard
 @ stdcall ImmDisableIME(long)
 @ stub ImmDisableIme
@@ -39,9 +39,9 @@
 @ stdcall ImmGetGuideLineA(long long ptr long)
 @ stdcall ImmGetGuideLineW(long long ptr long)
 @ stub ImmGetHotKey
-@ stub ImmGetIMCCLockCount
-@ stub ImmGetIMCCSize
-@ stub ImmGetIMCLockCount
+@ stdcall ImmGetIMCCLockCount(long)
+@ stdcall ImmGetIMCCSize(long)
+@ stdcall ImmGetIMCLockCount(long)
 @ stdcall ImmGetIMEFileNameA(long ptr long)
 @ stdcall ImmGetIMEFileNameW(long ptr long)
 @ stub ImmGetImeInfoEx
@@ -67,14 +67,14 @@
 @ stub ImmLoadIME
 @ stub ImmLoadLayout
 @ stub ImmLockClientImc
-@ stub ImmLockIMC
-@ stub ImmLockIMCC
+@ stdcall ImmLockIMC(long)
+@ stdcall ImmLockIMCC(long)
 @ stub ImmLockImeDpi
 @ stdcall ImmNotifyIME(long long long long)
 @ stub ImmPenAuxInput
 @ stub ImmProcessKey
 @ stub ImmPutImeMenuItemsIntoMappedFile
-@ stub ImmReSizeIMCC
+@ stdcall ImmReSizeIMCC(long long)
 @ stub ImmRegisterClient
 @ stdcall ImmRegisterWordA(long str long str)
 @ stdcall ImmRegisterWordW(long wstr long wstr)
@@ -101,8 +101,8 @@
 @ stub ImmSystemHandler
 @ stub ImmTranslateMessage
 @ stub ImmUnlockClientImc
-@ stub ImmUnlockIMC
-@ stub ImmUnlockIMCC
+@ stdcall ImmUnlockIMC(long)
+@ stdcall ImmUnlockIMCC(long)
 @ stub ImmUnlockImeDpi
 @ stdcall ImmUnregisterWordA(long str long str)
 @ stdcall ImmUnregisterWordW(long wstr long wstr)