Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-02 02:34:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

- Sync mscms, mscoree, msctf with Wine

Browse source 
- Remove unneeded mscoree_ros.diff

svn path=/trunk/; revision=40399
This commit is contained in:
Dmitry Chapyshev 2009-04-06 15:43:12 +00:00
parent 9854f20f1c
commit 4147173032
8 changed files with 298 additions and 19 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
reactos/dll/win32/mscms/mscms_main.c
View file

@ -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

2
reactos/dll/win32/mscoree/mscoree.rbuild
View file

@ -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>

2
reactos/dll/win32/mscoree/mscoree.spec
View file

@ -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)

8
reactos/dll/win32/mscoree/mscoree_main.c
View file

@ -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);

11
reactos/dll/win32/mscoree/mscoree_ros.diff
View file

@ -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;

20
reactos/dll/win32/msctf/documentmgr.c
View file

@ -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;

2
reactos/dll/win32/msctf/msctf_internal.h
View file

@ -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);

252
reactos/dll/win32/msctf/threadmgr.c
View file

@ -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);
return E_NOTIMPL;
TRACE("(%p) %x\n",This,pdwCookie);
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;