- Sync mscms, mscoree, msctf with Wine

- Remove unneeded mscoree_ros.diff

svn path=/trunk/; revision=40399

reactos/dll/win32/mscms/mscms_main.c

@@ -36,6 +36,23 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(mscms);
 
+#ifdef HAVE_LCMS
+static int lcms_error_handler( int error, const char *text )
+{
+    switch (error)
+    {
+    case LCMS_ERRC_WARNING:
+    case LCMS_ERRC_RECOVERABLE:
+    case LCMS_ERRC_ABORTED:
+        WARN("%d %s\n", error, debugstr_a(text));
+        return 1;
+    default:
+        ERR("unknown error %d %s\n", error, debugstr_a(text));
+        return 0;
+    }
+}
+#endif
+
 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
 {
     TRACE( "(%p, %d, %p)\n", hinst, reason, reserved );
@@ -44,6 +61,9 @@ BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
     {
     case DLL_PROCESS_ATTACH:
         DisableThreadLibraryCalls( hinst );
+#ifdef HAVE_LCMS
+        cmsSetErrorHandler( lcms_error_handler );
+#endif
         break;
     case DLL_PROCESS_DETACH:
 #ifdef HAVE_LCMS

reactos/dll/win32/mscoree/mscoree.rbuild

@@ -1,6 +1,8 @@
 <module name="mscoree" type="win32dll" baseaddress="${BASEADDRESS_MSCOREE}" installbase="system32" installname="mscoree.dll">
 	<importlibrary definition="mscoree.spec" />
 	<include base="mscoree">.</include>
+	<include base="ReactOS">include/reactos/wine</include>
+	<define name="__WINESRC__" />
 	<library>wine</library>
 	<library>kernel32</library>
 	<library>advapi32</library>

reactos/dll/win32/mscoree/mscoree.spec

@@ -70,7 +70,7 @@
 @ stdcall LoadLibraryShim(ptr ptr ptr ptr)
 @ stub LoadLibraryWithPolicyShim
 @ stdcall LoadStringRCEx(long long ptr long long ptr)
-@ stub LockClrVersion
+@ stdcall LockClrVersion(ptr ptr ptr)
 @ stub MetaDataGetDispenser
 @ stdcall ND_CopyObjDst(ptr ptr long long)
 @ stdcall ND_CopyObjSrc(ptr long ptr long)

reactos/dll/win32/mscoree/mscoree_main.c

@@ -112,6 +112,8 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 
     switch (fdwReason)
     {
+    case DLL_WINE_PREATTACH:
+        return FALSE;  /* prefer native version */
     case DLL_PROCESS_ATTACH:
         DisableThreadLibraryCalls(hinstDLL);
         break;
@@ -255,6 +257,12 @@ HRESULT WINAPI LoadLibraryShim( LPCWSTR szDllName, LPCWSTR szVersion, LPVOID pvR
     return S_OK;
 }
 
+HRESULT WINAPI LockClrVersion(FLockClrVersionCallback hostCallback, FLockClrVersionCallback *pBeginHostSetup, FLockClrVersionCallback *pEndHostSetup)
+{
+    FIXME("(%p %p %p): stub\n", hostCallback, pBeginHostSetup, pEndHostSetup);
+    return S_OK;
+}
+
 HRESULT WINAPI CoInitializeCor(DWORD fFlags)
 {
     FIXME("(0x%08x): stub\n", fFlags);

reactos/dll/win32/mscoree/mscoree_ros.diff

@@ -1,11 +0,0 @@
---- mscoree_main.c	Tue Jun 10 13:29:52 2008
-+++ mscoree_main.c	Sun Sep 07 16:53:09 2008
-@@ -112,8 +112,6 @@
- 
-     switch (fdwReason)
-     {
--    case DLL_WINE_PREATTACH:
--        return FALSE;  /* prefer native version */
-     case DLL_PROCESS_ATTACH:
-         DisableThreadLibraryCalls(hinstDLL);
-         break;

reactos/dll/win32/msctf/documentmgr.c

@@ -46,6 +46,7 @@ typedef struct tagDocumentMgr {
     LONG refCount;
 
     ITfContext*  contextStack[2]; /* limit of 2 contexts */
+    ITfThreadMgrEventSink* ThreadMgrSink;
 } DocumentMgr;
 
 static inline DocumentMgr *impl_from_ITfSourceVtbl(ITfSource *iface)
@@ -130,9 +131,14 @@ static HRESULT WINAPI DocumentMgr_Push(ITfDocumentMgr *iface, ITfContext *pic)
     if (!pic || FAILED(IUnknown_QueryInterface(pic,&IID_ITfContext,(LPVOID*) &check)))
         return E_INVALIDARG;
 
+    if (This->contextStack[0] == NULL)
+        ITfThreadMgrEventSink_OnInitDocumentMgr(This->ThreadMgrSink,iface);
+
     This->contextStack[1] = This->contextStack[0];
     This->contextStack[0] = check;
 
+    ITfThreadMgrEventSink_OnPushContext(This->ThreadMgrSink,check);
+
     return S_OK;
 }
 
@@ -144,10 +150,17 @@ static HRESULT WINAPI DocumentMgr_Pop(ITfDocumentMgr *iface, DWORD dwFlags)
     if (dwFlags == TF_POPF_ALL)
     {
         if (This->contextStack[0])
+        {
+            ITfThreadMgrEventSink_OnPopContext(This->ThreadMgrSink,This->contextStack[0]);
             ITfContext_Release(This->contextStack[0]);
+        }
         if (This->contextStack[1])
+        {
+            ITfThreadMgrEventSink_OnPopContext(This->ThreadMgrSink,This->contextStack[1]);
             ITfContext_Release(This->contextStack[1]);
+        }
         This->contextStack[0] = This->contextStack[1] = NULL;
+        ITfThreadMgrEventSink_OnUninitDocumentMgr(This->ThreadMgrSink, iface);
         return S_OK;
     }
 
@@ -157,10 +170,14 @@ static HRESULT WINAPI DocumentMgr_Pop(ITfDocumentMgr *iface, DWORD dwFlags)
     if (This->contextStack[0] == NULL) /* Cannot pop last context */
         return E_FAIL;
 
+    ITfThreadMgrEventSink_OnPopContext(This->ThreadMgrSink,This->contextStack[0]);
     ITfContext_Release(This->contextStack[0]);
     This->contextStack[0] = This->contextStack[1];
     This->contextStack[1] = NULL;
 
+    if (This->contextStack[0] == NULL)
+        ITfThreadMgrEventSink_OnUninitDocumentMgr(This->ThreadMgrSink, iface);
+
     return S_OK;
 }
 
@@ -262,7 +279,7 @@ static const ITfSourceVtbl DocumentMgr_SourceVtbl =
     DocumentMgrSource_UnadviseSink,
 };
 
-HRESULT DocumentMgr_Constructor(ITfDocumentMgr **ppOut)
+HRESULT DocumentMgr_Constructor(ITfThreadMgrEventSink *ThreadMgrSink, ITfDocumentMgr **ppOut)
 {
     DocumentMgr *This;
 
@@ -273,6 +290,7 @@ HRESULT DocumentMgr_Constructor(ITfDocumentMgr **ppOut)
     This->DocumentMgrVtbl= &DocumentMgr_DocumentMgrVtbl;
     This->SourceVtbl = &DocumentMgr_SourceVtbl;
     This->refCount = 1;
+    This->ThreadMgrSink = ThreadMgrSink;
 
     TRACE("returning %p\n", This);
     *ppOut = (ITfDocumentMgr*)This;

reactos/dll/win32/msctf/msctf_internal.h

@@ -23,7 +23,7 @@
 extern DWORD tlsIndex;
 
 extern HRESULT ThreadMgr_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut);
-extern HRESULT DocumentMgr_Constructor(ITfDocumentMgr **ppOut);
+extern HRESULT DocumentMgr_Constructor(ITfThreadMgrEventSink*, ITfDocumentMgr **ppOut);
 extern HRESULT Context_Constructor(TfClientId tidOwner, IUnknown *punk, ITfContext **ppOut, TfEditCookie *pecTextStore);
 extern HRESULT InputProcessorProfiles_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut);
 extern HRESULT CategoryMgr_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut);

