archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/com/mobile/syncmgr/exe/msg.cpp

2409 lines
61 KiB
Raw Permalink Blame History

//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1997.
//
// File: Msg.cpp
//
// Contents: Handles messages between threads
//
// Classes: CThreadMsgProxy
//
// Notes:
//
// History: 05-Nov-97 rogerg Created.
//
//--------------------------------------------------------------------------
#include "precomp.h"
extern HINSTANCE g_hInst;
extern void UnitApplication();
// globals for handling QueryEndSession
HANDLE g_hEndSessionEvent = NULL; // created when an end session has occured.
BOOL g_fShuttingDown = FALSE; // set when application begins to shutdown.(WM_QUIT)
// global for keeping track of handler's threads. We create on Thread for each handler
// CLSID
STUBLIST *g_FirstStub = NULL; // pointer to first proxy in our list.
CRITICAL_SECTION g_StubListCriticalSection; // Critical Section to use for adding proxy
//+---------------------------------------------------------------------------
//
// Function: TerminateStub, public
//
// Synopsis: Called by proxy to terminate a Stub of the given Id.
//
// Arguments: [pStubID] - Identifies the stub.
//
// Returns: S_OK - Stub was terminated
// S_FALSE or Error - Stub either was already terminated
// or couldn't be found.
//
// Modifies:
//
// History: 17-Nov-98 rogerg Created.
//
//----------------------------------------------------------------------------
HRESULT TerminateStub(STUBLIST *pStubID)
{
HRESULT hr = E_UNEXPECTED;
STUBLIST *pStubList;
CCriticalSection cCritSect(&g_StubListCriticalSection,GetCurrentThreadId());
cCritSect.Enter();
pStubList = g_FirstStub;
while (pStubList)
{
if (pStubID == pStubList)
{
hr = pStubList->fStubTerminated ? S_FALSE : S_OK;
pStubList->fStubTerminated = TRUE;
break;
}
pStubList = pStubList->pNextStub;
}
cCritSect.Leave();
AssertSz(SUCCEEDED(hr),"Didn't find StubID on Terminate");
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: DoesStubExist, public
//
// Synopsis: Called by proxy see if Stub Exists
// or has been terminated
//
// Arguments: [pStubID] - Identifies the stub.
//
// Returns: S_OK - Stubs exists
// S_FALSE - Stub hasn't been terminated.
//
// Modifies:
//
// History: 17-Nov-98 rogerg Created.
//
//----------------------------------------------------------------------------
HRESULT DoesStubExist(STUBLIST *pStubID)
{
HRESULT hr = S_FALSE;
STUBLIST *pStubList;
CCriticalSection cCritSect(&g_StubListCriticalSection,GetCurrentThreadId());
cCritSect.Enter();
pStubList = g_FirstStub;
while (pStubList)
{
if (pStubID == pStubList)
{
// if stub has already been terminated return S_FALSE
hr = pStubList->fStubTerminated ? S_FALSE : S_OK;
break;
}
pStubList = pStubList->pNextStub;
}
cCritSect.Leave();
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CreateHandlerThread, public
//
// Synopsis: Called by client to create a new handler thread
//
// Arguments: [pThreadProxy] - on success returns a pointer to Proxy
// [hwndDlg] = hwnd of Window to associate with this proxy
//
// Returns: Appropriate status code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
HRESULT CreateHandlerThread(CThreadMsgProxy **pThreadProxy,HWND hwndDlg,
REFCLSID refClsid)
{
HRESULT hr = E_FAIL;
HANDLE hThread = NULL;
DWORD dwThreadId;
HandlerThreadArgs ThreadArgs;
STUBLIST *pStubList;
BOOL fExistingStub = FALSE;
CCriticalSection cCritSect(&g_StubListCriticalSection,GetCurrentThreadId());
*pThreadProxy = new CThreadMsgProxy();
if (NULL == *pThreadProxy)
return E_OUTOFMEMORY;
// lock the critical section and don't release it until the proxy
// has been setup.
cCritSect.Enter();
// Look to see if there is already a thread for this handler's
// clsid and if there is, reuse it, else create a new one.
pStubList = g_FirstStub;
while (pStubList)
{
if ((pStubList->clsidStub == refClsid) && (FALSE == pStubList->fStubTerminated))
{
fExistingStub = TRUE;
break;
}
pStubList = pStubList->pNextStub;
}
// if found existing proxy then addref the cRefs and init the proxy
// with the variables, else create a new one.
if (fExistingStub)
{
++(pStubList->cRefs); // bump up the cRefs
hr = (*pThreadProxy)->InitProxy(pStubList->hwndStub,
pStubList->ThreadIdStub,
pStubList->hThreadStub,
hwndDlg,
pStubList->clsidStub,
pStubList);
}
else
{
ThreadArgs.hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
if (ThreadArgs.hEvent)
{
hThread = CreateThread(NULL,0,HandlerThread,&ThreadArgs,0,&dwThreadId);
if (hThread)
{
WaitForSingleObject(ThreadArgs.hEvent,INFINITE);
hr = ThreadArgs.hr;
if (NOERROR == hr)
{
STUBLIST *pNewStub;
pNewStub = (STUBLIST*) ALLOC(sizeof(STUBLIST));
if (pNewStub)
{
pNewStub->pNextStub = NULL;
pNewStub->cRefs = 1;
pNewStub->hwndStub = ThreadArgs.hwndStub;
pNewStub->ThreadIdStub = dwThreadId;
pNewStub->hThreadStub = hThread;
pNewStub->clsidStub = refClsid;
pNewStub->fStubTerminated = FALSE;
if (NULL == g_FirstStub)
{
g_FirstStub = pNewStub;
}
else
{
pStubList = g_FirstStub;
while (pStubList->pNextStub)
{
pStubList = pStubList->pNextStub;
}
pStubList->pNextStub = pNewStub;
}
(*pThreadProxy)->InitProxy(ThreadArgs.hwndStub,dwThreadId,hThread,hwndDlg,
refClsid,pNewStub);
}
else
{
hr = E_OUTOFMEMORY;
}
}
// if failed to create thread, initproxy or add it to
// global list, then bail
if (NOERROR != hr)
{
CloseHandle(hThread);
}
}
else
{
hr = GetLastError();
}
CloseHandle(ThreadArgs.hEvent);
}
}
cCritSect.Leave();
// if got this far either found our created a handler thread, now need
// to initialize the the stub side to create a hndlrMsg for this
// instance of the handler. will return a hdnlrmsg that must be passed
// along with everycall.
if (NOERROR == hr
&& (*pThreadProxy))
{
hr = (*pThreadProxy)->CreateNewHndlrMsg();
// Review - if fail to create hndlr message, then
// free proxy and return an error.
}
if (NOERROR != hr)
{
if ((*pThreadProxy))
{
(*pThreadProxy)->Release();
*pThreadProxy = NULL;
}
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: HandlerThread, public
//
// Synopsis: main proc for Handler thread
//
// Arguments: [lpArg] - Ptr to HandlerThreadArgs
//
// Returns: Appropriate status code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
DWORD WINAPI HandlerThread( LPVOID lpArg )
{
MSG msg;
HRESULT hr;
CThreadMsgStub *pThreadMsgStub = NULL;
CMsgServiceHwnd *pMsgDlg;
HRESULT hrOleInitialize;
BOOL fMsgDlgInitialized = FALSE;
HandlerThreadArgs *pThreadArgs = (HandlerThreadArgs *) lpArg;
DWORD dwThreadID = GetCurrentThreadId();
__try
{
pThreadArgs->hr = E_UNEXPECTED;
// need to do a PeekMessage and then set an event to make sure
// a message loop is created before the first PostMessage is sent.
PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
hrOleInitialize = CoInitialize(NULL);
// create our message hwnd
pMsgDlg = new CMsgServiceHwnd;
if (pMsgDlg)
{
if (pMsgDlg->Initialize(dwThreadID,MSGHWNDTYPE_HANDLERTHREAD))
{
pThreadArgs->hwndStub = pMsgDlg->GetHwnd();
fMsgDlgInitialized = TRUE;
}
}
// set the approriate error
if (fMsgDlgInitialized && SUCCEEDED(hrOleInitialize))
hr = NOERROR;
else
hr = E_UNEXPECTED;
pThreadArgs->hr = hr;
// let the caller know the thread is done initializing.
if (pThreadArgs->hEvent)
SetEvent(pThreadArgs->hEvent);
if (NOERROR == hr)
{
// sit in loop receiving messages.
while (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
if (SUCCEEDED(hrOleInitialize))
{
CoFreeUnusedLibraries();
CoUninitialize();
}
}
__except(QueryHandleException())
{
AssertSz(0,"Exception in Handler Thread.");
}
return 0;
}
//+---------------------------------------------------------------------------
//
// Member: CMsgServiceHwnd::HandleThreadMessage, public
//
// Synopsis: Responsible for determining the thread message that
// was received and calling the proper handler routine
//
// Arguments: [pmsgInfo] - Ptr to MessagingInfo structure
// [pgenMsg] - Ptr to Generic Message structure.
//
// Returns: Appropriate status code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
HRESULT CMsgServiceHwnd::HandleThreadMessage(MessagingInfo *pmsgInfo,GenericMsg *pgenMsg)
{
CHndlrMsg *pHndlrMsg;
pgenMsg->hr = E_UNEXPECTED; // initialize the return result.
// review, look up in linked list to validate.
pHndlrMsg = pmsgInfo->pCHndlrMsg;
m_fInOutCall = TRUE;
switch (pgenMsg->ThreadMsg)
{
case ThreadMsg_Release:
{
MSGInitialize *pmsg = (MSGInitialize *) pgenMsg;
ULONG cRefs;
cRefs = pHndlrMsg->Release();
Assert(0 == cRefs);
m_pHndlrMsg = NULL; // review, change when done.
pgenMsg->hr = NOERROR;
m_fInOutCall = FALSE;
}
break;
case ThreadMsg_Initialize:
{
MSGInitialize *pmsg = (MSGInitialize *) pgenMsg;
pgenMsg->hr = pHndlrMsg->Initialize(pmsg->dwReserved,pmsg->dwSyncFlags,
pmsg->cbCookie,pmsg->lpCookie);
}
break;
case ThreadMsg_GetHandlerInfo:
{
MSGGetHandlerInfo *pmsg = (MSGGetHandlerInfo *) pgenMsg;
pgenMsg->hr = pHndlrMsg->GetHandlerInfo(pmsg->ppSyncMgrHandlerInfo);
}
break;
case ThreadMsg_GetItemObject:
{
MSGGetItemObject *pmsg = (MSGGetItemObject *) pgenMsg;
pgenMsg->hr = pHndlrMsg->GetItemObject(pmsg->ItemID,pmsg->riid,
pmsg->ppv);
}
break;
case ThreadMsg_ShowProperties:
{
MSGShowProperties *pmsg = (MSGShowProperties *) pgenMsg;
pgenMsg->hr = pHndlrMsg->ShowProperties(pmsg->hWndParent,pmsg->ItemID);
}
break;
case ThreadMsg_PrepareForSync:
{
MSGPrepareForSync *pmsg = (MSGPrepareForSync *) pgenMsg;
HANDLE hEvent = pmsgInfo->hMsgEvent;
pgenMsg->hr = pHndlrMsg->PrepareForSync(pmsg->cbNumItems,pmsg->pItemIDs,
pmsg->hWndParent,pmsg->dwReserved);
}
break;
case ThreadMsg_Synchronize:
{
MSGSynchronize *pmsg = (MSGSynchronize *) pgenMsg;
HANDLE hEvent = pmsgInfo->hMsgEvent;
pgenMsg->hr = pHndlrMsg->Synchronize(pmsg->hWndParent);
}
break;
case ThreadMsg_SetItemStatus:
{
MSGSetItemStatus *pmsg = (MSGSetItemStatus *) pgenMsg;
pgenMsg->hr = pHndlrMsg->SetItemStatus(pmsg->ItemID,pmsg->dwSyncMgrStatus);
}
break;
case ThreadMsg_ShowError:
{
MSGShowConflicts *pmsg = (MSGShowConflicts *) pgenMsg;
pgenMsg->hr = pHndlrMsg->ShowError(pmsg->hWndParent,pmsg->ErrorID);
}
break;
case ThreadMsg_AddHandlerItems:
{
MSGAddItemHandler *pmsg = (MSGAddItemHandler *) pgenMsg;
pgenMsg->hr = pHndlrMsg->AddHandlerItems(pmsg->hwndList,pmsg->pcbNumItems);
}
break;
case ThreadMsg_CreateServer:
{
MSGCreateServer *pmsg = (MSGCreateServer *) pgenMsg;
pgenMsg->hr = pHndlrMsg->CreateServer(pmsg->pCLSIDServer,pmsg->pHndlrQueue,pmsg->pHandlerId,pmsg->dwProxyThreadId);
}
break;
case ThreadMsg_SetHndlrQueue:
{
MSGSetHndlrQueue *pmsg = (MSGSetHndlrQueue *) pgenMsg;
pgenMsg->hr = pHndlrMsg->SetHndlrQueue(pmsg->pHndlrQueue,pmsg->pHandlerId,pmsg->dwProxyThreadId);
}
break;
case ThreadMsg_SetupCallback:
{
MSGSetupCallback *pmsg = (MSGSetupCallback *) pgenMsg;
pgenMsg->hr = pHndlrMsg->SetupCallback(pmsg->fSet);
}
break;
default:
AssertSz(0,"Unknown Thread Message");
break;
}
m_fInOutCall = FALSE;
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Function: DopModalLoop, public
//
// Synopsis: Sit in message loop until the specified object
// becomes or thread becomes signalled.
//
// Arguments: [hEvent] - Event to wait on
// [hThread] - Thread that if it becomes signalled indicates thread
// that is being called has died.
// [hwndDlg] - hwnd of Dialog on thread we should check message for, can be null.
// [fAllowIncomingCalls] - incoming Messages can be dispatched during out call.
//
// Returns: Appropriate status code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
HRESULT DoModalLoopoLD(HANDLE hEvent,HANDLE hThread,HWND hwndDlg,BOOL fAllowIncomingCalls,
DWORD dwTimeout)
{
HRESULT hr = NOERROR;
DWORD dwWakeup;
DWORD dwHandleCount;
DWORD dwStartTime = GetTickCount();
DWORD dwTimeoutValue;
HANDLE handles[2];
handles[0] = hEvent;
handles[1] = hThread;
dwHandleCount = (NULL == hThread) ? 1 : 2;
dwTimeoutValue = dwTimeout; // initial call to wait is just the passed in vaulue
// just sit in a loop until the message has been processed or the thread
// we are calling dies
// if no event to wait on just fall through
if (NULL == hEvent)
{
do
{
if (fAllowIncomingCalls)
{
dwWakeup = MsgWaitForMultipleObjects(dwHandleCount,&handles[0],FALSE,dwTimeoutValue,QS_ALLINPUT);
}
else
{
dwWakeup = WaitForMultipleObjects(dwHandleCount,&handles[0],FALSE,dwTimeoutValue);
}
if (WAIT_OBJECT_0 == dwWakeup)
{ // call was completed.
hr = NOERROR;
break;
}
else if ((WAIT_OBJECT_0 +1 == dwWakeup) && (2== dwHandleCount) )
{
// thread died within call.
AssertSz(0,"Server Thread Terminated");
hr = E_UNEXPECTED;
break;
}
else if (WAIT_ABANDONED_0 == dwWakeup)
{
AssertSz(0,"Abandoned"); // this shouldn't ever happen
hr = E_UNEXPECTED;
break;
}
else if (WAIT_TIMEOUT == dwWakeup)
{
hr = HRESULT_FROM_WIN32(ERROR_TIMEOUT);
break;
}
else
{
MSG msg;
// see if events are signalled themselves since can get into this
// loop is items are in the queue even if events we are
// waiting on are already set.
if (WAIT_OBJECT_0 == WaitForSingleObject(hEvent,0))
{
hr = NOERROR;
break;
}
else if (hThread && (WAIT_OBJECT_0 == WaitForSingleObject(hThread,0)) )
{
AssertSz(0,"Server Thread Terminated");
hr = E_UNEXPECTED;
break;
}
// only grab out one peek message since dispatch could
// cause another message to get placed in the queue.
if (PeekMessage(&msg, NULL, 0, 0, PM_NOYIELD | PM_REMOVE))
{
// Assert(msg.message != WM_QUIT);
if ( (NULL == hwndDlg) || !IsDialogMessage(hwndDlg,&msg))
{
TranslateMessage((LPMSG) &msg);
DispatchMessage((LPMSG) &msg);
}
}
}
// update the timeout value
// adjust the timeout value
if (INFINITE == dwTimeout)
{
dwTimeoutValue = INFINITE;
}
else
{
DWORD dwCurTime = GetTickCount();
// handle roll-over of GetTickCount. If this happens use has to wait
// for the StartTime again. so user may have to wait twice as long
// as originally anticipated.
if (dwCurTime < dwStartTime)
{
dwStartTime = dwCurTime;
}
// if the elapsed time is greater than the timeout set the
// timeout value to zero, else use the different/
if (dwTimeout <= (dwCurTime - dwStartTime))
{
dwTimeoutValue = 0;
}
else
{
dwTimeoutValue = dwTimeout - (dwCurTime - dwStartTime);
}
}
} while (1);
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: DopModalLoop, public
//
// Synopsis: Sit in message loop until the specified object
// becomes or thread becomes signalled.
//
// Arguments: [hEvent] - Event to wait on
// [hThread] - Thread that if it becomes signalled indicates thread
// that is being called has died.
// [hwndDlg] - hwnd of Dialog on thread we should check message for, can be null.
// [fAllowIncomingCalls] - incoming Messages can be dispatched during out call.
//
// Returns: Appropriate status code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
HRESULT DoModalLoop(HANDLE hEvent,HANDLE hThread,HWND hwndDlg,BOOL fAllowIncomingCalls,
DWORD dwTimeout)
{
HRESULT hr = NOERROR;
DWORD dwWakeup;
DWORD dwHandleCount;
DWORD dwStartTime = GetTickCount();
DWORD dwTimeoutValue;
HANDLE handles[2];
handles[0] = hEvent;
handles[1] = hThread;
Assert(NULL != hEvent);
dwHandleCount = (NULL == hThread) ? 1 : 2;
dwTimeoutValue = dwTimeout; // initial call to wait is just the passed in vaulue
// just sit in a loop until the message has been processed or the thread
// we are calling dies
do
{
DWORD dwWaitValue;
MSG msg;
// check if hEvents are signalled yet
if (WAIT_OBJECT_0 == (dwWaitValue = WaitForSingleObject(hEvent,0)) )
{
hr = NOERROR;
break;
}
else if ( (dwWaitValue != WAIT_ABANDONED)
&& hThread && (WAIT_OBJECT_0 == (dwWaitValue = WaitForSingleObject(hThread,0))) )
{
// possible on Release message event was set between the
// time we checked for it and our thread event check.
if (WAIT_OBJECT_0 == (dwWaitValue = WaitForSingleObject(hEvent,0)) )
{
hr = NOERROR;
}
else
{
AssertSz(0,"Server Thread Terminated");
hr = E_UNEXPECTED;
}
break;
}
// if come out af any of these calls with abandoned then assert and break;
if (WAIT_ABANDONED == dwWaitValue)
{
AssertSz(0,"Abandoned"); // this shouldn't ever happen
hr = E_UNEXPECTED;
break;
}
// if not then either grab next PeekMessage or wait for objects depending
if (fAllowIncomingCalls)
{
// Leave any completion posts in the queue until the call has returned.
if (PeekMessage(&msg, NULL, 0, 0, PM_NOYIELD | PM_REMOVE) )
{
dwWakeup = WAIT_OBJECT_0 + dwHandleCount; // set it to wait MsgWait would.
Assert (msg.message != WM_QUIT);
if ( (NULL == hwndDlg) || !IsDialogMessage(hwndDlg,&msg))
{
TranslateMessage((LPMSG) &msg);
DispatchMessage((LPMSG) &msg);
}
}
else
{
dwWakeup = MsgWaitForMultipleObjects(dwHandleCount,&handles[0],FALSE,dwTimeoutValue,QS_ALLINPUT);
}
}
else
{
dwWakeup = WaitForMultipleObjects(dwHandleCount,&handles[0],FALSE,dwTimeoutValue);
}
if (WAIT_TIMEOUT == dwWakeup)
{
hr = HRESULT_FROM_WIN32(ERROR_TIMEOUT);
break;
}
// update the timeout value
if (INFINITE == dwTimeout)
{
dwTimeoutValue = INFINITE;
}
else
{
DWORD dwCurTime = GetTickCount();
// handle roll-over of GetTickCount. If this happens use has to wait
// for the StartTime again. so user may have to wait twice as long
// as originally anticipated.
if (dwCurTime < dwStartTime)
{
dwStartTime = dwCurTime;
}
// if the elapsed time is greater than the timeout set the
// timeout value to zero, else use the different/
if (dwTimeout <= (dwCurTime - dwStartTime))
{
dwTimeoutValue = 0;
}
else
{
dwTimeoutValue = dwTimeout - (dwCurTime - dwStartTime);
}
}
} while (1);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::CThreadMsgProxy, public
//
// Synopsis: Constructor
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
CThreadMsgProxy::CThreadMsgProxy()
{
m_Clsid = GUID_NULL;
m_cRef = 1;
m_hwndDlg = NULL;
m_pCHndlrMsg = NULL;
m_fTerminatedHandler = FALSE;
m_hThreadStub = NULL;
m_ThreadIdStub = 0;
m_hwndStub = NULL;
m_hwndDlg = NULL;
m_ThreadIdProxy = 0;
m_fNewHndlrQueue = FALSE;
m_pHandlerId = 0;
m_pHndlrQueue = NULL;
m_dwNestCount = 0;
m_fHaveCompletionCall = FALSE;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::~CThreadMsgProxy, public
//
// Synopsis: destructor
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 03-Jun-98 rogerg Created.
//
//----------------------------------------------------------------------------
CThreadMsgProxy::~CThreadMsgProxy()
{
Assert(0 == m_dwNestCount);
Assert(NULL == m_pStubId);
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::InitProxy, public
//
// Synopsis: Initializes member vars of Thread Proxy
// Arguments: [hwndStub] - hwnd of the Stub to send messages too.
// [ThreadId] - ThreadId of the Stub
// [hThread] - Handle of the Stub Thread.
//
// Returns: !!!!This function should be written so it never fails.
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::InitProxy(HWND hwndStub, DWORD ThreadId,HANDLE hThread,
HWND hwndDlg,REFCLSID refClsid,
STUBLIST *pStubId)
{
m_hwndStub = hwndStub;
m_ThreadIdStub = ThreadId;
m_hThreadStub = hThread;
m_pStubId = pStubId;
m_hwndDlg = hwndDlg;
m_Clsid = refClsid;
m_ThreadIdProxy = GetCurrentThreadId();
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::DispatchMsg, public
//
// Synopsis: Dispatches the specified messge
// Arguments: [pgenMsg] - Ptr to Generic Message structure.
// [fAllowIncomingCalls] - incoming Messages can be dispatched during out call.
//
// Returns: Appropriate status code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::DispatchMsg(GenericMsg *pgenMsg,BOOL fAllowIncomingCalls,BOOL fAsync)
{
HRESULT hr = E_UNEXPECTED;
MessagingInfo msgInfo;
// if the hndlrmsg information needs to be updated update
// it before sending requested message
AssertSz(!m_fTerminatedHandler,"Dispatching Message on Terminated Thread");
if (m_fTerminatedHandler)
{
return E_UNEXPECTED;
}
++m_dwNestCount;
msgInfo.hMsgEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
if (NULL == msgInfo.hMsgEvent)
{
--m_dwNestCount;
return GetLastError();
}
msgInfo.dwSenderThreadID = m_ThreadIdProxy;
msgInfo.pCHndlrMsg = m_pCHndlrMsg;
// Post the message to the handler thread.
Assert(m_hwndStub);
Assert(m_pCHndlrMsg);
Assert(m_hThreadStub);
Assert(m_pStubId);
if (m_hwndStub && m_pCHndlrMsg && m_hThreadStub && m_pStubId)
{
BOOL fPostMessage;
fPostMessage = PostMessage(m_hwndStub,WM_THREADMESSAGE,(WPARAM) &msgInfo, (LPARAM) pgenMsg);
Assert(fPostMessage || m_pStubId->fStubTerminated);
if (fPostMessage)
{
hr = DoModalLoop(msgInfo.hMsgEvent,m_hThreadStub,m_hwndDlg,fAllowIncomingCalls,INFINITE);
}
}
CloseHandle(msgInfo.hMsgEvent);
--m_dwNestCount;
// if have a callback message then post. Note don't have this code for stub messages
// since it doesn;t have any callbacks
if (m_fHaveCompletionCall)
{
PostMessage(m_msgCompletion.hwnd,m_msgCompletion.message,m_msgCompletion.wParam,m_msgCompletion.lParam);
m_fHaveCompletionCall = FALSE;
}
return NOERROR != hr ? hr : pgenMsg->hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::DispatchsStubMsg, public
//
// Synopsis: Dispatches the specified Stub messge
// Arguments: [pgenMsg] - Ptr to Generic Message structure.
// [fAllowIncomingCalls] - incoming Messages can be dispatched during out call.
//
// Returns: Appropriate status code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::DispatchsStubMsg(GenericMsg *pgenMsg,BOOL fAllowIncomingCalls)
{
HRESULT hr = E_UNEXPECTED;
MessagingInfo msgInfo;
BOOL fPostMessage;
AssertSz(!m_fTerminatedHandler,"Dispatching Stub Message on Terminated Thread");
if (m_fTerminatedHandler)
return E_UNEXPECTED;
msgInfo.hMsgEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
if (NULL == msgInfo.hMsgEvent)
return GetLastError();
m_dwNestCount++;
msgInfo.dwSenderThreadID = m_ThreadIdProxy;
// Post the message to the handler thread.
Assert(m_hwndStub);
Assert(m_hThreadStub);
Assert(m_pStubId);
if (m_hwndStub && m_hThreadStub && m_pStubId)
{
fPostMessage = PostMessage(m_hwndStub,WM_THREADSTUBMESSAGE,(WPARAM) &msgInfo, (LPARAM) pgenMsg);
Assert(fPostMessage || (m_pStubId->fStubTerminated));
if (fPostMessage)
{
hr = DoModalLoop(msgInfo.hMsgEvent,m_hThreadStub,m_hwndDlg,fAllowIncomingCalls,INFINITE);
}
}
CloseHandle(msgInfo.hMsgEvent);
m_dwNestCount--;
Assert(FALSE == m_fHaveCompletionCall); // catch any stub calls that occur at same time as dispatch
return NOERROR != hr ? hr : pgenMsg->hr;
}
//+---------------------------------------------------------------------------
//
// Function: TerminateHandlerThread, public
//
// Synopsis: terminate the non-responsive handler thread
//
// Returns: Appropriate status code
//
// Modifies: m_hThreadStub;
//
// History: 02-Nov-98 susia Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::TerminateHandlerThread(TCHAR *pszHandlerName,BOOL fPromptUser)
{
int iEndSession;
TCHAR pszFormatString[MAX_PATH + 1],
pszMessageText[MAX_PATH + 1],
pszTitleString[MAX_STRING_RES + 1];
AssertSz(!m_fTerminatedHandler,"Terminate Handler called twice on same Proxy");
if (S_OK == DoesStubExist(m_pStubId))
{
BOOL fAllHandlerInstancesComplete;
BOOL bResult;
// let use know of cases don't want to prompt user but haven't killed stub yet.
Assert(fPromptUser);
if (fPromptUser)
{
if (!pszHandlerName)
{
LoadString(g_hInst,IDS_NULL_HANDLERNOTRESPONDING,pszMessageText, MAX_PATH);
}
else
{
LoadString(g_hInst,IDS_HANDLERNOTRESPONDING,pszFormatString, MAX_PATH);
wsprintf(pszMessageText,pszFormatString, pszHandlerName);
}
LoadString(g_hInst,IDS_SYNCMGR_ERROR,pszTitleString, MAX_STRING_RES);
iEndSession = MessageBox(m_hwndDlg,pszMessageText,pszTitleString,
MB_YESNO | MB_ICONERROR );
if (IDYES != iEndSession)
{
return S_FALSE; //Yes will terminate the thread
}
}
// make sure handler is still not responding.
fAllHandlerInstancesComplete = TRUE;
if (m_pHndlrQueue)
{
fAllHandlerInstancesComplete = m_pHndlrQueue->IsAllHandlerInstancesCancelCompleted(m_Clsid);
}
// if no longer any instancesof this handler that aren't responding just ignore
// the terminate.
if (S_OK == fAllHandlerInstancesComplete)
{
return S_FALSE;
}
// mark the stubId as terminated
TerminateStub(m_pStubId);
// now terminate the thread.
bResult = TerminateThread (m_hThreadStub, 0);
AssertSz(bResult,"Error Terminating Thread");
}
m_pStubId = NULL;
// if get here means we should are terminating this thread
m_fTerminatedHandler = TRUE;
m_hThreadStub = 0; // set threadId of stub to zero.
// set the proxy stubhwnd to NULL
m_hwndStub = NULL;
// if have a hndlrmsg tell it we are terminated and clear
// out our member variable.
if (m_pCHndlrMsg)
{
CHndlrMsg *pCHndlrMsg = m_pCHndlrMsg;
m_pCHndlrMsg = NULL;
pCHndlrMsg->ForceKillHandler();
}
return S_OK;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::CreateNewHndlrMsg, public
//
// Synopsis: Make a request to the stub to create a new
// Handler Message object
//
// Arguments:
// Returns: Appropriate status code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::CreateNewHndlrMsg()
{
HRESULT hr = NOERROR;
MSGSTUBCreateStub msg;
msg.MsgGen.ThreadMsg = StubMsg_CreateNewStub;
hr = DispatchsStubMsg( (GenericMsg *) &msg,TRUE);
m_pCHndlrMsg = msg.pCHndlrMsg;
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::ReleaseStub, public
//
// Synopsis: Informst the Stub thread that it is no longer needed.
// Arguments:
// Returns: Appropriate status code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::ReleaseStub()
{
HRESULT hr = NOERROR;
GenericMsg msg;
msg.ThreadMsg = StubMsg_Release;
hr = DispatchsStubMsg( (GenericMsg *) &msg,TRUE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::QueryInterface, public
//
// Synopsis: Standard QueryInterface
//
// Arguments: [iid] - Interface ID
// [ppvObj] - Object return
//
// Returns: Always returns E_NOTIMPL;
//
// Modifies: [ppvObj]
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::QueryInterface(REFIID riid, LPVOID FAR *ppv)
{
AssertSz(0,"QI called on MsgProxy");
return E_NOTIMPL;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::AddRef, public
//
// Synopsis: Add reference
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CThreadMsgProxy::AddRef()
{
ULONG cRefs;
cRefs = InterlockedIncrement((LONG *)& m_cRef);
return cRefs;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::Release, public
//
// Synopsis: Release reference
// Must properly handle the case Release is
// called before the initialize method in case
// createing the handler thread fails.
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CThreadMsgProxy::Release()
{
HRESULT hr = NOERROR;
GenericMsg msg;
ULONG cRefs;
cRefs = InterlockedDecrement( (LONG *) &m_cRef);
if (cRefs)
return cRefs;
if (m_hThreadStub && !m_fTerminatedHandler)
{
CCriticalSection cCritSect(&g_StubListCriticalSection,GetCurrentThreadId());
BOOL fLastRelease = FALSE;
BOOL fExistingStub = FALSE;
STUBLIST *pStubList;
// release the handler Thread.
msg.ThreadMsg = ThreadMsg_Release;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,FALSE);
m_pCHndlrMsg = NULL;
// If the cRefs in our proxy list is zero
// then sit in loop until the ThreadStub Dies.
cCritSect.Enter();
pStubList = g_FirstStub;
while (pStubList)
{
if (pStubList->clsidStub == m_Clsid)
{
fExistingStub = TRUE;
break;
}
pStubList= pStubList->pNextStub;
}
Assert(fExistingStub); // their should always be an existing proxy
if (fExistingStub)
{
Assert(pStubList->cRefs > 0);
(pStubList->cRefs)--;
if (0 == pStubList->cRefs)
{
STUBLIST CurStub;
STUBLIST *pCurStub = &CurStub;
CurStub.pNextStub = g_FirstStub;
while (pCurStub->pNextStub)
{
if (pCurStub->pNextStub == pStubList)
{
pCurStub->pNextStub = pStubList->pNextStub;
g_FirstStub = CurStub.pNextStub;
FREE(pStubList);
break;
}
pCurStub = pCurStub->pNextStub;
}
fLastRelease = TRUE;
}
}
cCritSect.Leave();
if (fLastRelease)
{
// send the quit command to the stub,
if (NOERROR == ReleaseStub())
{
// Review, what if stubthread never dies.
m_dwNestCount++;
DoModalLoop(m_hThreadStub,NULL,NULL,TRUE,INFINITE); // sit in loop until the stub thread dies
CloseHandle(m_hThreadStub);
m_dwNestCount--;
}
}
m_pStubId = NULL; // clear StubId
}
delete this;
return cRefs;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::Initialize, public
//
// Synopsis: Sends Initialize command to the Handler thread
// Arguments: [dwReserved] - reserved.
// [dwSyncFlags] - syncflags
// [cbCookie] - size of cookie data
// [lpCookie] - ptr to any cookie data
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::Initialize(DWORD dwReserved,
DWORD dwSyncFlags,
DWORD cbCookie,
const BYTE *lpCookie)
{
HRESULT hr = NOERROR;
MSGInitialize msg;
msg.MsgGen.ThreadMsg = ThreadMsg_Initialize;
// package up the parameters
msg.dwReserved = dwReserved;
msg.dwSyncFlags = dwSyncFlags;
msg.cbCookie = cbCookie;
msg.lpCookie = lpCookie;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,FALSE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::GetHandlerInfo, public
//
// Synopsis: Sends GetHandler command to the Handler thread
// Arguments: [ppSyncMgrHandlerInfo] - pointer to SyncMgrHandlerInfo pointer
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::GetHandlerInfo(LPSYNCMGRHANDLERINFO *ppSyncMgrHandlerInfo)
{
HRESULT hr = NOERROR;
MSGGetHandlerInfo msg;
msg.MsgGen.ThreadMsg = ThreadMsg_Initialize;
// package up the parameters
msg.ppSyncMgrHandlerInfo = ppSyncMgrHandlerInfo;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,FALSE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::EnumOfflineItems, public
//
// Synopsis: Sends Enum command to the Handler thread
// Should not be called. AddItems method
// should be called instead
//
// Arguments: [ppenumOfflineItems] - reserved.
//
// Returns: E_NOTIMPL;
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::EnumSyncMgrItems(ISyncMgrEnumItems **ppenumOfflineItems)
{
#ifdef DONOTCALL
HRESULT hr = NOERROR;
MSGEnumOfflineItems msgEnum;
msgEnum.MsgGen.ThreadMsg = ThreadMsg_EnumOfflineItems;
msgEnum.ppenumOfflineItems = ppenumOfflineItems;
hr = DispatchMsg( (GenericMsg *) &msgEnum);
#endif // DONOTCALL
AssertSz(0,"EnumMethod Called on Proxy");
return E_NOTIMPL;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::GetItemObject, public
//
// Synopsis: Sends GetItemObject command to the Handler thread
// Arguments: [ItemID] - identifies the item.
// [riid] - requested interface
// [ppv] - On success, pointer to object
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::GetItemObject(REFSYNCMGRITEMID ItemID,REFIID riid,void** ppv)
{
HRESULT hr = NOERROR;
MSGGetItemObject msg;
msg.MsgGen.ThreadMsg = ThreadMsg_GetItemObject;
// package up the parameters
msg.ItemID = ItemID;
msg.riid = riid;
msg.ppv = ppv;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,FALSE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::ShowProperties, public
//
// Synopsis: Sends ShowProperties command to the Handler thread
// Arguments: [hWndParent] - hwnd to use as parent of any dialogs
// [ItemID] - Identifies the Item
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::ShowProperties(HWND hWndParent,REFSYNCMGRITEMID ItemID)
{
HRESULT hr = NOERROR;
MSGShowProperties msg;
msg.MsgGen.ThreadMsg = ThreadMsg_ShowProperties;
// package up the parameters
msg.hWndParent = hWndParent;
msg.ItemID = ItemID;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,TRUE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::SetProgressCallback, public
//
// Synopsis: Sends SetProgressCallback command to the Handler thread
// This method should not be called, SetupCallback method
// should be called instead
//
// Arguments: [lpCallBack] - Ptr to callback.
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::SetProgressCallback(ISyncMgrSynchronizeCallback *lpCallBack)
{
#ifdef DONTCALL
HRESULT hr = NOERROR;
MSGSetProgressCallback msg;
msg.MsgGen.ThreadMsg = ThreadMsg_SetProgressCallback;
// package up the parameters
msg.lpCallBack = lpCallBack;
hr = DispatchMsg( (GenericMsg *) &msg);
return hr;
#endif // DONTCALL
AssertSz(0,"SetProgressCallback called on Proxy");
return E_NOTIMPL;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::PrepareForSync, public
//
// Synopsis: Sends PrepareForSync command to the Handler thread
//
// Arguments: [cbNumItems] - Number of items in the pItemIDs array.
// [pItemIDs] - array of item ids
// [hWndParent] - hwnd to use as the parent for any dialogs
// [dwReserved] - Reserved parameter.
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::PrepareForSync(ULONG cbNumItems,SYNCMGRITEMID *pItemIDs,
HWND hWndParent,DWORD dwReserved)
{
HRESULT hr = NOERROR;
MSGPrepareForSync msg;
msg.MsgGen.ThreadMsg = ThreadMsg_PrepareForSync;
// package up the parameters
msg.cbNumItems = cbNumItems;
msg.pItemIDs = pItemIDs;
msg.hWndParent = hWndParent;
msg.dwReserved = dwReserved;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,TRUE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::Synchronize, public
//
// Synopsis: Sends Synchronize command to the Handler thread
//
// Arguments: [hWndParent] - hwnd to use as the parent for any dialogs
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::Synchronize(HWND hWndParent)
{
HRESULT hr = NOERROR;
MSGSynchronize msg;
msg.MsgGen.ThreadMsg = ThreadMsg_Synchronize;
// package up the parameters
msg.hWndParent = hWndParent;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,TRUE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::SetItemStatus, public
//
// Synopsis: Sends SetItemStatus command to the Handler thread
//
// Arguments: [ItemID] - Identifies the item
// [dwSyncMgrStatus] - Status to set the item too.
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::SetItemStatus(REFSYNCMGRITEMID ItemID,DWORD dwSyncMgrStatus)
{
HRESULT hr = NOERROR;
MSGSetItemStatus msg;
msg.MsgGen.ThreadMsg = ThreadMsg_SetItemStatus;
// package up the parameters
msg.ItemID = ItemID;
msg.dwSyncMgrStatus = dwSyncMgrStatus;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,FALSE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::ShowError, public
//
// Synopsis: Sends ShowError command to the Handler thread
//
// Arguments: [hWndParent] - hwnd to use as the parent for any dialogs
// [dwErrorID] - Identifies the Error.
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::ShowError(HWND hWndParent,REFSYNCMGRERRORID ErrorID,ULONG *pcbNumItems,SYNCMGRITEMID **ppItemIDs)
{
HRESULT hr = NOERROR;
MSGShowConflicts msg;
msg.MsgGen.ThreadMsg = ThreadMsg_ShowError;
// package up the parameters
msg.hWndParent = hWndParent;
msg.ErrorID = ErrorID;
msg.pcbNumItems = pcbNumItems;
msg.ppItemIDs = ppItemIDs;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,TRUE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::CreateServer, public
//
// Synopsis: Sends CreateServer command to the Handler thread
//
// Arguments: [pCLSIDServer] - clsid of handler to create
// [pHndlrQueue] - Queue the handler belongs too.
// [wHandlerId] - ID assigned to this instance of the Handler
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::CreateServer(const CLSID *pCLSIDServer,CHndlrQueue *pHndlrQueue,
HANDLERINFO *pHandlerId)
{
HRESULT hr = NOERROR;
MSGCreateServer msg;
m_pHndlrQueue = pHndlrQueue;
m_pHandlerId = pHandlerId;
msg.MsgGen.ThreadMsg = ThreadMsg_CreateServer;
// package up the parameters
msg.pCLSIDServer = pCLSIDServer;
msg.pHndlrQueue = pHndlrQueue;
msg.pHandlerId = pHandlerId;
msg.dwProxyThreadId = m_ThreadIdProxy;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,FALSE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::SetHndlrQueue, public
//
// Synopsis: Assigns a new queue to the Handler
//
// Arguments: [pHndlrQueue] - Queue the handler now belongs too.
// [wHandlerId] - ID assigned to this instance of the Handler
// [dwThreadIdProxy] - ThreadID the queue is in.
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::SetHndlrQueue(CHndlrQueue *pHndlrQueue,
HANDLERINFO *pHandlerId,
DWORD dwThreadIdProxy)
{
HRESULT hr = NOERROR;
MSGSetHndlrQueue msg;
AssertSz(0,"this shouldn't be called");
m_ThreadIdProxy = dwThreadIdProxy; // update the threadId the Proxy is on.
msg.MsgGen.ThreadMsg = ThreadMsg_SetHndlrQueue;
// package up the parameters
msg.pHndlrQueue = pHndlrQueue;
msg.pHandlerId = pHandlerId;
msg.dwProxyThreadId = dwThreadIdProxy;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,FALSE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::AddHandlerItems, public
//
// Synopsis: Request Handler adds its items to the queue.
//
// Arguments: [hwndList] - Currently not used..
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::AddHandlerItems(HWND hwndList,DWORD *pcbNumItems)
{
HRESULT hr = NOERROR;
MSGAddItemHandler msg;
msg.MsgGen.ThreadMsg = ThreadMsg_AddHandlerItems;
// package up the parameters
msg.hwndList = hwndList;
msg.pcbNumItems = pcbNumItems;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,FALSE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::SetupCallback, public
//
// Synopsis: Request stub sets up the Callback.
//
// Arguments: [fSet] - TRUE == set the callback, FALSE == revoke it.
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::SetupCallback(BOOL fSet)
{
HRESULT hr = NOERROR;
MSGSetupCallback msg;
AssertSz(0,"Shouldn't be called");
msg.MsgGen.ThreadMsg = ThreadMsg_SetupCallback;
// package up the parameters
msg.fSet = fSet;
hr = DispatchMsg( (GenericMsg *) &msg,TRUE,FALSE);
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::SetProxyParams, public
//
// Synopsis: informs server thread that the queue has been chagned
// on it..
//
// Arguments:
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::SetProxyParams(HWND hwndDlg, DWORD ThreadIdProxy,
CHndlrQueue *pHndlrQueue,HANDLERINFO *pHandlerId )
{
m_hwndDlg = hwndDlg;
m_ThreadIdProxy = ThreadIdProxy;
m_pHndlrQueue = pHndlrQueue;
m_pHandlerId = pHandlerId;
Assert(m_pCHndlrMsg);
if (m_pCHndlrMsg)
{
m_pCHndlrMsg->SetHndlrQueue(pHndlrQueue,pHandlerId,m_ThreadIdProxy);
}
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Member: CThreadMsgProxy::SetProxyCompletion, public
//
// Synopsis: sets values for any completion notification to
// post when returning from an out call
//
// Arguments:
//
// Returns: Appropriate error code
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CThreadMsgProxy::SetProxyCompletion(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam)
{
Assert(FALSE == m_fHaveCompletionCall); // should only ever have one.
if (m_fHaveCompletionCall) // if already have a completion fail.
return S_FALSE;
m_fHaveCompletionCall = TRUE;
m_msgCompletion.hwnd = hWnd;
m_msgCompletion.message = Msg;
m_msgCompletion.wParam = wParam;
m_msgCompletion.lParam = lParam;
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Member: CMsgServiceHwnd::CMsgServiceHwnd, public
//
// Synopsis: Constructor
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
CMsgServiceHwnd::CMsgServiceHwnd()
{
m_hwnd = NULL;
m_dwThreadID = -1;
m_pHndlrMsg = NULL;
m_fInOutCall = FALSE;
m_pMsgServiceQueue = NULL;
m_MsgHwndType = MSGHWNDTYPE_UNDEFINED;
}
//+---------------------------------------------------------------------------
//
// Member: CMsgServiceHwnd::~CMsgServiceHwnd, public
//
// Synopsis: Destructor
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
CMsgServiceHwnd::~CMsgServiceHwnd()
{
}
//+---------------------------------------------------------------------------
//
// Member: CMsgServiceHwnd::Initialize, public
//
// Synopsis: Initializes the service HWND
//
// Arguments: [dwThreadID] - id of thread hwnd belongs too.
// [MsgHwndType] - type of MsgHwnd this is.
//
// Returns: TRUE on success, FALSE on failure
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
BOOL CMsgServiceHwnd::Initialize(DWORD dwThreadID,MSGHWNDTYPE MsgHwndType)
{
BOOL fInitialized = FALSE;
TCHAR szWinTitle[MAX_STRING_RES];
m_MsgHwndType = MsgHwndType;
LoadString(g_hInst, IDS_SYNCMGRNAME, szWinTitle, ARRAY_SIZE(szWinTitle));
m_hwnd = CreateWindowEx(0,
TEXT(MSGSERVICE_HWNDCLASSNAME),
szWinTitle,
// must use WS_POPUP so the window does not get
// assigned a hot key by user.
WS_DISABLED | WS_POPUP,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL, // REVIEW, can we give it a parent to not show up.
NULL,
g_hInst,
this);
Assert(m_hwnd);
if (m_hwnd)
{
m_dwThreadID = dwThreadID;
if (MSGHWNDTYPE_HANDLERTHREAD == m_MsgHwndType)
{
// m_pHndlrMsg = new CHndlrMsg;
// if (NULL != m_pHndlrMsg)
fInitialized = TRUE;
}
else
{
fInitialized = TRUE;
}
}
if (!fInitialized)
{
Assert(NULL == m_pHndlrMsg);
}
// caller still needs to call Destroy if initialize returns false.
return fInitialized;
}
//+---------------------------------------------------------------------------
//
// Member: CMsgServiceHwnd::Destroy, public
//
// Synopsis: Destroys the ServiceHwnd
//
// Arguments:
// Returns:
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
void CMsgServiceHwnd::Destroy()
{
BOOL fDestroy;
// HANDLER m_pHndlrMsg will be destroyed by the Release HandleThreadMessage call
// only case that it shouldn't is if for some reason CreateThreadHndlr failed
Assert(NULL == m_pHndlrMsg);
if (m_pHndlrMsg)
{
m_pHndlrMsg->Release();
m_pHndlrMsg = NULL;
}
if (m_hwnd)
{
fDestroy = DestroyWindow(m_hwnd);
Assert(TRUE == fDestroy);
}
delete this;
}
//+---------------------------------------------------------------------------
//
// Member: CMsgServiceHwnd::MsgThreadWndProc, public
//
// Synopsis: Servicer Side message handling window.
//
// Arguments:
// Returns:
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
LRESULT CALLBACK MsgThreadWndProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
CMsgServiceHwnd *pThis = (CMsgServiceHwnd *) GetWindowLongPtr(hWnd, DWL_THREADWNDPROCCLASS);
if (pThis || (msg == WM_CREATE) )
{
switch (msg)
{
case WM_CREATE :
{
CREATESTRUCT *pCreateStruct = (CREATESTRUCT *) lParam;
SetWindowLongPtr(hWnd, DWL_THREADWNDPROCCLASS,(LONG_PTR) pCreateStruct->lpCreateParams );
pThis = (CMsgServiceHwnd *) pCreateStruct->lpCreateParams ;
}
break;
case WM_DESTROY:
SetWindowLongPtr(hWnd, DWL_THREADWNDPROCCLASS,(LONG_PTR) NULL);
PostQuitMessage(0); // no longer need this thread
break;
case WM_THREADSTUBMESSAGE: // message send only to stub.
{
MessagingInfo *pmsgInfo = (MessagingInfo *) wParam;
GenericMsg *pgenMsg = (GenericMsg *) lParam;
Assert(MSGHWNDTYPE_HANDLERTHREAD == pThis->m_MsgHwndType);
pgenMsg->hr = E_UNEXPECTED;
switch(pgenMsg->ThreadMsg)
{
case StubMsg_Release:
// proxy is telling us there is no need to stick around
// any longer so post a quit message.
Assert(NULL == pThis->m_pHndlrMsg);
pThis->Destroy(); // no longer need this
pgenMsg->hr = NOERROR;
break;
case StubMsg_CreateNewStub:
// proxy is telling us there is no need to stick around
// any longer so post a quit message.
pThis->m_pHndlrMsg = new CHndlrMsg;
((MSGSTUBCreateStub *) pgenMsg)->pCHndlrMsg = pThis->m_pHndlrMsg;
pThis->m_pHndlrMsg = NULL;
pgenMsg->hr = NOERROR;
break;
default:
AssertSz(0,"Unknown StubMessage");
break;
};
if (pmsgInfo->hMsgEvent)
{
SetEvent(pmsgInfo->hMsgEvent);
}
break;
}
case WM_THREADMESSAGE:
{
MessagingInfo *pmsgInfo = (MessagingInfo *) wParam;
GenericMsg *pgenMsg = (GenericMsg *) lParam;
Assert(MSGHWNDTYPE_HANDLERTHREAD == pThis->m_MsgHwndType);
pThis->HandleThreadMessage(pmsgInfo,pgenMsg);
// won't be an hEvent on an async call
if (pmsgInfo->hMsgEvent)
{
SetEvent(pmsgInfo->hMsgEvent);
}
// on an async call we free
break;
}
case WM_CFACTTHREAD_REVOKE:
{
HRESULT hr;
Assert(MSGHWNDTYPE_MAINTHREAD == pThis->m_MsgHwndType);
hr = CoRevokeClassObject((DWORD)wParam);
Assert(NOERROR == hr);
break;
}
case WM_MAINTHREAD_QUIT: // handles shutdown of main thread.
{
HANDLE hThread = (HANDLE) lParam;
Assert(MSGHWNDTYPE_MAINTHREAD == pThis->m_MsgHwndType);
// set ShuttingDown Flag for race conditions with QueryEnd.
// bfore yielding.
g_fShuttingDown = TRUE;
// if there is an hThread that was passed wait until
// it goes away
Assert(0 == hThread); // we currently don't support this.
if (hThread)
{
WaitForSingleObject(hThread,INFINITE);
CloseHandle(hThread);
}
// if have a queryEndSession object state its okay to return now
// no need to cleanup window.
if (g_hEndSessionEvent)
{
HANDLE hEvent = g_hEndSessionEvent;
// g_hEndSessionEvent = NULL; // leave EndSession NON-Null since only need to handle one.
SetEvent(hEvent);
}
else
{
pThis->Destroy(); // Clean up this window.
}
break;
}
case WM_QUERYENDSESSION:
{
HWND hwndQueryParent;
UINT uiMessageID;
BOOL fLetUserDecide;
BOOL fReturn = TRUE;
// only handle this message if it is the main thread window
if (MSGHWNDTYPE_MAINTHREAD != pThis->m_MsgHwndType)
{
break;
}
if (!g_fShuttingDown
&& (S_FALSE == ObjMgr_HandleQueryEndSession(&hwndQueryParent,&uiMessageID,&fLetUserDecide)))
{
TCHAR pszTitle[MAX_PATH];
TCHAR pszMessageText[MAX_PATH];
UINT uType; // style of messagebox.
int iEndSession;
LoadString(g_hInst,IDS_SYNCMGRNAME,pszTitle,sizeof(pszTitle)/sizeof(TCHAR));
LoadString(g_hInst,uiMessageID,pszMessageText,sizeof(pszMessageText)/sizeof(TCHAR));
if (fLetUserDecide)
{
uType = MB_YESNO | MB_ICONEXCLAMATION | MB_SETFOREGROUND;
}
else
{
uType = MB_OK | MB_ICONSTOP | MB_SETFOREGROUND;
}
iEndSession = MessageBox(hwndQueryParent,pszMessageText,
pszTitle,uType);
if (!fLetUserDecide || IDYES != iEndSession)
{
fReturn = FALSE; // FALSE causes system to stop the shutdown.
}
}
// if we are going to allow shutdown cleanup our threads
// before returning since on Win9x its too late afterwards.
if (TRUE == fReturn)
{
HANDLE hEndSessionEvent = NULL;
// its possible that another QUERYENDSESSION comes
// in while we are still shutting down. If already
// handling an end sessios or in WM_MAINTHREAD_QUIT just fall through
if (NULL == g_hEndSessionEvent && !g_fShuttingDown)
{
g_hEndSessionEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
hEndSessionEvent = g_hEndSessionEvent;
ObjMgr_CloseAll(); // start the process of closing down the dialogs.
Assert(hEndSessionEvent);
// wait until other threads have cleaned up so we know its safe to terminate.
if (hEndSessionEvent)
{
DoModalLoop(hEndSessionEvent ,NULL,NULL,TRUE,INFINITE);
CloseHandle(hEndSessionEvent);
}
}
}
return fReturn;
}
break;
default:
break;
}
}
return DefWindowProc(hWnd, msg, wParam, lParam);
}
//+---------------------------------------------------------------------------
//
// Function: InitMessageService, public
//
// Synopsis: Initializes our internal thread messaging service.
// Must be called before any Messagin is done.
//
// Arguments:
// Returns: NOERROR if Service was successfully initialized.
//
// Modifies:
//
// History: 05-Nov-97 rogerg Created.
//
//----------------------------------------------------------------------------
STDAPI InitMessageService()
{
ATOM aWndClass;
WNDCLASS xClass;
DWORD dwErr;
// initialize the proxy critical section
InitializeCriticalSection(&g_StubListCriticalSection);
// Register windows class.we need for handling thread communication
xClass.style = 0;
xClass.lpfnWndProc = MsgThreadWndProc;
xClass.cbClsExtra = 0;
xClass.cbWndExtra = sizeof(PVOID); // room for class this ptr
xClass.hInstance = g_hInst;
xClass.hIcon = NULL;
xClass.hCursor = NULL;
xClass.hbrBackground = (HBRUSH) (COLOR_BACKGROUND + 1);
xClass.lpszMenuName = NULL;
xClass.lpszClassName = TEXT(MSGSERVICE_HWNDCLASSNAME);
aWndClass = RegisterClass( &xClass );
dwErr = GetLastError();
Assert(0 != aWndClass);
return 0 == aWndClass ? S_FALSE : S_OK;
}