windows-xp/Source/XPSP1/NT/com/mobile/syncmgr/exe/msg.cpp

//+-------------------------------------------------------------------------
//
//  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;
}