reactos/dll/win32/msctf/threadmgr.c

@@ -32,20 +32,46 @@
 #include "shlwapi.h"
 #include "winerror.h"
 #include "objbase.h"
+#include "olectl.h"
 
 #include "wine/unicode.h"
+#include "wine/list.h"
 
 #include "msctf.h"
 #include "msctf_internal.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(msctf);
 
+typedef struct tagThreadMgrSink {
+    struct list         entry;
+    union {
+        /* ThreadMgr Sinks */
+        IUnknown            *pIUnknown;
+        /* ITfActiveLanguageProfileNotifySink *pITfActiveLanguageProfileNotifySink; */
+        /* ITfDisplayAttributeNotifySink *pITfDisplayAttributeNotifySink; */
+        /* ITfKeyTraceEventSink *pITfKeyTraceEventSink; */
+        /* ITfPreservedKeyNotifySink *pITfPreservedKeyNotifySink; */
+        /* ITfThreadFocusSink *pITfThreadFocusSink; */
+        ITfThreadMgrEventSink *pITfThreadMgrEventSink;
+    } interfaces;
+} ThreadMgrSink;
+
 typedef struct tagACLMulti {
     const ITfThreadMgrVtbl *ThreadMgrVtbl;
     const ITfSourceVtbl *SourceVtbl;
     LONG refCount;
 
+    const ITfThreadMgrEventSinkVtbl *ThreadMgrEventSinkVtbl; /* internal */
+
     ITfDocumentMgr *focus;
+
+    /* kept as separate lists to reduce unnecessary iterations */
+    struct list     ActiveLanguageProfileNotifySink;
+    struct list     DisplayAttributeNotifySink;
+    struct list     KeyTraceEventSink;
+    struct list     PreservedKeyNotifySink;
+    struct list     ThreadFocusSink;
+    struct list     ThreadMgrEventSink;
 } ThreadMgr;
 
 static inline ThreadMgr *impl_from_ITfSourceVtbl(ITfSource *iface)
