able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/mobile/syncmgr/dll/hndlrq.cpp

2187 lines
60 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// 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;
}
Reference in a new issue Copy permalink