|
|
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1997.
//
// File: Hndlrq.h
//
// Contents: Keeps tracks of Handlers and UI assignments
//
// Classes: CHndlrQueue
//
// Notes:
//
// History: 05-Nov-97 rogerg Created.
//
//--------------------------------------------------------------------------
#ifndef _HANDLERQUEUE_
#define _HANDLERQUEUE_
// For Choice dialog If same item is added again first one their wins.
// This handles the case if user previously chose properties. duplicate items
// will be set to not synchronize even if the preference is set. this is
// the defined behavior for AddHandlerItemsToQueue.
//
// Progress dialog all items get synchronized as they were added. To move
// items to the Progress queue always use the TransferQueueData method. If Item
// was previously skipped what should we do?
// Also need routines for registering Choice and Progress dialogs.
class CBaseDlg;class CChoiceDlg;class CLock;class CThreadMsgProxy;class CHndlrMsg;
// state the handler should go to next
// note: any items with a HandlerState other than choice in a TransferQueueData
// will be released asserting the HANDLERSTATE_RELEASE or HANDLERSTATE_DEAD
// state is set.
typedef enum _tagHANDLERSTATE{ HANDLERSTATE_NEW = 0x00, // state is initialized to this.
HANDLERSTATE_CREATE = 0x01, // state is initialized to this.
HANDLERSTATE_INCREATE = 0x02, // state is initialized to this.
HANDLERSTATE_INITIALIZE = 0x03, // set after a successfull creation.
HANDLERSTATE_ININITIALIZE = 0x04, // set during initialization call
HANDLERSTATE_ADDHANDLERTEMS = 0x05, // items need to be enumerated
HANDLERSTATE_INADDHANDLERITEMS = 0x06, // in the items enumerator
HANDLERSTATE_PREPAREFORSYNC = 0x07, // set during queue tranfers
HANDLERSTATE_INPREPAREFORSYNC = 0x08, // handler is currently in a prepfosync call.
HANDLERSTATE_INSETCALLBACK = 0x09, // within a setcallback call.
HANDLERSTATE_SYNCHRONIZE = 0x0A, // Prepare for Sync set this if successfull
HANDLERSTATE_INSYNCHRONIZE = 0x0B, // item is currently in a synchronize call
HANDLERSTATE_HASERRORJUMPS = 0x0C, // if synchronize returned but error has jumps
HANDLERSTATE_INHASERRORJUMPS = 0x0D, // this handleris in a has jumps call
HANDLERSTATE_RELEASE = 0x0E, // Handler can be released, set on error or after success
HANDLERSTATE_TRANSFERRELEASE = 0x0F, // Handler can be released, was transferred into the queue but nothing to do.
HANDLERSTATE_DEAD = 0x10, // handler has been released. Data Stays around.
} HANDLERSTATE;
typedef enum _tagQUEUETYPE{ QUEUETYPE_CHOICE = 0x1, //
QUEUETYPE_PROGRESS = 0x2, //
QUEUETYPE_SETTINGS = 0x3, //
} QUEUETYPE;
// Job info list is assigned to each new item added to the hndlrqueu
// keeps track of number of handlers attached to JobInfo, Initialize
// flags, schedule name
// Progress queue keeps a linked list.
typedef struct _JOBINFO { struct _JOBINFO *pNextJobInfo; struct _JOBINFO *pTransferJobInfo; // used in queue transfer.
DWORD cRefs; DWORD dwSyncFlags; // standard sync flags
TCHAR szScheduleName[MAX_PATH + 1]; BOOL fCanMakeConnection; // Job is allowed to dial the connection.
BOOL fTriedConnection; // Job already tried to dial the connection.
DWORD cbNumConnectionObjs; CONNECTIONOBJ *pConnectionObj[1]; // array of cbNumConnecObjs associated with this job.
} JOBINFO;
typedef struct _ITEMLIST{ struct _ITEMLIST* pnextItem; WORD wItemId; // Id that uniquely identifies Item within a handler.
void *pHandlerInfo; // pointer to the handler that owns this item
SYNCMGRITEM offlineItem; // enumerator structure item returned
BOOL fItemCancelled; // when set poper code should be returned to progress.
BOOL fDuplicateItem; // when set to true indicates there was already an existing item of this handler and item.
BOOL fIncludeInProgressBar; // if set to true items ProgValues are added to the progress bar.
BOOL fProgressBarHandled; // Used internally by GetProgressInfo for calculating num items of num items completed
INT iProgValue; // current progress value.
INT iProgMaxValue; // current progress max value.
BOOL fProgValueDirty; // set to true if Normalized Progress Value needs to be recalced.
INT iProgValueNormalized; // current progress value normalized
DWORD dwStatusType; // status type from last callback.
BOOL fHiddenItem; // flag set it Item was added by ShowErrors returning nonItem.
BOOL fSynchronizingItem; // flag set while item has been selected for prepareForSync/synchronize.
} ITEMLIST;typedef ITEMLIST* LPITEMLIST;
typedef struct _HANDLERINFO { struct _HANDLERINFO *pNextHandler; DWORD dwCallNestCount; struct _HANDLERINFO *pHandlerId; // Id that uniquely identifies this instance of the Handler
CLSID clsidHandler; // CLSID of the handler Handler
DWORD dwRegistrationFlags; // flags as item is registered
SYNCMGRHANDLERINFO SyncMgrHandlerInfo; // copy of handler info GetHandlerInfo Call
HANDLERSTATE HandlerState; HWND hWndCallback; // hWnd to send callback information to.
BOOL fHasErrorJumps; // BOOL if can call ShowErrors then don't release on completion of sync.
BOOL fInShowErrorCall; // bool to indicate if handler is currently handling a ShowError Call.
BOOL fInTerminateCall; // bool to indicate if handler is currently handling a ShowError Call.
CThreadMsgProxy *pThreadProxy; DWORD dwOutCallMessages; // out call messages we are currenlty handling.
WORD wItemCount; BOOL fCancelled; // This Handler was Cancelled by the User.
BOOL fRetrySync; // retrySync was requested while before this items synchronization was done.
LPITEMLIST pFirstItem; // ptr to first Item of the handler in the list.
JOBINFO *pJobInfo;} HANDLERINFO;typedef HANDLERINFO* LPHANDLERINFO;
#define MAXPROGRESSVALUE 3000 // maximum absolute progress bar value
class CHndlrQueue : CLockHandler {
private: // review when eat up all the available IDs
LPHANDLERINFO m_pFirstHandler; JOBINFO *m_pFirstJobInfo; // pointer to first job.
HWND m_hwndDlg; // hwnd to dialog that owns the queue.
CBaseDlg *m_pDlg; // pointer to dialog that owns the queue.
WORD m_wHandlerCount; // number of handlers in this queue
QUEUETYPE m_QueueType; // type of queue this is.
DWORD m_dwQueueThreadId; // Thread that queue was created on.
DWORD m_dwShowErrororOutCallCount; // number of handlers currently stuck in a ShowError Call.
BOOL m_fInCancelCall; // Don't allow Cancel to be re-entrant
DWORD m_cRefs; BOOL m_fItemsMissing; // set if any handlers have missing items.
INT m_iNormalizedMax; // last calculated Max Value in GetProgressInfo
BOOL m_fNumItemsCompleteNeedsARecalc; // Need to recalulate the number of items complete.
BOOL m_iItemCount; // Total Number of Items as shown in progress.
BOOL m_iCompletedItems; // Number of Completed Items..
ULONG m_ulProgressItemCount; // total count of Items in cache included with progress.
public: CHndlrQueue(QUEUETYPE QueueType,CBaseDlg *pDlg); ~CHndlrQueue();
STDMETHODIMP_(ULONG) AddRef(); STDMETHODIMP_(ULONG) Release();
// main queue routines
STDMETHODIMP AddHandler(HANDLERINFO **ppHandlerId,JOBINFO *pJobInfo,DWORD dwRegistrationFlags); STDMETHODIMP Cancel(void); STDMETHODIMP ForceKillHandlers(BOOL *pfItemToKill); STDMETHODIMP TransferQueueData(CHndlrQueue *pQueueMoveFrom); STDMETHODIMP SetQueueHwnd(CBaseDlg *pDlg); STDMETHODIMP ReleaseCompletedHandlers(void); BOOL AreAnyItemsSelectedInQueue(); // walks through seeing if any items are selected for sync.
STDMETHODIMP FreeAllHandlers(void); // frees all handlers associated with the queue.
STDMETHODIMP GetHandlerInfo(REFCLSID clsidHandler,LPSYNCMGRHANDLERINFO pSyncMgrHandlerInfo); STDMETHODIMP GetHandlerInfo(HANDLERINFO *pHandlerId,LPSYNCMGRHANDLERINFO pSyncMgrHandlerInfo); STDMETHODIMP GetItemDataAtIndex(HANDLERINFO *pHandlerId,WORD wItemID,CLSID *pclsidHandler, SYNCMGRITEM* offlineItem,BOOL *pfHiddenItem); STDMETHODIMP GetItemDataAtIndex(HANDLERINFO *pHandlerId,REFSYNCMGRITEMID ItemID,CLSID *pclsidHandler, SYNCMGRITEM* offlineItem,BOOL *pfHiddenItem);
// new methods for walking through ListView relying on clsid and itemID
STDMETHODIMP FindFirstItemInState(HANDLERSTATE hndlrState,HANDLERINFO **ppHandlerId,WORD *wItemID); STDMETHODIMP FindNextItemInState(HANDLERSTATE hndlrState,HANDLERINFO *pLastHandlerId,WORD wLastItemID, HANDLERINFO **ppHandlerId,WORD *wItemID);
STDMETHODIMP SetItemState(REFCLSID clsidHandler,REFSYNCMGRITEMID ItemID,DWORD dwState); STDMETHODIMP ItemHasProperties(REFCLSID clsidHandler,REFSYNCMGRITEMID ItemID); // determines if there are properties associated with this item.
STDMETHODIMP ShowProperties(REFCLSID clsidHandler,REFSYNCMGRITEMID ItemID,HWND hwndParent); // show properties for this listView Item.
STDMETHODIMP ReEnumHandlerItems(REFCLSID clsidHandler,REFSYNCMGRITEMID ItemID); STDMETHODIMP SkipItem(REFCLSID clsidHandler,REFSYNCMGRITEMID ItemID); // skip this item
// methods for handling the progress and Items complete
STDMETHODIMP GetProgressInfo(INT *iProgValue,INT *iMaxValue,INT *iNumItemsComplete, INT *iNumItemsTotal); STDMETHODIMP SetItemProgressInfo(HANDLERINFO *pHandlerId,WORD wItemID, LPSYNCMGRPROGRESSITEM pSyncProgressItem, BOOL *pfProgressChanged); STDMETHODIMP RemoveFinishedProgressItems(); // walks through list marking any
// finished items as fIncludeInProgressBar==FALSE;
STDMETHODIMP PersistChoices(void); // persists choices for next time.
// For finding Handlers that meet specific state requirements
STDMETHODIMP FindFirstHandlerInState(HANDLERSTATE hndlrState, REFCLSID clsidHandler,HANDLERINFO **ppHandlerId,CLSID *pMatchHandlerClsid); STDMETHODIMP FindNextHandlerInState(HANDLERINFO *pLastHandlerID, REFCLSID clsidHandler,HANDLERSTATE hndlrState,HANDLERINFO **ppHandlerId ,CLSID *pMatchHandlerClsid);
// functions for calling through the items proxy.
STDMETHODIMP CreateServer(HANDLERINFO *pHandlerId, const CLSID *pCLSIDServer); STDMETHODIMP Initialize(HANDLERINFO *pHandlerId,DWORD dwReserved,DWORD dwSyncFlags, DWORD cbCookie,const BYTE *lpCooke); STDMETHODIMP AddHandlerItemsToQueue(HANDLERINFO *pHandlerId,DWORD *pcbNumItems); STDMETHODIMP GetItemObject(HANDLERINFO *pHandlerId,WORD wItemID,REFIID riid,void** ppv); STDMETHODIMP SetUpProgressCallback(HANDLERINFO *pHandlerId,BOOL fSet,HWND hwnd); // TRUE == create, FALSE == destroy. Callback info should be sent to specified hwnd.
STDMETHODIMP PrepareForSync(HANDLERINFO *pHandlerId,HWND hWndParent); STDMETHODIMP Synchronize(HANDLERINFO *pHandlerId,HWND hWndParent); STDMETHODIMP ShowError(HANDLERINFO *pHandlerId,HWND hWndParent,REFSYNCMGRERRORID ErrorID);
// callback proxy functions
STDMETHODIMP IsAllHandlerInstancesCancelCompleted(REFCLSID clsidHandler);
// functions called from Handler Thread
STDMETHODIMP SetHandlerInfo(HANDLERINFO *pHandlerId,LPSYNCMGRHANDLERINFO pSyncMgrHandlerInfo); STDMETHODIMP AddItemToHandler(HANDLERINFO *pHandlerId,LPSYNCMGRITEM pOffineItem); STDMETHODIMP Progress(HANDLERINFO *pHandlerId,REFSYNCMGRITEMID ItemID,LPSYNCMGRPROGRESSITEM lpSyncProgressItem); STDMETHODIMP LogError(HANDLERINFO *pHandlerId,DWORD dwErrorLevel,const WCHAR *lpcErrorText,LPSYNCMGRLOGERRORINFO lpSyncLogError); STDMETHODIMP DeleteLogError(HANDLERINFO *pHandlerId,REFSYNCMGRERRORID ErrorID,DWORD dwReserved); void CallCompletionRoutine(HANDLERINFO *pHandlerId,DWORD dwThreadMsg,HRESULT hr, ULONG cbNumItems,SYNCMGRITEMID *pItemIDs);
// internal queue handler of method calls with completion
// routines. can be called on either handler or dlg owner thread
// on error from calls completion routine is still invoked for
// the convenience of the caller to never have to worry about it.
STDMETHODIMP PrepareForSyncCompleted(LPHANDLERINFO pHandlerInfo,HRESULT hCallResult); STDMETHODIMP SynchronizeCompleted(LPHANDLERINFO pHandlerInfo,HRESULT hCallResult); STDMETHODIMP ShowErrorCompleted(LPHANDLERINFO pHandlerInfo,HRESULT hCallResult,ULONG cbNumItems,SYNCMGRITEMID *pItemIDs);
STDMETHODIMP AddQueueJobInfo(DWORD dwSyncFlags, DWORD cbNumConnectionNames, TCHAR **ppConnectionNames,TCHAR *pszScheduleName,BOOL fCanMakeConnection ,JOBINFO **ppJobInfo);
DWORD ReleaseJobInfoExt(JOBINFO *pJobInfo);
// state transition functions
STDMETHODIMP CancelQueue(void); // put queue into cancel mode.
STDMETHODIMP ScrambleIdleHandlers(REFCLSID clsidLastHandler);
// Handler dial support functinos
STDMETHODIMP BeginSyncSession(); STDMETHODIMP EndSyncSession(); STDMETHODIMP SortHandlersByConnection(); STDMETHODIMP EstablishConnection( LPHANDLERINFO pHandlerID, WCHAR const * lpwszConnection, DWORD dwReserved );
private: // private functions for finding proper handlers and items.
LPITEMLIST AllocNewHandlerItem(LPHANDLERINFO pHandlerInfo,SYNCMGRITEM *pOfflineItem); STDMETHODIMP LookupHandlerFromId(HANDLERINFO *pHandlerId,LPHANDLERINFO *pHandlerInfo); STDMETHODIMP FindItemData(CLSID clsidHandler,REFSYNCMGRITEMID OfflineItemID, HANDLERSTATE hndlrStateFirst,HANDLERSTATE hndlrStateLast, LPHANDLERINFO *ppHandlerInfo,LPITEMLIST *ppItem);
BOOL IsItemAlreadyInList(CLSID clsidHandler,REFSYNCMGRITEMID ItemID, HANDLERINFO *pHandlerId, LPHANDLERINFO *ppHandlerMatched, LPITEMLIST *ppItemListMatch); STDMETHODIMP MoveHandler(CHndlrQueue *pQueueMoveFrom, LPHANDLERINFO pHandlerInfoMoveFrom,HANDLERINFO **pHandlerId, CLock *pclockQueue); DWORD GetSelectedItemsInHandler(LPHANDLERINFO pHandlerInfo,ULONG *cbCount, SYNCMGRITEMID* pItems); BOOL IsItemCompleted(LPHANDLERINFO pHandler,LPITEMLIST pItem); STDMETHODIMP ReleaseHandlers(HANDLERSTATE HandlerState); // Releases handlers that are no longer neededfs
// items to handle maintain JobInfo items.
STDMETHODIMP CreateJobInfo(JOBINFO **ppJobInfo,DWORD cbNumConnectionNames); DWORD AddRefJobInfo(JOBINFO *pJobInfo); DWORD ReleaseJobInfo(JOBINFO *pJobInfo);
STDMETHODIMP ForceCompleteOutCalls(LPHANDLERINFO pCurHandler);
// connection help routines
STDMETHODIMP OpenConnection(JOBINFO *pJobInfo);
// helper function for setting item ProgressInfo
STDMETHODIMP SetItemProgressInfo(LPITEMLIST pItem, LPSYNCMGRPROGRESSITEM pSyncProgressItem, BOOL *pfProgressChanged); STDMETHODIMP SetItemProgressValues(LPITEMLIST pItem,INT iProgValue,INT iProgMaxValue);
friend CHndlrMsg;};
// helper functions
BOOL IsValidSyncProgressItem(LPSYNCMGRPROGRESSITEM lpProgItem);BOOL IsValidSyncLogErrorInfo(DWORD dwErrorLevel,const WCHAR *lpcErrorText,LPSYNCMGRLOGERRORINFO lpSyncLogError);
#endif // _HANDLERQUEUE_
|