@@ -53,12 +79,64 @@ static inline ThreadMgr *impl_from_ITfSourceVtbl(ITfSource *iface)
     return (ThreadMgr *)((char *)iface - FIELD_OFFSET(ThreadMgr,SourceVtbl));
 }
 
+static inline ThreadMgr *impl_from_ITfThreadMgrEventSink(ITfThreadMgrEventSink *iface)
+{
+    return (ThreadMgr *)((char *)iface - FIELD_OFFSET(ThreadMgr,ThreadMgrEventSinkVtbl));
+}
+
+static void free_sink(ThreadMgrSink *sink)
+{
+        IUnknown_Release(sink->interfaces.pIUnknown);
+        HeapFree(GetProcessHeap(),0,sink);
+}
+
 static void ThreadMgr_Destructor(ThreadMgr *This)
 {
+    struct list *cursor, *cursor2;
+
     TlsSetValue(tlsIndex,NULL);
     TRACE("destroying %p\n", This);
     if (This->focus)
         ITfDocumentMgr_Release(This->focus);
+
+    /* free sinks */
+    LIST_FOR_EACH_SAFE(cursor, cursor2, &This->ActiveLanguageProfileNotifySink)
+    {
+        ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+        list_remove(cursor);
+        free_sink(sink);
+    }
+    LIST_FOR_EACH_SAFE(cursor, cursor2, &This->DisplayAttributeNotifySink)
+    {
+        ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+        list_remove(cursor);
+        free_sink(sink);
+    }
+    LIST_FOR_EACH_SAFE(cursor, cursor2, &This->KeyTraceEventSink)
+    {
+        ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+        list_remove(cursor);
+        free_sink(sink);
+    }
+    LIST_FOR_EACH_SAFE(cursor, cursor2, &This->PreservedKeyNotifySink)
+    {
+        ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+        list_remove(cursor);
+        free_sink(sink);
+    }
+    LIST_FOR_EACH_SAFE(cursor, cursor2, &This->ThreadFocusSink)
+    {
+        ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+        list_remove(cursor);
+        free_sink(sink);
+    }
+    LIST_FOR_EACH_SAFE(cursor, cursor2, &This->ThreadMgrEventSink)
+    {
+        ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+        list_remove(cursor);
+        free_sink(sink);
+    }
+
     HeapFree(GetProcessHeap(),0,This);
 }
 
