2187 lines
60 KiB
C++
2187 lines
60 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1998.
|
|
//
|
|
// File: Hndlrq.cpp
|
|
//
|
|
// Contents: Implements class for keeping track of handlers
|
|
// and the UI associated with them
|
|
//
|
|
// Classes: CHndlrQueue
|
|
//
|
|
// History: 05-Nov-97 rogerg Created.
|
|
// 17-Nov-97 susia Moved to onestop dll for settings.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "precomp.h"
|
|
extern DWORD g_dwPlatformId;
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::CHndlrQueue(QUEUETYPE QueueType)
|
|
//
|
|
// PURPOSE: CHndlrQueue constructor
|
|
//
|
|
// COMMENTS: Implemented on main thread.
|
|
//
|
|
// History: 01-01-98 susia Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
CHndlrQueue::CHndlrQueue(QUEUETYPE QueueType)
|
|
{
|
|
m_cRef = 1;
|
|
m_pFirstHandler = NULL;
|
|
m_wHandlerCount = 0;
|
|
m_QueueType = QueueType;
|
|
m_ConnectionList = NULL;
|
|
m_ConnectionCount = 0;
|
|
m_fItemsMissing = FALSE;
|
|
InitializeCriticalSection(&m_CriticalSection);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::AddRef()
|
|
//
|
|
// PURPOSE: AddRef
|
|
//
|
|
// History: 30-Mar-98 susia Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) CHndlrQueue::AddRef()
|
|
{
|
|
TRACE("CHndlrQueue::AddRef()\r\n");
|
|
return ++m_cRef;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::Release()
|
|
//
|
|
// PURPOSE: Release
|
|
//
|
|
// History: 30-Mar-98 susia Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) CHndlrQueue::Release()
|
|
{
|
|
TRACE("CHndlrQueue::Release()\r\n");
|
|
if (--m_cRef)
|
|
return m_cRef;
|
|
|
|
FreeAllHandlers();
|
|
delete this;
|
|
return 0L;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::~CHndlrQueue()
|
|
//
|
|
// PURPOSE: CHndlrQueue destructor
|
|
//
|
|
// COMMENTS: Implemented on main thread.
|
|
//
|
|
// History: 01-01-98 susia Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
CHndlrQueue::~CHndlrQueue()
|
|
{
|
|
Assert(NULL == m_pFirstHandler); // all items should be freed at this point.
|
|
DeleteCriticalSection(&m_CriticalSection);
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::AddHandler(REFCLSID clsidHandler, WORD *wHandlerId)
|
|
//
|
|
// PURPOSE: Add a handler to the queue
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// History: 01-01-98 susia Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::AddHandler(REFCLSID clsidHandler, WORD *wHandlerId)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
LPHANDLERINFO pnewHandlerInfo;
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
|
|
// first see if we already have this handler in the queue.
|
|
// find first handler that matches the request CLSID
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo )
|
|
{
|
|
if (clsidHandler == pCurHandlerInfo->clsidHandler)
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
//didn't find the handler in the queue, add it now.
|
|
pnewHandlerInfo = (LPHANDLERINFO) ALLOC(sizeof(HANDLERINFO));
|
|
|
|
if (pnewHandlerInfo)
|
|
{
|
|
// initialize
|
|
memset(pnewHandlerInfo,0,sizeof(HANDLERINFO));
|
|
pnewHandlerInfo->HandlerState = HANDLERSTATE_CREATE;
|
|
pnewHandlerInfo->wHandlerId = ++m_wHandlerCount;
|
|
|
|
// add to end of list and set wHandlerId. End of list since in choice dialog want
|
|
// first writer wins so don't have to continue searches when setting item state.
|
|
if (NULL == m_pFirstHandler)
|
|
{
|
|
m_pFirstHandler = pnewHandlerInfo;
|
|
}
|
|
else
|
|
{
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo->pNextHandler)
|
|
{
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
pCurHandlerInfo->pNextHandler = pnewHandlerInfo;
|
|
}
|
|
|
|
*wHandlerId = pnewHandlerInfo->wHandlerId;
|
|
|
|
hr = NOERROR;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::RemoveHandler(WORD wHandlerId)
|
|
//
|
|
// PURPOSE: Release a handler from the queue
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// History: 09-23-98 susia Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::RemoveHandler(WORD wHandlerId)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
LPHANDLERINFO pPrevHandlerInfo;
|
|
LPHANDLERINFO pCurHandlerInfo;
|
|
LPITEMLIST pCurItem = NULL;
|
|
LPITEMLIST pNextItem = NULL;
|
|
|
|
pCurHandlerInfo = pPrevHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo && (pCurHandlerInfo->wHandlerId != wHandlerId))
|
|
{
|
|
pPrevHandlerInfo = pCurHandlerInfo;
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
if (pCurHandlerInfo)
|
|
{
|
|
//Update the first node if necessary
|
|
if (pCurHandlerInfo == m_pFirstHandler)
|
|
{
|
|
m_pFirstHandler = m_pFirstHandler->pNextHandler;
|
|
}
|
|
//Fix up linked list
|
|
pPrevHandlerInfo->pNextHandler = pCurHandlerInfo->pNextHandler;
|
|
|
|
|
|
//Free the handler items if there are any
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
while (pCurItem)
|
|
{
|
|
FREE(pCurItem->pItemCheckState);
|
|
pNextItem = pCurItem->pnextItem;
|
|
FREE(pCurItem);
|
|
pCurItem = pNextItem;
|
|
}
|
|
|
|
//Release the handler
|
|
if (pCurHandlerInfo->pSyncMgrHandler)
|
|
{
|
|
pCurHandlerInfo->pSyncMgrHandler->Release();
|
|
}
|
|
|
|
FREE(pCurHandlerInfo);
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::FreeAllHandlers(void)
|
|
//
|
|
// PURPOSE: loops through all the Handlers and frees them
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// History: 01-01-98 susia Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::FreeAllHandlers(void)
|
|
{
|
|
HANDLERINFO HandlerInfoStart;
|
|
LPHANDLERINFO pPrevHandlerInfo = &HandlerInfoStart;
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
LPITEMLIST pCurItem = NULL;
|
|
LPITEMLIST pNextItem = NULL;
|
|
|
|
if (m_ConnectionList)
|
|
{
|
|
FREE(m_ConnectionList);
|
|
m_ConnectionList = NULL;
|
|
}
|
|
pPrevHandlerInfo->pNextHandler = m_pFirstHandler;
|
|
|
|
while (pPrevHandlerInfo->pNextHandler)
|
|
{
|
|
pCurHandlerInfo = pPrevHandlerInfo->pNextHandler;
|
|
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
while (pCurItem)
|
|
{
|
|
FREE(pCurItem->pItemCheckState);
|
|
pNextItem = pCurItem->pnextItem;
|
|
FREE(pCurItem);
|
|
pCurItem = pNextItem;
|
|
}
|
|
|
|
pPrevHandlerInfo->pNextHandler = pCurHandlerInfo->pNextHandler;
|
|
if (pCurHandlerInfo->pSyncMgrHandler)
|
|
{
|
|
pCurHandlerInfo->pSyncMgrHandler->Release();
|
|
}
|
|
FREE(pCurHandlerInfo);
|
|
}
|
|
|
|
// update the pointer to the first handler item
|
|
m_pFirstHandler = HandlerInfoStart.pNextHandler;
|
|
Assert(NULL == m_pFirstHandler); // should always have released everything.
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CHndlrQueue::GetHandlerInfo, public
|
|
//
|
|
// Synopsis: Gets Data associated with the HandlerID and ItemID
|
|
//
|
|
// Arguments: [wHandlerId] - Id Of Handler the Item belongs too
|
|
//
|
|
// Returns: Appropriate return codes
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 17-Nov-97 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::GetHandlerInfo(REFCLSID clsidHandler,
|
|
LPSYNCMGRHANDLERINFO pSyncMgrHandlerInfo)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
// find first handler that matches the request CLSID
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo )
|
|
{
|
|
if (clsidHandler == pCurHandlerInfo->clsidHandler)
|
|
{
|
|
*pSyncMgrHandlerInfo = pCurHandlerInfo->SyncMgrHandlerInfo;
|
|
hr = NOERROR;
|
|
break;
|
|
}
|
|
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION:CHndlrQueue::GetSyncItemDataOnConnection(int iConnectionIndex,
|
|
// WORD wHandlerId,
|
|
// WORD wItemID,
|
|
// CLSID *pclsidHandler,
|
|
// SYNCMGRITEM* offlineItem,
|
|
// ITEMCHECKSTATE *pItemCheckState,
|
|
// BOOL fSchedSync,
|
|
// BOOL fClear)
|
|
//
|
|
// PURPOSE: Get the item data per connection
|
|
//
|
|
// COMMENTS: Ras implementation is based on names. Switch to GUIDs for Connection
|
|
// objects
|
|
//
|
|
// History: 01-01-98 susia Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::GetSyncItemDataOnConnection(
|
|
int iConnectionIndex,
|
|
WORD wHandlerId, WORD wItemID,
|
|
CLSID *pclsidHandler,
|
|
SYNCMGRITEM* offlineItem,
|
|
ITEMCHECKSTATE *pItemCheckState,
|
|
BOOL fSchedSync,
|
|
BOOL fClear)
|
|
{
|
|
BOOL fFoundMatch = FALSE;
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
LPITEMLIST pCurItem = NULL;
|
|
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo && !fFoundMatch)
|
|
{
|
|
// only valid if Hanlder is in the PrepareForSync state.
|
|
if (wHandlerId == pCurHandlerInfo->wHandlerId) // see if CLSID matches
|
|
{
|
|
// see if handler info has a matching item
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
if (wItemID == pCurItem->wItemId)
|
|
{
|
|
fFoundMatch = TRUE;
|
|
break;
|
|
}
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
}
|
|
if (!fFoundMatch)
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
if (fFoundMatch)
|
|
{
|
|
if (pclsidHandler)
|
|
{
|
|
*pclsidHandler = pCurHandlerInfo->clsidHandler;
|
|
}
|
|
if (offlineItem)
|
|
{
|
|
*offlineItem = pCurItem->offlineItem;
|
|
}
|
|
|
|
if (pItemCheckState)
|
|
{
|
|
if (fSchedSync)
|
|
{
|
|
Assert(0 == iConnectionIndex);
|
|
|
|
//if only holding on connection's settings at a time
|
|
if (fClear)
|
|
{
|
|
pCurItem->pItemCheckState[iConnectionIndex].dwSchedule = SYNCMGRITEMSTATE_UNCHECKED;
|
|
}
|
|
}
|
|
else //AutoSync
|
|
{
|
|
Assert((iConnectionIndex>=0) && (iConnectionIndex < m_ConnectionCount))
|
|
}
|
|
|
|
*pItemCheckState = pCurItem->pItemCheckState[iConnectionIndex];
|
|
}
|
|
}
|
|
|
|
return fFoundMatch ? NOERROR : S_FALSE;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// STDMETHODIMP CHndlrQueue::GetItemIcon(WORD wHandlerId, WORD wItemID, HICON *phIcon)
|
|
//
|
|
// PURPOSE: Get the item icon
|
|
//
|
|
// History: 03-13-98 susia Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::GetItemIcon(WORD wHandlerId,
|
|
WORD wItemID,
|
|
HICON *phIcon)
|
|
{
|
|
BOOL fFoundMatch = FALSE;
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
LPITEMLIST pCurItem = NULL;
|
|
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo && !fFoundMatch)
|
|
{
|
|
if (wHandlerId == pCurHandlerInfo->wHandlerId) // see if CLSID matches
|
|
{
|
|
// see if handler info has a matching item
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
if (wItemID == pCurItem->wItemId)
|
|
{
|
|
fFoundMatch = TRUE;
|
|
break;
|
|
}
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
}
|
|
if (!fFoundMatch)
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
if (fFoundMatch)
|
|
{
|
|
if (phIcon)
|
|
{
|
|
*phIcon = pCurItem->offlineItem.hIcon;
|
|
}
|
|
}
|
|
|
|
return fFoundMatch ? NOERROR : S_FALSE;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// STDMETHODIMP CHndlrQueue::GetItemName(WORD wHandlerId, WORD wItemID, WCHAR *pwszName)
|
|
//
|
|
// PURPOSE: Get the item Name
|
|
//
|
|
// History: 03-13-98 susia Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::GetItemName(WORD wHandlerId,
|
|
WORD wItemID,
|
|
WCHAR *pwszName)
|
|
{
|
|
BOOL fFoundMatch = FALSE;
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
LPITEMLIST pCurItem = NULL;
|
|
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo && !fFoundMatch)
|
|
{
|
|
if (wHandlerId == pCurHandlerInfo->wHandlerId) // see if CLSID matches
|
|
{
|
|
// see if handler info has a matching item
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
if (wItemID == pCurItem->wItemId)
|
|
{
|
|
fFoundMatch = TRUE;
|
|
break;
|
|
}
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
}
|
|
if (!fFoundMatch)
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
if (fFoundMatch)
|
|
{
|
|
if (pwszName)
|
|
{
|
|
lstrcpy(pwszName, pCurItem->offlineItem.wszItemName);
|
|
}
|
|
}
|
|
|
|
return fFoundMatch ? NOERROR : S_FALSE;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::FindFirstHandlerInState(HANDLERSTATE hndlrState,WORD *wHandlerID)
|
|
//
|
|
// PURPOSE: finds first handler it comes across in the state
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::FindFirstHandlerInState(HANDLERSTATE hndlrState,WORD *wHandlerID)
|
|
{
|
|
return FindNextHandlerInState(0,hndlrState,wHandlerID);
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::FindNextHandlerInState(WORD wLastHandlerID,
|
|
// HANDLERSTATE hndlrState,WORD *wHandlerID)
|
|
//
|
|
// PURPOSE: finds next handler after LasthandlerID in the queue that matches
|
|
// the requested state.
|
|
//
|
|
// COMMENTS: passing in 0 for the LasthandlerID is the same as calling
|
|
// FindFirstHandlerInState
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::FindNextHandlerInState(WORD wLastHandlerID,HANDLERSTATE hndlrState,WORD *wHandlerID)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
LPHANDLERINFO pCurHandler;
|
|
|
|
*wHandlerID = 0;
|
|
|
|
pCurHandler = m_pFirstHandler;
|
|
|
|
if (0 != wLastHandlerID)
|
|
{
|
|
// loop foward until find the last handlerID we checked or hit the end
|
|
while (pCurHandler)
|
|
{
|
|
if (wLastHandlerID == pCurHandler->wHandlerId)
|
|
{
|
|
break;
|
|
}
|
|
pCurHandler = pCurHandler->pNextHandler;
|
|
}
|
|
if (NULL == pCurHandler)
|
|
return S_FALSE;
|
|
|
|
pCurHandler = pCurHandler->pNextHandler; // increment to next handler.
|
|
}
|
|
|
|
while (pCurHandler)
|
|
{
|
|
if (hndlrState == pCurHandler->HandlerState)
|
|
{
|
|
*wHandlerID = pCurHandler->wHandlerId;
|
|
hr = S_OK;
|
|
break;
|
|
}
|
|
pCurHandler = pCurHandler->pNextHandler;
|
|
}
|
|
return hr;
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::FindFirstItemOnConnection
|
|
// (TCHAR *pszConnectionName,
|
|
// CLSID *pclsidHandler,
|
|
// SYNCMGRITEMID* OfflineItemID,
|
|
// WORD *wHandlerId,
|
|
// WORD *wItemID)
|
|
//
|
|
// PURPOSE: find first ListView Item that can sync over the specified
|
|
// connection and return its clsid and ItemID
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::FindFirstItemOnConnection
|
|
(TCHAR *pszConnectionName,
|
|
CLSID *pclsidHandler,
|
|
SYNCMGRITEMID* OfflineItemID,
|
|
WORD *pwHandlerId,
|
|
WORD *pwItemID)
|
|
{
|
|
DWORD dwCheckState;
|
|
|
|
|
|
return FindNextItemOnConnection
|
|
(pszConnectionName,0,0,pclsidHandler,
|
|
OfflineItemID, pwHandlerId, pwItemID,
|
|
TRUE, &dwCheckState);
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::FindNextItemOnConnection
|
|
// (TCHAR *pszConnectionName,
|
|
// WORD wLastHandlerId,
|
|
// WORD wLastItemID,
|
|
// CLSID *pclsidHandler,
|
|
// SYNCMGRITEMID* OfflineItemID,
|
|
// WORD *pwHandlerId,
|
|
// WORD *pwItemID,
|
|
// BOOL fAllHandlers,
|
|
// DWORD *pdwCheckState)
|
|
//
|
|
//
|
|
//
|
|
// PURPOSE: starts on the next item after the specified Handler and ItemID
|
|
// setting the last HandlerID to 0 is the same as calling
|
|
// FindFirstItemOnConnection
|
|
//
|
|
// COMMENTS: For now, no Handler can specifiy that it can or cannot sync over a
|
|
// connection, so assume it can, and ignore the connection.
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::FindNextItemOnConnection
|
|
(TCHAR *pszConnectionName,
|
|
WORD wLastHandlerId,
|
|
WORD wLastItemID,
|
|
CLSID *pclsidHandler,
|
|
SYNCMGRITEMID* OfflineItemID,
|
|
WORD *pwHandlerId,
|
|
WORD *pwItemID,
|
|
BOOL fAllHandlers,
|
|
DWORD *pdwCheckState)
|
|
|
|
|
|
{
|
|
BOOL fFoundMatch = FALSE;
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
LPITEMLIST pCurItem = NULL;
|
|
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
if (!pCurHandlerInfo)
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
if (0 != wLastHandlerId)
|
|
{
|
|
// loop until find the specified handler or hit end of list.
|
|
while(pCurHandlerInfo && wLastHandlerId != pCurHandlerInfo->wHandlerId)
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
|
|
if (NULL == pCurHandlerInfo) // reached end of list without finding the Handler
|
|
{
|
|
Assert(0); // user must have passed an invalid start HandlerID.
|
|
return S_FALSE;
|
|
}
|
|
}
|
|
|
|
// loop until find item or end of item list
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
|
|
if (0 != wLastItemID)
|
|
{
|
|
while (pCurItem && pCurItem->wItemId != wLastItemID)
|
|
{
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
if (NULL == pCurItem) // reached end of item list without finding the specified item
|
|
{
|
|
Assert(0); // user must have passed an invalid start ItemID.
|
|
return S_FALSE;
|
|
}
|
|
|
|
// now we found the Handler and item. loop through remaining items for this handler and
|
|
// see if there is a match
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
//Found the item on this handler
|
|
if (pCurItem)
|
|
{
|
|
fFoundMatch = TRUE;
|
|
}
|
|
|
|
//If we are to move beyond this handler, do so now, else we are done
|
|
if (!fFoundMatch && fAllHandlers)
|
|
{
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler; // increment to next handler if no match
|
|
}
|
|
|
|
if ((FALSE == fFoundMatch) && fAllHandlers)
|
|
{
|
|
while (pCurHandlerInfo && !fFoundMatch)
|
|
{
|
|
// see if handler info has a matching item
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
|
|
if (pCurItem)
|
|
fFoundMatch = TRUE;
|
|
|
|
if (!fFoundMatch)
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
}
|
|
|
|
if (fFoundMatch)
|
|
{
|
|
*pclsidHandler = pCurHandlerInfo->clsidHandler;
|
|
*OfflineItemID = pCurItem->offlineItem.ItemID;
|
|
*pwHandlerId = pCurHandlerInfo->wHandlerId;
|
|
*pwItemID = pCurItem->wItemId;
|
|
*pdwCheckState = pCurItem->pItemCheckState[0].dwSchedule;
|
|
}
|
|
|
|
return fFoundMatch ? NOERROR : S_FALSE;
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::GetHandlerIDFromClsid
|
|
// (REFCLSID clsidHandlerIn,
|
|
// WORD *pwHandlerId)
|
|
//
|
|
// PURPOSE: get the HnadlerID from the CLSID
|
|
//
|
|
// COMMENTS: if the Handler is GUID_NULL enumerate all
|
|
//
|
|
// HISTORY: 03-09-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::GetHandlerIDFromClsid
|
|
(REFCLSID clsidHandlerIn,
|
|
WORD *pwHandlerId)
|
|
{
|
|
LPHANDLERINFO pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
Assert(pwHandlerId);
|
|
|
|
if (clsidHandlerIn == GUID_NULL)
|
|
{
|
|
*pwHandlerId = 0;
|
|
return S_OK;
|
|
|
|
}
|
|
while (pCurHandlerInfo && (clsidHandlerIn != pCurHandlerInfo->clsidHandler))
|
|
{
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
if (NULL == pCurHandlerInfo) // reached end of list without finding the Handler
|
|
{
|
|
*pwHandlerId = 0;
|
|
Assert(0); // user must have passed an invalid start HandlerID.
|
|
return S_FALSE;
|
|
}
|
|
|
|
*pwHandlerId = pCurHandlerInfo->wHandlerId;
|
|
|
|
return S_OK;
|
|
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::SetItemListViewID(CLSID clsidHandler,
|
|
// SYNCMGRITEMID OfflineItemID,INT iItem)
|
|
//
|
|
// PURPOSE: assigns all items that match the handler clsid and
|
|
// ItemID this listView Value.
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::SetItemListViewID(CLSID clsidHandler,
|
|
SYNCMGRITEMID OfflineItemID,INT iItem)
|
|
{
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
LPITEMLIST pCurItem = NULL;
|
|
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo )
|
|
{
|
|
if (clsidHandler == pCurHandlerInfo->clsidHandler)
|
|
{
|
|
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
if (OfflineItemID == pCurItem->offlineItem.ItemID)
|
|
{
|
|
// This can be called at anytime after prepareforSync if a duplicate
|
|
// is added later to the choice or progress bar.
|
|
// found a match
|
|
pCurItem->iItem = iItem;
|
|
}
|
|
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
}
|
|
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
return NOERROR;
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: DWORD CHndlrQueue::GetCheck(WORD wParam, INT iItem)
|
|
//
|
|
// PURPOSE: Return the check state for the logon, logoff and
|
|
// prompt me first check boxes on the connection number iItem
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
DWORD CHndlrQueue::GetCheck(WORD wParam, INT iItem)
|
|
{
|
|
// if no connection list all items are unchecked
|
|
if (!m_ConnectionList)
|
|
return 0;
|
|
|
|
switch (wParam)
|
|
{
|
|
case IDC_AUTOLOGON:
|
|
return m_ConnectionList[iItem].dwLogon;
|
|
break;
|
|
case IDC_AUTOLOGOFF:
|
|
return m_ConnectionList[iItem].dwLogoff;
|
|
break;
|
|
case IDC_AUTOPROMPT_ME_FIRST:
|
|
return m_ConnectionList[iItem].dwPromptMeFirst;
|
|
break;
|
|
case IDC_AUTOREADONLY:
|
|
return m_ConnectionList->dwReadOnly;
|
|
break;
|
|
case IDC_AUTOHIDDEN:
|
|
return m_ConnectionList->dwHidden;
|
|
break;
|
|
case IDC_AUTOCONNECT:
|
|
return m_ConnectionList->dwMakeConnection;
|
|
break;
|
|
case IDC_IDLECHECKBOX:
|
|
return m_ConnectionList[iItem].dwIdleEnabled;
|
|
|
|
default:
|
|
AssertSz(0,"Unkown SetConnectionCheckBox");
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: DWORD CHndlrQueue::SetConnectionCheck(WORD wParam, DWORD dwState,
|
|
// INT iConnectionItem)
|
|
//
|
|
// PURPOSE: Set the check state for the logon, logoff and
|
|
// prompt me first check boxes on the connection number iConnectionItem
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::SetConnectionCheck(WORD wParam, DWORD dwState, INT iConnectionItem)
|
|
{
|
|
|
|
// if no connection list then just return
|
|
if (!m_ConnectionList)
|
|
return E_OUTOFMEMORY;
|
|
|
|
switch (wParam)
|
|
{
|
|
case IDC_AUTOLOGON:
|
|
m_ConnectionList[iConnectionItem].dwLogon = dwState;
|
|
break;
|
|
case IDC_AUTOLOGOFF:
|
|
m_ConnectionList[iConnectionItem].dwLogoff = dwState;
|
|
break;
|
|
case IDC_AUTOPROMPT_ME_FIRST:
|
|
m_ConnectionList[iConnectionItem].dwPromptMeFirst = dwState;
|
|
break;
|
|
case IDC_IDLECHECKBOX:
|
|
m_ConnectionList[iConnectionItem].dwIdleEnabled = dwState;
|
|
break;
|
|
// these two sare for schedule
|
|
case IDC_AUTOHIDDEN:
|
|
m_ConnectionList->dwHidden = dwState;
|
|
break;
|
|
case IDC_AUTOREADONLY:
|
|
m_ConnectionList->dwReadOnly = dwState;
|
|
break;
|
|
case IDC_AUTOCONNECT:
|
|
m_ConnectionList->dwMakeConnection = dwState;
|
|
break;
|
|
default:
|
|
AssertSz(0,"Unkown SetConnectionCheckBox");
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::SetSyncCheckStateFromListViewItem(
|
|
// DWORD dwSyncType,
|
|
// INT iItem,
|
|
// BOOL fChecked,
|
|
// INT iConnectionItem)
|
|
//
|
|
//
|
|
// PURPOSE: finds item with this listview ID and sets it appropriately.
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::SetSyncCheckStateFromListViewItem(SYNCTYPE SyncType,
|
|
INT iItem,
|
|
BOOL fChecked,
|
|
INT iConnectionItem)
|
|
{
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
LPITEMLIST pCurItem = NULL;
|
|
DWORD dwState;
|
|
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
dwState = fChecked ? SYNCMGRITEMSTATE_CHECKED : SYNCMGRITEMSTATE_UNCHECKED;
|
|
|
|
while (pCurHandlerInfo )
|
|
{
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
if (iItem == pCurItem->iItem)
|
|
{
|
|
switch(SyncType)
|
|
{
|
|
case SYNCTYPE_AUTOSYNC:
|
|
pCurItem->pItemCheckState[iConnectionItem].dwAutoSync = dwState;
|
|
break;
|
|
case SYNCTYPE_IDLE:
|
|
pCurItem->pItemCheckState[iConnectionItem].dwIdle = dwState;
|
|
break;
|
|
case SYNCTYPE_SCHEDULED:
|
|
pCurItem->pItemCheckState[iConnectionItem].dwSchedule = dwState;
|
|
break;
|
|
default:
|
|
AssertSz(0,"Unknown Setting type");
|
|
break;
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
Assert(0); // review - better assert but warn us when try to set a listView item that isn't assigned.
|
|
return S_FALSE; // item wasn't found
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::ListViewItemHasProperties(INT iItem)
|
|
//
|
|
// PURPOSE: determines if there are properties associated with this item.
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::ListViewItemHasProperties(INT iItem)
|
|
{
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
LPITEMLIST pCurItem = NULL;
|
|
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo )
|
|
{
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
if (iItem == pCurItem->iItem)
|
|
{
|
|
|
|
Assert(HANDLERSTATE_PREPAREFORSYNC == pCurHandlerInfo->HandlerState);
|
|
|
|
return pCurItem->offlineItem.dwFlags & SYNCMGRITEM_HASPROPERTIES
|
|
? NOERROR : S_FALSE;
|
|
}
|
|
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
// Assert(-1 == iItem); // if don't find item, should be because user clicked in list box where there was none
|
|
return S_FALSE; // item wasn't found
|
|
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::ShowProperties(HWND hwndParent,INT iItem)
|
|
//
|
|
// PURPOSE: find the first item in the queueu with the assigned iItem and
|
|
// call there show properties method.
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::ShowProperties(HWND hwndParent,INT iItem)
|
|
{
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
LPITEMLIST pCurItem = NULL;
|
|
|
|
AssertSz(0,"ShowProperties Called from Setttings");
|
|
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo )
|
|
{
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
if (iItem == pCurItem->iItem)
|
|
{
|
|
Assert(HANDLERSTATE_PREPAREFORSYNC == pCurHandlerInfo->HandlerState);
|
|
|
|
// UI shouldn't call this unless item actually has a properties flag
|
|
Assert(SYNCMGRITEM_HASPROPERTIES & pCurItem->offlineItem.dwFlags);
|
|
|
|
// make sure properties flag isn't set.
|
|
if ( (SYNCMGRITEM_HASPROPERTIES & pCurItem->offlineItem.dwFlags))
|
|
{
|
|
return pCurHandlerInfo->pSyncMgrHandler->
|
|
ShowProperties(hwndParent,
|
|
(pCurItem->offlineItem.ItemID));
|
|
}
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
Assert(0); // review - better assert but wanr us when try to set a listView item that isn't assigned.
|
|
return S_FALSE; // item wasn't found
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::CreateServer(WORD wHandlerId, const CLSID *pCLSIDServer)
|
|
//
|
|
// PURPOSE: Create the Handler server
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::CreateServer(WORD wHandlerId, const CLSID *pCLSIDServer)
|
|
{
|
|
HRESULT hr = NO_ERROR; // review for Lookup failures
|
|
LPHANDLERINFO pHandlerInfo = NULL;
|
|
LPUNKNOWN pUnk;
|
|
|
|
hr = LookupHandlerFromId(wHandlerId,&pHandlerInfo);
|
|
if (hr == NOERROR)
|
|
{
|
|
if (HANDLERSTATE_CREATE != pHandlerInfo->HandlerState)
|
|
{
|
|
Assert(HANDLERSTATE_CREATE == pHandlerInfo->HandlerState);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
pHandlerInfo->HandlerState = HANDLERSTATE_INCREATE;
|
|
|
|
pHandlerInfo->clsidHandler = *pCLSIDServer;
|
|
hr = CoCreateInstance(pHandlerInfo->clsidHandler,
|
|
NULL, CLSCTX_INPROC_SERVER,
|
|
IID_IUnknown, (void **) &pUnk);
|
|
|
|
if (NOERROR == hr)
|
|
{
|
|
hr = pUnk->QueryInterface(IID_ISyncMgrSynchronize,
|
|
(void **) &pHandlerInfo->pSyncMgrHandler);
|
|
|
|
pUnk->Release();
|
|
}
|
|
|
|
|
|
if (NOERROR == hr)
|
|
{
|
|
pHandlerInfo->HandlerState = HANDLERSTATE_INITIALIZE;
|
|
}
|
|
else
|
|
{
|
|
pHandlerInfo->pSyncMgrHandler = NULL;
|
|
pHandlerInfo->HandlerState = HANDLERSTATE_DEAD;
|
|
}
|
|
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::Initialize(WORD wHandlerId,DWORD dwReserved,DWORD dwSyncFlags,
|
|
// DWORD cbCookie,const BYTE *lpCookie)
|
|
//
|
|
// PURPOSE: Initialize the handler
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::Initialize(WORD wHandlerId,DWORD dwReserved,DWORD dwSyncFlags,
|
|
DWORD cbCookie,const BYTE *lpCookie)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED; // review for Lookup failures
|
|
LPHANDLERINFO pHandlerInfo = NULL;
|
|
|
|
if (NOERROR == LookupHandlerFromId(wHandlerId,&pHandlerInfo))
|
|
{
|
|
if (HANDLERSTATE_INITIALIZE != pHandlerInfo->HandlerState)
|
|
{
|
|
Assert(HANDLERSTATE_INITIALIZE == pHandlerInfo->HandlerState);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
pHandlerInfo->HandlerState = HANDLERSTATE_ININITIALIZE;
|
|
|
|
Assert(pHandlerInfo->pSyncMgrHandler);
|
|
|
|
if (NULL != pHandlerInfo->pSyncMgrHandler)
|
|
{
|
|
hr = pHandlerInfo->pSyncMgrHandler->Initialize(dwReserved,dwSyncFlags,cbCookie,lpCookie);
|
|
}
|
|
|
|
if (NOERROR == hr)
|
|
{
|
|
pHandlerInfo->HandlerState = HANDLERSTATE_ADDHANDLERTEMS;
|
|
pHandlerInfo->dwSyncFlags = dwSyncFlags;
|
|
}
|
|
else
|
|
{
|
|
// on an error, go ahead and release the proxy if server doesn't want to handle
|
|
pHandlerInfo->HandlerState = HANDLERSTATE_DEAD;
|
|
}
|
|
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::AddHandlerItemsToQueue(WORD wHandlerId)
|
|
//
|
|
// PURPOSE: Enumerate the handler items and add them to the queue
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::AddHandlerItemsToQueue(WORD wHandlerId)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED; // review for Lookup failures
|
|
LPHANDLERINFO pHandlerInfo = NULL;
|
|
LPSYNCMGRENUMITEMS pEnumOffline = NULL;
|
|
|
|
if (NOERROR == LookupHandlerFromId(wHandlerId,&pHandlerInfo))
|
|
{
|
|
if (HANDLERSTATE_ADDHANDLERTEMS != pHandlerInfo->HandlerState)
|
|
{
|
|
Assert(HANDLERSTATE_ADDHANDLERTEMS == pHandlerInfo->HandlerState);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
pHandlerInfo->HandlerState = HANDLERSTATE_INADDHANDLERITEMS;
|
|
|
|
Assert(pHandlerInfo->pSyncMgrHandler);
|
|
|
|
if (pHandlerInfo->pSyncMgrHandler)
|
|
{
|
|
hr = pHandlerInfo->pSyncMgrHandler->EnumSyncMgrItems(&pEnumOffline);
|
|
|
|
if ( ((NOERROR == hr) || (S_SYNCMGR_MISSINGITEMS == hr)) && pEnumOffline)
|
|
{
|
|
SYNCMGRITEMNT5B2 offItem; // temporarily use NT5B2 structure since its bigger
|
|
ULONG pceltFetched;
|
|
|
|
// add the handler info
|
|
SYNCMGRHANDLERINFO *pSyncMgrHandlerInfo = NULL;
|
|
|
|
// update missing items info
|
|
m_fItemsMissing |= (S_SYNCMGR_MISSINGITEMS == hr);
|
|
|
|
hr = pHandlerInfo->pSyncMgrHandler->GetHandlerInfo(&pSyncMgrHandlerInfo);
|
|
if (NOERROR == hr && pSyncMgrHandlerInfo)
|
|
{
|
|
if (IsValidSyncMgrHandlerInfo(pSyncMgrHandlerInfo))
|
|
{
|
|
SetHandlerInfo(wHandlerId,pSyncMgrHandlerInfo);
|
|
}
|
|
|
|
CoTaskMemFree(pSyncMgrHandlerInfo);
|
|
}
|
|
|
|
// Get this handlers registration flags
|
|
BOOL fReg;
|
|
|
|
fReg = RegGetHandlerRegistrationInfo(pHandlerInfo->clsidHandler,
|
|
&(pHandlerInfo->dwRegistrationFlags));
|
|
|
|
// rely on RegGetHandler to set flags to zero on error
|
|
// so assert that it does
|
|
Assert(fReg || (0 == pHandlerInfo->dwRegistrationFlags));
|
|
|
|
|
|
hr = NOERROR; // okay to add items even if Gethandler info fails
|
|
|
|
Assert(sizeof(SYNCMGRITEMNT5B2) > sizeof(SYNCMGRITEM));
|
|
|
|
// sit in loop getting data of objects to fill list box.
|
|
// should really set up list in memory for OneStop to fill in or
|
|
// main thread could pass in a callback interface.
|
|
|
|
while(NOERROR == pEnumOffline->Next(1,(SYNCMGRITEM *) &offItem,&pceltFetched))
|
|
{
|
|
// don't add the item if temporary.
|
|
if (!(offItem.dwFlags & SYNCMGRITEM_TEMPORARY))
|
|
{
|
|
AddItemToHandler(wHandlerId,(SYNCMGRITEM *) &offItem);
|
|
}
|
|
}
|
|
|
|
pEnumOffline->Release();
|
|
}
|
|
}
|
|
|
|
if (NOERROR == hr)
|
|
{
|
|
pHandlerInfo->HandlerState = HANDLERSTATE_PREPAREFORSYNC;
|
|
}
|
|
else
|
|
{
|
|
pHandlerInfo->HandlerState = HANDLERSTATE_DEAD;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CHndlrQueue::SetHandlerInfo, public
|
|
//
|
|
// Synopsis: Adds item to the specified handler.
|
|
// Called in context of the handlers thread.
|
|
//
|
|
// Arguments: [pHandlerId] - Id of handler.
|
|
// [pSyncMgrHandlerInfo] - Points to SyncMgrHandlerInfo to be filled in.
|
|
//
|
|
// Returns: Appropriate Error code
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 28-Jul-98 rogerg Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::SetHandlerInfo(WORD wHandlerId,LPSYNCMGRHANDLERINFO pSyncMgrHandlerInfo)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED;
|
|
LPHANDLERINFO pHandlerInfo = NULL;
|
|
|
|
if (!pSyncMgrHandlerInfo)
|
|
{
|
|
return E_INVALIDARG;
|
|
Assert(pSyncMgrHandlerInfo);
|
|
}
|
|
|
|
|
|
if (NOERROR == LookupHandlerFromId(wHandlerId,&pHandlerInfo))
|
|
{
|
|
if (HANDLERSTATE_INADDHANDLERITEMS != pHandlerInfo->HandlerState)
|
|
{
|
|
Assert(HANDLERSTATE_INADDHANDLERITEMS == pHandlerInfo->HandlerState);
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
|
|
// Review - After clients update turn
|
|
// this check back on
|
|
if (0 /* pSyncMgrHandlerInfo->cbSize != sizeof(SYNCMGRHANDLERINFO) */)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
pHandlerInfo->SyncMgrHandlerInfo = *pSyncMgrHandlerInfo;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::AddItemToHandler(WORD wHandlerId,SYNCMGRITEM *pOffineItem)
|
|
//
|
|
// PURPOSE: Add the handler's items
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::AddItemToHandler(WORD wHandlerId,SYNCMGRITEM *pOffineItem)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED; // review for Lookup failures
|
|
LPHANDLERINFO pHandlerInfo = NULL;
|
|
LPITEMLIST pNewItem = NULL;
|
|
|
|
if (!IsValidSyncMgrItem(pOffineItem))
|
|
{
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
if (NOERROR == LookupHandlerFromId(wHandlerId,&pHandlerInfo))
|
|
{
|
|
if (HANDLERSTATE_INADDHANDLERITEMS != pHandlerInfo->HandlerState)
|
|
{
|
|
Assert(HANDLERSTATE_INADDHANDLERITEMS == pHandlerInfo->HandlerState);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
// Allocate the item.
|
|
pNewItem = (LPITEMLIST) ALLOC(sizeof(ITEMLIST));
|
|
|
|
if (NULL == pNewItem)
|
|
return E_OUTOFMEMORY;
|
|
|
|
memset(pNewItem,0,sizeof(ITEMLIST));
|
|
pNewItem->wItemId = ++pHandlerInfo->wItemCount;
|
|
pNewItem->pHandlerInfo = pHandlerInfo;
|
|
pNewItem->iItem = -1;
|
|
|
|
pNewItem->offlineItem = *pOffineItem;
|
|
|
|
// stick the item on the end of the list
|
|
if (NULL == pHandlerInfo->pFirstItem)
|
|
{
|
|
pHandlerInfo->pFirstItem = pNewItem;
|
|
Assert(1 == pHandlerInfo->wItemCount);
|
|
}
|
|
else
|
|
{
|
|
LPITEMLIST pCurItem;
|
|
|
|
pCurItem = pHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem->pnextItem)
|
|
pCurItem = pCurItem->pnextItem;
|
|
|
|
pCurItem->pnextItem = pNewItem;
|
|
|
|
Assert ((pCurItem->wItemId + 1) == pNewItem->wItemId);
|
|
}
|
|
|
|
hr = NOERROR;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::LookupHandlerFromId(WORD wHandlerId,
|
|
// LPHANDLERINFO *pHandlerInfo)
|
|
//
|
|
// PURPOSE: finds associated hander data from the handler ID
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::LookupHandlerFromId(WORD wHandlerId,LPHANDLERINFO *pHandlerInfo)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED; // review error code.
|
|
LPHANDLERINFO pCurItem;
|
|
|
|
*pHandlerInfo = NULL;
|
|
pCurItem = m_pFirstHandler;
|
|
|
|
while (pCurItem)
|
|
{
|
|
if (wHandlerId == pCurItem->wHandlerId )
|
|
{
|
|
*pHandlerInfo = pCurItem;
|
|
hr = NOERROR;
|
|
break;
|
|
}
|
|
|
|
pCurItem = pCurItem->pNextHandler;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::InitAutoSyncSettings(HWND hwndRasCombo)
|
|
//
|
|
// PURPOSE: Initialize the autosync settings per the connections
|
|
// listed in this RasCombo
|
|
//
|
|
// COMMENTS: Ras based (connection name as identifier) When connection object
|
|
// based, we will use the connection GUID to identify the connection
|
|
// settings
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::InitSyncSettings(SYNCTYPE syncType,HWND hwndRasCombo)
|
|
{
|
|
SCODE sc = S_OK;
|
|
int i;
|
|
|
|
// This function gets possibly gets called twice
|
|
// once for AuotSync and once for Idle if already have
|
|
// a connection list then use existing
|
|
|
|
if (NULL == m_ConnectionList)
|
|
{
|
|
m_ConnectionCount = ComboBox_GetCount(hwndRasCombo);
|
|
|
|
if (m_ConnectionCount > 0)
|
|
{
|
|
smMem(m_ConnectionList = (LPCONNECTIONSETTINGS)
|
|
ALLOC(m_ConnectionCount * sizeof(CONNECTIONSETTINGS)));
|
|
|
|
}
|
|
}
|
|
|
|
// if now have a connection list set the appropriate settings
|
|
if (m_ConnectionList)
|
|
{
|
|
COMBOBOXEXITEM comboItem;
|
|
|
|
for (i=0; i<m_ConnectionCount; i++)
|
|
{
|
|
comboItem.mask = CBEIF_TEXT;
|
|
comboItem.cchTextMax = RAS_MaxEntryName + 1;
|
|
comboItem.pszText = m_ConnectionList[i].pszConnectionName;
|
|
comboItem.iItem = i;
|
|
|
|
// Review what happens on failure
|
|
ComboEx_GetItem(hwndRasCombo,&comboItem);
|
|
|
|
switch (syncType)
|
|
{
|
|
case SYNCTYPE_AUTOSYNC:
|
|
RegGetAutoSyncSettings(&(m_ConnectionList[i]));
|
|
break;
|
|
case SYNCTYPE_IDLE:
|
|
RegGetIdleSyncSettings(&(m_ConnectionList[i]));
|
|
break;
|
|
default:
|
|
AssertSz(0,"Unknown SyncType");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
EH_Err:
|
|
return sc;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::InitSchedSyncSettings(LPCONNECTIONSETTINGS pConnectionSettings)
|
|
//
|
|
// PURPOSE: Initialize the scheduled Sync settings per the connections
|
|
// listed in this RasCombo
|
|
//
|
|
// COMMENTS: Ras based (connection name as identifier) When connection object
|
|
// based, we will use the connection GUID to identify the connection
|
|
// settings
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::InitSchedSyncSettings(LPCONNECTIONSETTINGS pConnectionSettings)
|
|
{
|
|
m_ConnectionList = pConnectionSettings;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::ReadSchedSyncSettingsPerConnection(WORD wHandlerID,
|
|
// TCHAR * pszSchedName)
|
|
//
|
|
// PURPOSE: Read the scheduled Sync settings from the registry.
|
|
// If there is no entry in the registry, the default is the
|
|
// check state of the current offline item
|
|
//
|
|
// COMMENTS: Ras based (connection name as identifier) When connection object
|
|
// based, we will use the connection GUID to identify the connection
|
|
// settings
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::ReadSchedSyncSettingsOnConnection(WORD wHandlerID,TCHAR * pszSchedName)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED; // review for Lookup failures
|
|
LPHANDLERINFO pHandlerInfo = NULL;
|
|
|
|
Assert(m_ConnectionList != NULL);
|
|
|
|
if (!m_ConnectionList)
|
|
return E_UNEXPECTED;
|
|
|
|
//Set the Check set of this item per connection
|
|
if (NOERROR == LookupHandlerFromId(wHandlerID,&pHandlerInfo))
|
|
{
|
|
LPITEMLIST pCurItem = pHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
//Scheduled sync only works on one connection
|
|
Assert(NULL == pCurItem->pItemCheckState );
|
|
|
|
pCurItem->pItemCheckState = (ITEMCHECKSTATE*) ALLOC(sizeof(ITEMCHECKSTATE));
|
|
|
|
if (!pCurItem->pItemCheckState)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
// by default no items in the schedule are checked.
|
|
pCurItem->pItemCheckState[0].dwSchedule = FALSE;
|
|
|
|
|
|
// possible for schedule name to be null when schedule first created.
|
|
if (pszSchedName)
|
|
{
|
|
|
|
RegGetSyncItemSettings(SYNCTYPE_SCHEDULED,
|
|
pHandlerInfo->clsidHandler,
|
|
pCurItem->offlineItem.ItemID,
|
|
m_ConnectionList->pszConnectionName,
|
|
&(pCurItem->pItemCheckState[0].dwSchedule),
|
|
pCurItem->offlineItem.dwItemState,
|
|
pszSchedName);
|
|
}
|
|
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
|
|
}
|
|
return hr;
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::InsertItem(LPHANDLERINFO pCurHandler,
|
|
// LPSYNC_HANDLER_ITEM_INFO pHandlerItemInfo)
|
|
//
|
|
// PURPOSE: App is programatically adding an item to the schedule
|
|
// with a default check state
|
|
//
|
|
// HISTORY: 11-25-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::InsertItem(LPHANDLERINFO pCurHandler,
|
|
LPSYNC_HANDLER_ITEM_INFO pHandlerItemInfo)
|
|
{
|
|
LPITEMLIST pCurItem = pCurHandler->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
if (pHandlerItemInfo->itemID == pCurItem->offlineItem.ItemID)
|
|
{
|
|
pCurItem->pItemCheckState[0].dwSchedule = pHandlerItemInfo->dwCheckState;
|
|
pCurItem->offlineItem.hIcon = pHandlerItemInfo->hIcon;
|
|
lstrcpy(pCurItem->offlineItem.wszItemName, pHandlerItemInfo->wszItemName);
|
|
|
|
return S_OK;
|
|
}
|
|
pCurItem = pCurItem->pnextItem;
|
|
|
|
}
|
|
if (!pCurItem)
|
|
{
|
|
|
|
//Item was not found on the handler, add it now
|
|
// Allocate the item.
|
|
LPITEMLIST pNewItem = (LPITEMLIST) ALLOC(sizeof(ITEMLIST));
|
|
|
|
if (NULL == pNewItem)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
memset(pNewItem,0,sizeof(ITEMLIST));
|
|
pNewItem->wItemId = ++pCurHandler->wItemCount;
|
|
pNewItem->pHandlerInfo = pCurHandler;
|
|
pNewItem->iItem = -1;
|
|
|
|
SYNCMGRITEM *pOfflineItem = (LPSYNCMGRITEM) ALLOC(sizeof(SYNCMGRITEM));
|
|
|
|
if (NULL == pOfflineItem)
|
|
{
|
|
FREE(pNewItem);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
ZeroMemory(pOfflineItem, sizeof(SYNCMGRITEM));
|
|
pNewItem->offlineItem = *pOfflineItem;
|
|
pNewItem->offlineItem.hIcon = pHandlerItemInfo->hIcon;
|
|
pNewItem->offlineItem.ItemID = pHandlerItemInfo->itemID;
|
|
lstrcpy(pNewItem->offlineItem.wszItemName, pHandlerItemInfo->wszItemName);
|
|
|
|
//Scheduled sync only works on one connection
|
|
Assert(NULL == pNewItem->pItemCheckState );
|
|
|
|
pNewItem->pItemCheckState = (ITEMCHECKSTATE*) ALLOC(sizeof(ITEMCHECKSTATE));
|
|
if (!pNewItem->pItemCheckState)
|
|
{
|
|
FREE(pNewItem);
|
|
FREE(pOfflineItem);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
pNewItem->pItemCheckState[0].dwSchedule = pHandlerItemInfo->dwCheckState;
|
|
|
|
// stick the item on the end of the list
|
|
if (NULL == pCurHandler->pFirstItem)
|
|
{
|
|
pCurHandler->pFirstItem = pNewItem;
|
|
Assert(1 == pCurHandler->wItemCount);
|
|
}
|
|
else
|
|
{
|
|
LPITEMLIST pCurItem;
|
|
pCurItem = pCurHandler->pFirstItem;
|
|
|
|
while (pCurItem->pnextItem)
|
|
pCurItem = pCurItem->pnextItem;
|
|
|
|
pCurItem->pnextItem = pNewItem;
|
|
|
|
Assert ((pCurItem->wItemId + 1) == pNewItem->wItemId);
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::AddHandlerItem(LPSYNC_HANDLER_ITEM_INFO pHandlerItemInfo)
|
|
//
|
|
// PURPOSE: App is programatically adding an item to the schedule
|
|
// with this default check state
|
|
//
|
|
// HISTORY: 03-05-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::AddHandlerItem(LPSYNC_HANDLER_ITEM_INFO pHandlerItemInfo)
|
|
{
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
SCODE sc = S_OK;
|
|
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo )
|
|
{
|
|
if (pHandlerItemInfo->handlerID == pCurHandlerInfo->clsidHandler)
|
|
{
|
|
|
|
return InsertItem(pCurHandlerInfo, pHandlerItemInfo);
|
|
|
|
}
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
//if the handler is not loaded, just cache the new item.
|
|
return SYNCMGR_E_HANDLER_NOT_LOADED;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::SetItemCheck(REFCLSID pclsidHandler,
|
|
// SYNCMGRITEMID *pOfflineItemID, DWORD dwCheckState)
|
|
//
|
|
// PURPOSE: App is programatically setting the check state of an item
|
|
//
|
|
// HISTORY: 03-05-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::SetItemCheck(REFCLSID pclsidHandler,
|
|
SYNCMGRITEMID *pOfflineItemID, DWORD dwCheckState)
|
|
{
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
LPITEMLIST pCurItem = NULL;
|
|
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo )
|
|
{
|
|
if (pclsidHandler == pCurHandlerInfo->clsidHandler)
|
|
{
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
if (*pOfflineItemID == pCurItem->offlineItem.ItemID)
|
|
{
|
|
pCurItem->pItemCheckState[0].dwSchedule = dwCheckState;
|
|
return S_OK;
|
|
}
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
return SYNCMGR_E_ITEM_UNREGISTERED;
|
|
}
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
//if the handler is not loaded, just cache the new item
|
|
return SYNCMGR_E_HANDLER_NOT_LOADED;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: HndlrQueue::GetItemCheck(REFCLSID pclsidHandler,
|
|
// SYNCMGRITEMID *pOfflineItemID, DWORD *pdwCheckState)
|
|
// PURPOSE: App is programatically setting the check state of an item
|
|
//
|
|
// HISTORY: 03-05-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::GetItemCheck(REFCLSID pclsidHandler,
|
|
SYNCMGRITEMID *pOfflineItemID, DWORD *pdwCheckState)
|
|
{
|
|
LPHANDLERINFO pCurHandlerInfo = NULL;
|
|
LPITEMLIST pCurItem = NULL;
|
|
|
|
pCurHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pCurHandlerInfo )
|
|
{
|
|
if (pclsidHandler == pCurHandlerInfo->clsidHandler)
|
|
{
|
|
pCurItem = pCurHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
if (*pOfflineItemID == pCurItem->offlineItem.ItemID)
|
|
{
|
|
*pdwCheckState = pCurItem->pItemCheckState[0].dwSchedule;
|
|
return S_OK;
|
|
}
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
return SYNCMGR_E_ITEM_UNREGISTERED;
|
|
}
|
|
pCurHandlerInfo = pCurHandlerInfo->pNextHandler;
|
|
}
|
|
|
|
//if the handler is not loaded, just cache the new item
|
|
return SYNCMGR_E_HANDLER_NOT_LOADED;
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::ReadSyncSettingsPerConnection(SYNCTYPE syncType,
|
|
// WORD wHandlerID)
|
|
//
|
|
// PURPOSE: Read the autosync settings from the registry.
|
|
// If there is no entry in the registry, the default is the
|
|
// check state of the current offline item
|
|
//
|
|
// COMMENTS: Ras based (connection name as identifier) When connection object
|
|
// based, we will use the connection GUID to identify the connection
|
|
// settings
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::ReadSyncSettingsPerConnection(SYNCTYPE syncType,
|
|
WORD wHandlerID)
|
|
{
|
|
HRESULT hr = E_UNEXPECTED; // review for Lookup failures
|
|
LPHANDLERINFO pHandlerInfo = NULL;
|
|
|
|
int i;
|
|
|
|
if (0 == m_ConnectionCount)
|
|
return S_FALSE;
|
|
|
|
Assert(m_ConnectionList != NULL);
|
|
Assert(m_ConnectionCount != 0);
|
|
|
|
//Set the Check set of this item per connection
|
|
if (NOERROR == LookupHandlerFromId(wHandlerID,&pHandlerInfo))
|
|
{
|
|
LPITEMLIST pCurItem = pHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
|
|
// if don't alreayd have a checkStateAllocate one.
|
|
if (!pCurItem->pItemCheckState)
|
|
{
|
|
pCurItem->pItemCheckState = (ITEMCHECKSTATE*) ALLOC(m_ConnectionCount * sizeof(ITEMCHECKSTATE));
|
|
}
|
|
|
|
if (!pCurItem->pItemCheckState)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
for (i=0; i<m_ConnectionCount; i++)
|
|
{
|
|
DWORD dwDefaultCheck;
|
|
|
|
// if handler hasn't registered for the
|
|
// event then set its check state fo uncheck
|
|
// we do this in each case. to start off with
|
|
// assume the handler is registered
|
|
|
|
// If change this logic need to also change logic in exe hndlrq.
|
|
|
|
|
|
dwDefaultCheck = pCurItem->offlineItem.dwItemState;
|
|
|
|
switch (syncType)
|
|
{
|
|
case SYNCTYPE_AUTOSYNC:
|
|
|
|
if (0 == (pHandlerInfo->dwRegistrationFlags
|
|
& (SYNCMGRREGISTERFLAG_CONNECT | SYNCMGRREGISTERFLAG_PENDINGDISCONNECT)))
|
|
{
|
|
dwDefaultCheck = SYNCMGRITEMSTATE_UNCHECKED;
|
|
}
|
|
|
|
RegGetSyncItemSettings(SYNCTYPE_AUTOSYNC,
|
|
pHandlerInfo->clsidHandler,
|
|
pCurItem->offlineItem.ItemID,
|
|
m_ConnectionList[i].pszConnectionName,
|
|
&(pCurItem->pItemCheckState[i].dwAutoSync),
|
|
dwDefaultCheck,
|
|
NULL);
|
|
|
|
break;
|
|
case SYNCTYPE_IDLE:
|
|
|
|
if (0 == (pHandlerInfo->dwRegistrationFlags & (SYNCMGRREGISTERFLAG_IDLE) ))
|
|
{
|
|
dwDefaultCheck = SYNCMGRITEMSTATE_UNCHECKED;
|
|
}
|
|
|
|
RegGetSyncItemSettings(SYNCTYPE_IDLE,
|
|
pHandlerInfo->clsidHandler,
|
|
pCurItem->offlineItem.ItemID,
|
|
m_ConnectionList[i].pszConnectionName,
|
|
&(pCurItem->pItemCheckState[i].dwIdle),
|
|
dwDefaultCheck,
|
|
NULL);
|
|
break;
|
|
default:
|
|
AssertSz(0,"Unknown SyncType");
|
|
break;
|
|
}
|
|
|
|
}
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::ReadAdvancedIdleSettings
|
|
//
|
|
// PURPOSE: Reads in the advanced Idle Settings.
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CHndlrQueue::ReadAdvancedIdleSettings(LPCONNECTIONSETTINGS pConnectionSettings)
|
|
{
|
|
|
|
// connection settings for global idle are really overloaded.
|
|
// advanced idle settings are in each connection so just copy it from
|
|
// whatever the first connection is.
|
|
|
|
if ( (m_ConnectionCount < 1) || (NULL == m_ConnectionList))
|
|
return S_FALSE;
|
|
|
|
|
|
*pConnectionSettings = m_ConnectionList[0];
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP CHndlrQueue::WriteAdvancedIdleSettings(LPCONNECTIONSETTINGS pConnectionSettings)
|
|
{
|
|
int iIndex;
|
|
|
|
// connection settings for global idle are really overloaded.
|
|
// advanced idle settings are in each connection so copy the members into each
|
|
// loaded connection in the list
|
|
|
|
for (iIndex = 0; iIndex < m_ConnectionCount; iIndex++)
|
|
{
|
|
m_ConnectionList[iIndex].ulIdleWaitMinutes = pConnectionSettings->ulIdleWaitMinutes;
|
|
m_ConnectionList[iIndex].ulIdleRetryMinutes = pConnectionSettings->ulIdleRetryMinutes;
|
|
m_ConnectionList[iIndex].dwRepeatSynchronization = pConnectionSettings->dwRepeatSynchronization;
|
|
m_ConnectionList[iIndex].dwRunOnBatteries = pConnectionSettings->dwRunOnBatteries;
|
|
m_ConnectionList[iIndex].ulIdleWaitMinutes = pConnectionSettings->ulIdleWaitMinutes;
|
|
|
|
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::CommitAutoSyncChanges(Ras *pRas)
|
|
//
|
|
// PURPOSE: Write the autosync settings to the registry. This is done when
|
|
// the user selects OK or APPLY from the settings dialog.
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::CommitSyncChanges(SYNCTYPE syncType,CRasUI *pRas)
|
|
{
|
|
LPHANDLERINFO pHandlerInfo;
|
|
int i;
|
|
|
|
if (!m_ConnectionList) // if no connection list, nothing to do
|
|
{
|
|
Assert(m_ConnectionList);
|
|
return NOERROR;
|
|
}
|
|
|
|
switch (syncType)
|
|
{
|
|
case SYNCTYPE_AUTOSYNC:
|
|
RegSetAutoSyncSettings(m_ConnectionList, m_ConnectionCount, pRas,
|
|
!m_fItemsMissing /* fCleanReg */,
|
|
TRUE /* fSetMachineState */,
|
|
TRUE /* fPerUser */);
|
|
|
|
break;
|
|
case SYNCTYPE_IDLE:
|
|
RegSetIdleSyncSettings(m_ConnectionList, m_ConnectionCount, pRas,
|
|
!m_fItemsMissing /* fCleanReg */,
|
|
TRUE /* fPerUser */);
|
|
|
|
break;
|
|
default:
|
|
AssertSz(0,"Unknown SyncType");
|
|
break;
|
|
}
|
|
|
|
for (i=0; i<m_ConnectionCount; i++)
|
|
{
|
|
|
|
pHandlerInfo = m_pFirstHandler;
|
|
|
|
while (pHandlerInfo)
|
|
{
|
|
LPITEMLIST pCurItem = pHandlerInfo->pFirstItem;
|
|
BOOL fAnyItemsChecked = FALSE;
|
|
|
|
while (pCurItem)
|
|
{
|
|
switch (syncType)
|
|
{
|
|
case SYNCTYPE_AUTOSYNC:
|
|
|
|
fAnyItemsChecked |= pCurItem->pItemCheckState[i].dwAutoSync;
|
|
|
|
RegSetSyncItemSettings(syncType,
|
|
pHandlerInfo->clsidHandler,
|
|
pCurItem->offlineItem.ItemID,
|
|
m_ConnectionList[i].pszConnectionName,
|
|
pCurItem->pItemCheckState[i].dwAutoSync,
|
|
NULL);
|
|
break;
|
|
case SYNCTYPE_IDLE:
|
|
|
|
fAnyItemsChecked |= pCurItem->pItemCheckState[i].dwIdle;
|
|
|
|
RegSetSyncItemSettings(syncType,
|
|
pHandlerInfo->clsidHandler,
|
|
pCurItem->offlineItem.ItemID,
|
|
m_ConnectionList[i].pszConnectionName,
|
|
pCurItem->pItemCheckState[i].dwIdle,
|
|
NULL);
|
|
break;
|
|
}
|
|
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
|
|
// write out the NoItems checked value on the handler for this connection
|
|
RegSetSyncHandlerSettings(syncType,
|
|
m_ConnectionList[i].pszConnectionName,
|
|
pHandlerInfo->clsidHandler,
|
|
fAnyItemsChecked ? 1 : 0);
|
|
|
|
|
|
pHandlerInfo = pHandlerInfo->pNextHandler;
|
|
}
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// FUNCTION: CHndlrQueue::CommitSchedSyncChanges(TCHAR * pszSchedName,
|
|
// TCHAR * pszFriendlyName,
|
|
// TCHAR * pszConnectionName,
|
|
// DWORD dwConnType,
|
|
// BOOL fCleanReg)
|
|
//
|
|
//
|
|
// PURPOSE: Write the scheduled sync settings to the registry. This is done when
|
|
// the user selects OK or FINISH from the settings dialog.
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// HISTORY: 01-01-98 SusiA Created.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
STDMETHODIMP CHndlrQueue::CommitSchedSyncChanges(TCHAR * pszSchedName,
|
|
TCHAR * pszFriendlyName,
|
|
TCHAR * pszConnectionName,
|
|
DWORD dwConnType,
|
|
BOOL fCleanReg)
|
|
{
|
|
LPHANDLERINFO pHandlerInfo;
|
|
pHandlerInfo = m_pFirstHandler;
|
|
|
|
if (!m_ConnectionList) // Review - What should we do here?
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
if (fCleanReg && !m_fItemsMissing)
|
|
{
|
|
RegRemoveScheduledTask(pszSchedName); // Remove any previous settings
|
|
}
|
|
|
|
lstrcpy(m_ConnectionList->pszConnectionName, pszConnectionName);
|
|
m_ConnectionList->dwConnType = dwConnType;
|
|
|
|
//set the SID on this schedule
|
|
if (g_dwPlatformId == VER_PLATFORM_WIN32_NT)
|
|
{
|
|
if (!RegSetSIDForSchedule(pszSchedName))
|
|
{
|
|
E_FAIL;
|
|
}
|
|
}
|
|
|
|
//Set the friendly name in the registry
|
|
if (!RegSetSchedFriendlyName(pszSchedName,pszFriendlyName))
|
|
{
|
|
E_FAIL;
|
|
}
|
|
RegSetSchedSyncSettings(m_ConnectionList, pszSchedName);
|
|
|
|
while (pHandlerInfo)
|
|
{
|
|
LPITEMLIST pCurItem = pHandlerInfo->pFirstItem;
|
|
|
|
while (pCurItem)
|
|
{
|
|
RegSetSyncItemSettings(SYNCTYPE_SCHEDULED,
|
|
pHandlerInfo->clsidHandler,
|
|
pCurItem->offlineItem.ItemID,
|
|
m_ConnectionList->pszConnectionName,
|
|
pCurItem->pItemCheckState[0].dwSchedule,
|
|
pszSchedName);
|
|
|
|
pCurItem = pCurItem->pnextItem;
|
|
}
|
|
|
|
pHandlerInfo = pHandlerInfo->pNextHandler;
|
|
}
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
|