@@ -124,8 +202,9 @@ static HRESULT WINAPI ThreadMgr_fnDeactivate( ITfThreadMgr* iface)
 static HRESULT WINAPI ThreadMgr_CreateDocumentMgr( ITfThreadMgr* iface, ITfDocumentMgr
 **ppdim)
 {
+    ThreadMgr *This = (ThreadMgr *)iface;
     TRACE("(%p)\n",iface);
-    return DocumentMgr_Constructor(ppdim);
+    return DocumentMgr_Constructor((ITfThreadMgrEventSink*)&This->ThreadMgrEventSinkVtbl, ppdim);
 }
 
 static HRESULT WINAPI ThreadMgr_EnumDocumentMgrs( ITfThreadMgr* iface, IEnumTfDocumentMgrs
@@ -167,6 +246,8 @@ static HRESULT WINAPI ThreadMgr_SetFocus( ITfThreadMgr* iface, ITfDocumentMgr *p
     if (!pdimFocus || FAILED(IUnknown_QueryInterface(pdimFocus,&IID_ITfDocumentMgr,(LPVOID*) &check)))
         return E_INVALIDARG;
 
+    ITfThreadMgrEventSink_OnSetFocus((ITfThreadMgrEventSink*)&This->ThreadMgrEventSinkVtbl, This->focus, check);
+
     if (This->focus)
         ITfDocumentMgr_Release(This->focus);
 
@@ -257,16 +338,48 @@ static ULONG WINAPI Source_Release(ITfSource *iface)
 static WINAPI HRESULT ThreadMgrSource_AdviseSink(ITfSource *iface,
         REFIID riid, IUnknown *punk, DWORD *pdwCookie)
 {
+    ThreadMgrSink *tms;
     ThreadMgr *This = impl_from_ITfSourceVtbl(iface);
-    FIXME("STUB:(%p)\n",This);
+
-    return E_NOTIMPL;
+    TRACE("(%p) %s %p %p\n",This,debugstr_guid(riid),punk,pdwCookie);
+
+    if (!riid || !punk || !pdwCookie)
+        return E_INVALIDARG;
+
+    if (IsEqualIID(riid, &IID_ITfThreadMgrEventSink))
+    {
+        tms = HeapAlloc(GetProcessHeap(),0,sizeof(ThreadMgrSink));
+        if (!tms)
+            return E_OUTOFMEMORY;
+        if (!SUCCEEDED(IUnknown_QueryInterface(punk, riid, (LPVOID*)&tms->interfaces.pITfThreadMgrEventSink)))
+        {
+            HeapFree(GetProcessHeap(),0,tms);
+            return CONNECT_E_CANNOTCONNECT;
+        }
+        list_add_head(&This->ThreadMgrEventSink,&tms->entry);
+        *pdwCookie = (DWORD)tms;
+    }
+    else
+    {
+        FIXME("(%p) Unhandled Sink: %s\n",This,debugstr_guid(riid));
+        return E_NOTIMPL;
+    }
+
+    TRACE("cookie %x\n",*pdwCookie);
+
+    return S_OK;
 }
 
 static WINAPI HRESULT ThreadMgrSource_UnadviseSink(ITfSource *iface, DWORD pdwCookie)
 {
+    ThreadMgrSink *sink = (ThreadMgrSink*)pdwCookie;
     ThreadMgr *This = impl_from_ITfSourceVtbl(iface);
-    FIXME("STUB:(%p)\n",This);
+    TRACE("(%p) %x\n",This,pdwCookie);
-    return E_NOTIMPL;
+
+    list_remove(&sink->entry);
+    free_sink(sink);
+
+    return S_OK;
 }
 
 static const ITfSourceVtbl ThreadMgr_SourceVtbl =
@@ -279,6 +392,127 @@ static const ITfSourceVtbl ThreadMgr_SourceVtbl =
     ThreadMgrSource_UnadviseSink,
 };
 
+/*****************************************************
+ * ITfThreadMgrEventSink functions  (internal)
+ *****************************************************/
+static HRESULT WINAPI ThreadMgrEventSink_QueryInterface(ITfThreadMgrEventSink *iface, REFIID iid, LPVOID *ppvOut)
+{
+    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
+    return ThreadMgr_QueryInterface((ITfThreadMgr *)This, iid, *ppvOut);
+}
+
+static ULONG WINAPI ThreadMgrEventSink_AddRef(ITfThreadMgrEventSink *iface)
+{
+    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
+    return ThreadMgr_AddRef((ITfThreadMgr*)This);
+}
+
+static ULONG WINAPI ThreadMgrEventSink_Release(ITfThreadMgrEventSink *iface)
+{
+    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
+    return ThreadMgr_Release((ITfThreadMgr *)This);
+}
+
+
+static WINAPI HRESULT ThreadMgrEventSink_OnInitDocumentMgr(
+        ITfThreadMgrEventSink *iface,ITfDocumentMgr *pdim)
+{
+    struct list *cursor;
+    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
+
+    TRACE("(%p) %p\n",This,pdim);
+
+    LIST_FOR_EACH(cursor, &This->ThreadMgrEventSink)
+    {
+        ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+        ITfThreadMgrEventSink_OnInitDocumentMgr(sink->interfaces.pITfThreadMgrEventSink,pdim);
+    }
+
+    return S_OK;
+}
+
+static WINAPI HRESULT ThreadMgrEventSink_OnUninitDocumentMgr(
+        ITfThreadMgrEventSink *iface, ITfDocumentMgr *pdim)
+{
+    struct list *cursor;
+    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
+
+    TRACE("(%p) %p\n",This,pdim);
+
+    LIST_FOR_EACH(cursor, &This->ThreadMgrEventSink)
+    {
+        ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+        ITfThreadMgrEventSink_OnUninitDocumentMgr(sink->interfaces.pITfThreadMgrEventSink,pdim);
+    }
+
+    return S_OK;
+}
+
+static WINAPI HRESULT ThreadMgrEventSink_OnSetFocus(
+        ITfThreadMgrEventSink *iface, ITfDocumentMgr *pdimFocus,
+        ITfDocumentMgr *pdimPrevFocus)
+{
+    struct list *cursor;
+    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
+
+    TRACE("(%p) %p %p\n",This,pdimFocus, pdimPrevFocus);
+
+    LIST_FOR_EACH(cursor, &This->ThreadMgrEventSink)
+    {
+        ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+        ITfThreadMgrEventSink_OnSetFocus(sink->interfaces.pITfThreadMgrEventSink, pdimFocus, pdimPrevFocus);
+    }
+
+    return S_OK;
+}
+
+static WINAPI HRESULT ThreadMgrEventSink_OnPushContext(
+        ITfThreadMgrEventSink *iface, ITfContext *pic)
+{
+    struct list *cursor;
+    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
+
+    TRACE("(%p) %p\n",This,pic);
+
+    LIST_FOR_EACH(cursor, &This->ThreadMgrEventSink)
+    {
+        ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+        ITfThreadMgrEventSink_OnPushContext(sink->interfaces.pITfThreadMgrEventSink,pic);
+    }
+
+    return S_OK;
+}
+
+static WINAPI HRESULT ThreadMgrEventSink_OnPopContext(
+        ITfThreadMgrEventSink *iface, ITfContext *pic)
+{
+    struct list *cursor;
+    ThreadMgr *This = impl_from_ITfThreadMgrEventSink(iface);
+
+    TRACE("(%p) %p\n",This,pic);
+
+    LIST_FOR_EACH(cursor, &This->ThreadMgrEventSink)
+    {
+        ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+        ITfThreadMgrEventSink_OnPopContext(sink->interfaces.pITfThreadMgrEventSink,pic);
+    }
+
+    return S_OK;
+}
+
+static const ITfThreadMgrEventSinkVtbl ThreadMgr_ThreadMgrEventSinkVtbl =
+{
+    ThreadMgrEventSink_QueryInterface,
+    ThreadMgrEventSink_AddRef,
+    ThreadMgrEventSink_Release,
+
+    ThreadMgrEventSink_OnInitDocumentMgr,
+    ThreadMgrEventSink_OnUninitDocumentMgr,
+    ThreadMgrEventSink_OnSetFocus,
+    ThreadMgrEventSink_OnPushContext,
+    ThreadMgrEventSink_OnPopContext
+};
+
 HRESULT ThreadMgr_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut)
 {
     ThreadMgr *This;
@@ -300,9 +534,17 @@ HRESULT ThreadMgr_Constructor(IUnknown *pUnkOuter, IUnknown **ppOut)
 
     This->ThreadMgrVtbl= &ThreadMgr_ThreadMgrVtbl;
     This->SourceVtbl = &ThreadMgr_SourceVtbl;
+    This->ThreadMgrEventSinkVtbl = &ThreadMgr_ThreadMgrEventSinkVtbl;
     This->refCount = 1;
     TlsSetValue(tlsIndex,This);
 
+    list_init(&This->ActiveLanguageProfileNotifySink);
+    list_init(&This->DisplayAttributeNotifySink);
+    list_init(&This->KeyTraceEventSink);
+    list_init(&This->PreservedKeyNotifySink);
+    list_init(&This->ThreadFocusSink);
+    list_init(&This->ThreadMgrEventSink);
+
     TRACE("returning %p\n", This);
     *ppOut = (IUnknown *)This;
     return S_OK;