windows-xp/Source/XPSP1/NT/termsrv/remdsk/rds/as/h/ut.h

//
// Utilities
//

#ifndef _H_UT
#define _H_UT



//
// Data types stored in the profile information.
//
#define COM_PROFTYPE_STRING     1L
#define COM_PROFTYPE_INT        2L
#define COM_PROFTYPE_BOOL       3L
#define COM_PROFTYPE_UNKNOWN    4L


#define COM_MAX_SUBKEY         256
#define COM_MAX_BOOL_STRING    5



//
//
// TYPEDEFS
//
//


//
// Priorities for UT_RegisterEventProc()
//
// Event procedures are registered with a priority that affects the order
// that the event procedures are called in.
//
// All event procedures of a given priority are called before event
// procedures of a numerically lower priority.
//
// The priority can be any number between 0 and UT_MAX_PRIORITY
//
// The following values have been defined for specific uses:
//  UT_PRIORITY_OBMAN :     Used by OBMAN so its client event procedures
//                            are called before those of the client
//  UT_PRIORITY_APPSHARE    : Used by the DCShare Core to ensure it sees
//                            events before 'Normal' event procs.
//  UT_PRIORITY_NORMAL      : For all cases where the order of callling is
//                            not important.
//  UT_PRIORITY_NETWORK     : Used by the Network Layer to free any
//                            unprocessed network buffers.
//  UT_PRIORITY_LAST        : Used by the Utility Services to get the
//                            default event procedure called last
//
//
typedef enum
{
    UT_PRIORITY_LAST = 0,
    UT_PRIORITY_NETWORK,
    UT_PRIORITY_NORMAL,
    UT_PRIORITY_APPSHARING,
    UT_PRIORITY_OBMAN,
    UT_PRIORITY_MAX
} UT_PRIORITY;
typedef UT_PRIORITY * PUT_PRIORITY;



//
// SYSTEM LIMITS
//

//
// Maximum number of event handlers for each task
//
#define UTEVENT_HANDLERS_MAX            4

//
// Maximum number of exit procedures
//
#define UTEXIT_PROCS_MAX                4


//
// The groupware critsects, identified by constant
//
#define UTLOCK_FIRST        0
typedef enum
{
    UTLOCK_UT = UTLOCK_FIRST,
    UTLOCK_OM,              // obman
    UTLOCK_AL,              // app loader
    UTLOCK_T120,            // gcc/mcs
    UTLOCK_AS,              // app sharing
    UTLOCK_MAX
}
UTLOCK;


// Event message
#define WM_UTTRIGGER_MSG    (WM_APP)


//
// BASEDLIST
//
// This is a list structure with based offsets
//
// next            : the next item in the list
// prev            : the previous item in the list
//
//
typedef struct tagBASEDLIST
{
    DWORD       next;
    DWORD       prev;
}
BASEDLIST;
typedef BASEDLIST FAR * PBASEDLIST;


typedef struct
{
    BASEDLIST  chain;
    void FAR *pData;
}
SIMPLE_LIST, FAR * PSIMPLE_LIST;



//
//
// MACROS
//
//
//
// List handling
// =============
// The common functions support the concept of a doubly linked list of
// objects.  Objects can be inserted and removed from specified locations
// in the list.
//
// At start of day the calling application must call COM_BasedListInit with a
// pointer to a private piece of memory for a BASEDLIST structure.  The list
// handling will initialise this structure.  The application must not
// release this memory while the list is active.  (Nor must it release any
// object while it is in a list!)
//
// The list functions can only manage a single list, however the app
// can load objects with multiple lists.  Each call to the common list
// functions takes a BASEDLIST pointer as the object handle and if the
// application defines multiple BASEDLIST structures within an object then it
// may manage them through the list functions.
//
//
// List chaining
// =============
// For normal list chaining, we have something like
//
//   while (pointer != NULL)
//   {
//     do something;
//     pointer = pointer->next;
//   }
//
// When using lists whose elements contain offsets (in this case, relative
// offsets) to the next element, we have to cast to a 32-bit integer before
// we can add the offset.  This macro encapsulates this, and the example
// above would be modified as follows to use it:
//
//   while (pointer != NULL)
//   {
//     do something;
//     pointer = (TYPE) COM_BasedNextListField(pointer);
//   }
//
// Note also that the value returned by the macro is a pointer to a generic
// list object i.e.  a PBASEDLIST, and so must be cast back to the
// appropriate type.
//
//

//
// List traversing macros
// ======================
// These macros make use of DC_NEXT and DC_PREV, but also take the type of
// list being traversed in order to return the start pointer of the chained
// structure.
//
// The LIST_FIND macro supports the searching of a list, matching a key
// value to a selected structure element.
//
// The parameters to the macros are as follows:
//
//   pHead (type: PBASEDLIST)
//   -----
//      a pointer the root of the list
//
//   pEntry (type: STRUCT FAR * FAR *)
//   ------
//      a pointer to pointer to structure to chain from
//
//   STRUCT (a type name)
//   ------
//      the type of **pEntry
//
//   chain (a field name)
//   -----
//      the text name of the field in STRUCT which is the link along which
//      you wish to traverse
//
//   field (a field name)
//   -----
//      when FINDing, the text name of the field in STRUCT against which
//      you wish to match
//
//   key (a value, of the same type as STRUCT.field)
//   ---
//      when FINDing, the value to match against STRUCT.field against
//
//



//
// Offset arithmetic
// =================
// Using offsets within memory blocks, rather than pointers, to refer to
// objects in shared memory (as necessitated by the DC-Groupware shared
// memory architecture) presents certain difficulties.  Pointer arithmetic
// in C assumes that addition/subtraction operations involve objects of the
// same type and the offsets are presented as number of units of that
// particular type, rather than number of bytes.
//
// Therefore, pointers must be cast to integers before performing
// arithmetic on them (note that casting the pointers to byte pointers is
// not enough since on segmented architectures C performs bounds checking
// when doing pointer arithmetic which we don't want).
//
// Since this would make for cumbersome code if repeated everywhere, we
// define some useful macros to convert
//
// - an (offset, base) pair to a pointer (OFFSETBASE_TO_PTR)
//
// - a (pointer, base) pair to an offset (PTRBASE_TO_OFFSET)
//
// - a NULL pointer value to an offset(NULLBASE_TO_OFFSET)
//
// The offset calculated is the offset of the first parameter from the
// second.  As described above, the pointers passed in must be cast to
// 32-bit unsigned integers first, subtracted to get the offset, and then
// cast to 32-bit signed.
//
// The NULLBASE_TO_OFFSET value gives an offset that after translation back
// to a pointer gives a NULL.  This is NOT the same as a NULL offset, since
// this translates back to the base pointer (which is a perfectly valid
// address).
//
//
#define PTRBASE_TO_OFFSET(pObject, pBase)                               \
      (LONG)(((DWORD_PTR)(pObject)) - ((DWORD_PTR)(pBase)))

#define OFFSETBASE_TO_PTR(offset, pBase)                                \
      ((void FAR *) ((DWORD_PTR)(pBase) + (LONG)(offset)))

#define NULLBASE_TO_OFFSET(pBase)                                       \
      ((DWORD_PTR) (0L - (LONG_PTR)(pBase)))


__inline BOOL COM_BasedListIsEmpty ( PBASEDLIST pHead )
{
    ASSERT((pHead->next == 0 && pHead->prev == 0) ||
           (pHead->next != 0 && pHead->prev != 0));
    return (pHead->next == 0);
}

__inline void FAR * COM_BasedFieldToStruct ( PBASEDLIST pField, UINT nOffset )
{
    return (void FAR *) ((DWORD_PTR)pField - nOffset);
}

__inline PBASEDLIST COM_BasedStructToField ( void FAR * pStruct, UINT nOffset )
{
    return (PBASEDLIST) ((DWORD_PTR) pStruct + nOffset);
}

__inline PBASEDLIST COM_BasedNextListField ( PBASEDLIST p )
{
    return (PBASEDLIST) OFFSETBASE_TO_PTR(p->next, p);
}

__inline PBASEDLIST COM_BasedPrevListField ( PBASEDLIST p )
{
    return (PBASEDLIST) OFFSETBASE_TO_PTR(p->prev, p);
}

void FAR * COM_BasedListNext ( PBASEDLIST pHead, void FAR * pEntry, UINT nOffset );
void FAR * COM_BasedListPrev ( PBASEDLIST pHead, void FAR * pEntry, UINT nOffset );
void FAR * COM_BasedListFirst ( PBASEDLIST pHead, UINT nOffset );
void FAR * COM_BasedListLast ( PBASEDLIST pHead, UINT nOffset );

typedef enum
{
    LIST_FIND_FROM_FIRST,
    LIST_FIND_FROM_NEXT
}
LIST_FIND_TYPE;

void COM_BasedListFind ( LIST_FIND_TYPE   eType,
                           PBASEDLIST          pHead,
                           void FAR * FAR*  ppEntry,
                           UINT           nOffset,
                           int           nOffsetKey,
                           DWORD_PTR     Key,
                           int           cbKeySize );


PSIMPLE_LIST COM_SimpleListAppend ( PBASEDLIST pHead, void FAR * pData );
void FAR *   COM_SimpleListRemoveHead ( PBASEDLIST pHead );

//
//
// FUNCTION PROTOTYPES
//
//

//
// API FUNCTION: COM_Rect16sIntersect(...)
//
// DESCRIPTION:
// ============
// Checks whether two TSHR_RECT16s rectangles intersect.  Rectangles are
// defined to be inclusive of all edges.
//
// PARAMETERS:
// ===========
// pRect1          : pointer to a TSHR_RECT16 rectangle.
// pRect2          : pointer to a TSHR_RECT16 rectangle.
//
// RETURNS:
// ========
// TRUE - if the rectangles intersect
// FALSE - otherwise.
//
//
__inline BOOL COM_Rect16sIntersect(LPTSHR_RECT16 pRect1, LPTSHR_RECT16 pRect2)
{
    if ((pRect1->left > pRect2->right) ||
        (pRect1->right < pRect2->left) ||
        (pRect1->top > pRect2->bottom) ||
        (pRect1->bottom < pRect2->top))
    {
        return(FALSE);
    }
    else
    {
        return(TRUE);
    }
}


//
// API FUNCTION: COM_BasedListInit(...)
//
// DESCRIPTION:
// ============
// Initialise a list root.
//
// PARAMETERS:
// ===========
// pListRoot       : pointer to the list root.
//
// RETURNS:
// ========
// Nothing.
//
//
__inline void COM_BasedListInit(PBASEDLIST pListRoot)
{
    //
    // The <next> and <prev> items in a list are the offsets, from the list
    // item, of the next and previous list items.
    //
    // In an empty list, the next item after the root is the root itself,
    // so the <next> offset is zero.  Likewise for <prev>.
    //
    pListRoot->next = 0;
    pListRoot->prev = 0;
}


//
// API FUNCTION: COM_BasedListInsertBefore(...)
// Inserts an item into a list.  To insert an item at the start of a list,
// specify the list root as the <pListLink> parameter.
//
void COM_BasedListInsertBefore(PBASEDLIST pListLink, PBASEDLIST pNewLink);


//
// API FUNCTION: COM_BasedListInsertAfter(...)
// Inserts an item into a list.  To insert an item at the start of a list,
// specify the list root as the <pListLink> parameter.
//
//
void COM_BasedListInsertAfter(PBASEDLIST pListLink,  PBASEDLIST pNewLink);

//
// API FUNCTION: COM_BasedListRemove(...)
//
// DESCRIPTION:
// ============
// This function removes an item from a list.  The item to be removed is
// specified by a pointer to the BASEDLIST structure within the item.
//
// PARAMETERS:
// ===========
// pListLink       : pointer to link of the item to be removed.
//
// RETURNS:
// ========
// Nothing.
//
//
void COM_BasedListRemove(PBASEDLIST pListLink);


//
// API FUNCTION: COM_ReadProfInt(...)
//
// DESCRIPTION:
// ============
// This reads a private profile integer from the registry.
//
// PARAMETERS:
// ===========
// pSection        : section containing the entry to read.
// pEntry          : entry name of integer to retrieve.
// defaultValue    : default value to return
// pValue          : buffer to return the entry in.
//
// RETURNS:
// ========
// Nothing.
//
//
void COM_ReadProfInt(LPSTR pSection, LPSTR pEntry, int defValue, int * pValue);

#ifndef DLL_DISP
//
// API FUNCTION: DCS_StartThread(...)
//
// DESCRIPTION:
// ============
// Start a new thread of execution
//
// PARAMETERS:
// ===========
// entryFunction   : A pointer to the thread entry point.
//
//
BOOL DCS_StartThread(LPTHREAD_START_ROUTINE entryFunction);
#endif // DLL_DISP



#ifndef DLL_DISP
BOOL COMReadEntry(HKEY    topLevelKey,
                                 LPSTR pSection,
                                 LPSTR pEntry,
                                 LPSTR pBuffer,
                                 int  bufferSize,
                                 ULONG expectedDataType);
#endif // DLL_DISP





#define MAKE_SUBALLOC_PTR(pPool, chunkOffset)   OFFSETBASE_TO_PTR(chunkOffset, pPool)

#define MAKE_SUBALLOC_OFFSET(pPool, pChunk)     PTRBASE_TO_OFFSET(pChunk, pPool)


//
//
// Return codes - all offset from UT_BASE_RC
//
//

enum
{
    UT_RC_OK                    = UT_BASE_RC,
    UT_RC_NO_MEM
};


//
// The maximum number of UT events which we try to process without yielding
//
#define MAX_EVENTS_TO_PROCESS    10


//
//
// Types
//
//

//
// Utility Functions Interface handle
//
typedef struct tagUT_CLIENT *    PUT_CLIENT;


#define UTTASK_FIRST        0
typedef enum
{
    UTTASK_UI = UTTASK_FIRST,
    UTTASK_CMG,
    UTTASK_OM,
    UTTASK_AL,
    UTTASK_DCS,
    UTTASK_WB,
    UTTASK_MAX
}
UT_TASK;


//
// Event procedure registered by UT_RegisterEvent().
//
// Takes event handler registered data, event number and 2 parameters
//      Returns TRUE if event processed
//      Returns FALSE if not and event should be passed on to next handler
//
//
typedef BOOL (CALLBACK * UTEVENT_PROC)(LPVOID, UINT, UINT_PTR, UINT_PTR);

//
// Exit procedure
//
typedef void (CALLBACK * UTEXIT_PROC)( LPVOID exitData );

//
// The name of the class used to create UT windows
//
#define UT_WINDOW_CLASS     "DCUTWindowClass"

//
// The ID of the timer to use for trigger events.
//
#define UT_DELAYED_TIMER_ID 0x10101010


//
//
// Prototypes
//
//

//
//
// Task routines
//
//   UT_WndProc()              Subclassing window procedure
//   UT_InitTask()             Initialise a task
//   UT_TermTask()             Terminate a task
//   UT_RegisterEvent()        Register an event handler
//   UT_DeregisterEvent()      Deregisters an event handler
//   UT_RegisterExit()         Register an exit routine
//   UT_DeregisterExit()       Deregister an exit routine
//   UT_PostEvent()            Send an event to a task
//
//

LRESULT CALLBACK  UT_WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);

BOOL UT_InitTask(UT_TASK task, PUT_CLIENT * pputTask);

//
//
// Overview:
//   This registers a task and assigns it a handle.
//   All other Utility Functions require this handle to be passed to them.
//
//   If a task has already been registered with the same process ID, the
//   utilities handle that has already been allocated is returned.
//   This is to allows the Utility Functions to be used in the context of
//   tasks that DC-SHARE has intercepted the graphics calls for.
//
//   Each task is identified by a name.
//
// Parameters:
//
//   task
//     Unique it for identifying task
//
//   pUtHandle (returned)
//     Utility Services handle to be used for all calls to the Utility
//     Services by this task
//
//


void UT_TermTask(PUT_CLIENT * pputTask);
//
//
// Overview:
//   This de-registers a task
//   All task resources are freed and the utHandle is released
//
// Parameters:
//
//   utHandle
//     Utility Functions Handle
//

void UT_RegisterEvent(PUT_CLIENT      putTask,
                                UTEVENT_PROC eventProc,
                                LPVOID       eventData,
                                UT_PRIORITY  priority);

void UT_DeregisterEvent(PUT_CLIENT  putTask,
                                UTEVENT_PROC eventProc,
                                LPVOID      eventData);

void UT_PostEvent(PUT_CLIENT putTaskFrom,
                                     PUT_CLIENT putTaskTo,
                                     UINT    delay,
                                     UINT    eventNo,
                                     UINT_PTR param1,
                                     UINT_PTR param2);

#define NO_DELAY        0

//
//
// Overview:
//   This posts an event to another task.
//
// Parameters:
//
//   utHandle
//     Utility Functions handle of invoking task
//
//   toHandle
//     Utility Functions TASK handle of task to post event to
//
//   delay
//     Delay (in milliseconds) before event is posted
//
//   eventNo
//     event to be posted (see autevt.h for details of events)
//
//   param1
//     parameter 1 for event (meaning depends on event)
//
//   param2
//     parameter 2 for event (meaning depends on event)
//
//
// NOTES:
//
//   1)  The delay time is in milliseconds.  This may not be supported by
//       underlying OS but the setting and checking of the pop time value
//       is OS specific.
//
//   2)  The posting of events is asynchronous, the delay is simply
//       the time before the event is posted.  The task the event is
//       posted to will receive the event NOT BEFRE this time is up.
//
//   3)  If an event is posted with a delay specified, the sending task
//       must continue to process messages for the event to be posted
//

void UT_RegisterExit(PUT_CLIENT putTask, UTEXIT_PROC exitProc, LPVOID exitData);
void UT_DeregisterExit(PUT_CLIENT putTask, UTEXIT_PROC exitProc, LPVOID exitData);



//
// Memory routines
//      UT_MallocRefCount
//      UT_BumpUpRefCount
//      UT_FreeRefCount
//


void *  UT_MallocRefCount(UINT cbSizeMem, BOOL fZeroMem);
void    UT_BumpUpRefCount(void * pMemory);
void    UT_FreeRefCount(void ** ppMemory, BOOL fNullOnlyWhenFreed);


// Ref count allocs
typedef struct tagUTREFCOUNTHEADER
{
    STRUCTURE_STAMP
    UINT    refCount;
}
UTREFCOUNTHEADER;
typedef UTREFCOUNTHEADER * PUTREFCOUNTHEADER;



//
// UT_MoveMemory()
// Replacement for CRT memmove(); handles overlapping
//
void *  UT_MoveMemory(void * dst, const void * src, size_t count);



//
// Locks
// - UT_Lock()       - Locks a lock
// - UT_Unlock()     - Unlocks a lock
//

#ifndef DLL_DISP
extern CRITICAL_SECTION g_utLocks[UTLOCK_MAX];

__inline void UT_Lock(UTLOCK lock)
{
    ASSERT(lock >= UTLOCK_FIRST);
    ASSERT(lock < UTLOCK_MAX);

    EnterCriticalSection(&g_utLocks[lock]);
}

__inline void UT_Unlock(UTLOCK lock)
{
    ASSERT(lock >= UTLOCK_FIRST);
    ASSERT(lock < UTLOCK_MAX);

    LeaveCriticalSection(&g_utLocks[lock]);
}

#endif // DLL_DISP


//
// Tasks
// UT_HandleProcessStart()
// UT_HandleProcessEnd()
// UT_HandleThreadEnd()
//

BOOL UT_HandleProcessStart(HINSTANCE hInstance);

void UT_HandleProcessEnd(void);

void UT_HandleThreadEnd(void);



//
// Structure for holding an event.  The first two fields allow the event to
// be held on the delayed event Q to be scheduled later.
//
typedef struct tagUTEVENT_INFO
{
    STRUCTURE_STAMP

    BASEDLIST       chain;

    // Params
    UINT            event;
    UINT_PTR        param1;
    UINT_PTR        param2;

    PUT_CLIENT      putTo;
    UINT            popTime;
}
UTEVENT_INFO;
typedef UTEVENT_INFO  * PUTEVENT_INFO;


#ifndef DLL_DISP
void __inline ValidateEventInfo(PUTEVENT_INFO pEventInfo)
{
    ASSERT(!IsBadWritePtr(pEventInfo, sizeof(UTEVENT_INFO)));
}
#endif // DLL_DISP


//
// Information held about each exit procedure
//
typedef struct tagUTEXIT_PROC_INFO
{
    UTEXIT_PROC     exitProc;
    LPVOID          exitData;
} UTEXIT_PROC_INFO;
typedef UTEXIT_PROC_INFO * PUTEXIT_PROC_INFO;

//
// Information held about each event procedure
//
typedef struct tagUTEVENT_PROC_INFO
{
    UTEVENT_PROC    eventProc;
    LPVOID          eventData;
    UT_PRIORITY     priority;
}
UTEVENT_PROC_INFO;
typedef UTEVENT_PROC_INFO * PUTEVENT_PROC_INFO;


//
//
// UT_CLIENT
//
// Information stored about each Utilities registered task.  A pointer to
// this structure is returned as the UT Handle from UT_InitTask(), and is
// passed in as a parameter to subsequent calls to UT.
//
// This structure is allocated in the shared memory bank.
//
// This should be a multiple of 4 bytes to ensure DWORD alignment of the
// allocated memory
//
//
typedef struct tagUT_CLIENT
{
    DWORD               dwThreadId;
    HWND                utHwnd;         // Window to post UT events to

    UTEXIT_PROC_INFO    exitProcs[UTEXIT_PROCS_MAX];
                                         // Exit procedures registered for
                                         //   this task.
    UTEVENT_PROC_INFO   eventHandlers[UTEVENT_HANDLERS_MAX];
                                         // Event procedures registered for
                                         //   this task.

    BASEDLIST           pendingEvents;   // List of events for this task
                                         //   which are ready to be
                                         //   processed.
    BASEDLIST           delayedEvents;   // List of delayed events destined
                                         //   for this task.
}
UT_CLIENT;


#ifndef DLL_DISP
void __inline ValidateUTClient(PUT_CLIENT putTask)
{
    extern UT_CLIENT    g_autTasks[UTTASK_MAX];

    ASSERT(putTask >= &(g_autTasks[UTTASK_FIRST]));
    ASSERT(putTask < &(g_autTasks[UTTASK_MAX]));
    ASSERT(putTask->dwThreadId);
}
#endif // DLL_DISP


//
//
// UTTaskEnd(...)
//
//   This routine frees all resources associated with the task and
//   releases the handle
//
// Parameters:
//
//   pTaskData - The Utility Functions handle for the task that is ending
//
//
void UTTaskEnd(PUT_CLIENT putTask);



//
//
// Overview:
// This routine is called to check the status of delayed events and to post
// them to the target process if required.
//
// Parameters:
//
//   utHandle
//     Utility Functions handle of invoking task
//
// NOTES:
//
// 1) This routine is called periodically or whenever the application
//       believes a delayed event has popped.
//
// Return codes: None
//
//
void UTCheckEvents(PUT_CLIENT putTask);
void UTCheckDelayedEvents(PUT_CLIENT putTask);


//
//
// UTProcessEvent(...)
//
// Overview:
//   This process an event for the current task
//
//
// Parameters:
//
//   utHandle
//     Utility Functions Handle
//
//   event
//     The event to process
//
//   param1
//     The 1st parameter for the event
//
//   param2
//     The 2nd parameter for the event
//
//
void UTProcessEvent(PUT_CLIENT putTask, UINT event, UINT_PTR param1, UINT_PTR param2);


//
//
// UTProcessDelayedEvent(...)
//
// A delayed event destined for the current task is ready to be processed.
//
//   pTaskData   - The current tasks data.
//   eventOffset - Offset into the shared memory bank at which the event
//                 is stored.
//
//
void UTProcessDelayedEvent(PUT_CLIENT putTask, DWORD eventOffset);



//
//
// UTPostImmediateEvt(...)
//
// This function adds an event to a task's pending event queue, and posts
// a trigger event if required.
//
//   pSrcTaskData    - originating tasks data
//   pDestTaskData   - destination tasks data
//   event           - event data
//   param1          - parm1
//   param2          - parm2
//
//
void UTPostImmediateEvt(PUT_CLIENT          putTaskFrom,
                        PUT_CLIENT          putTaskTo,
                        UINT                event,
                        UINT_PTR            param1,
                        UINT_PTR            param2);


//
//
// UTPostDelayedEvt(...)
//
// This function adds an event to a task's delayed event queue, and starts
// a timer (on the destination's task) to get that task to process the
// event when the timer ticks.
//
//   pSrcTaskData    - originating tasks data
//   pDestTaskData   - destination tasks data
//   delay           - the delay (in milliseconds)
//   event           - event data
//   param1          - parm1
//   param2          - parm2
//
//
void UTPostDelayedEvt(PUT_CLIENT            putTaskFrom,
                                    PUT_CLIENT  putTaskTo,
                                   UINT         delay,
                                   UINT         event,
                                   UINT_PTR     param1,
                                   UINT_PTR     param2);

//
//
// Overview:
//   This posts a event to another task
//
// Parameters:
//
//   pSrcTaskInfo  - task data for the source task
//   pDestTaskInfo - task data for the dest task
//
void UTTriggerEvt(PUT_CLIENT putTaskFrom, PUT_CLIENT putTaskTo);


//
//
// Overview:
//   This starts a delayed-event timer for a task.
//
// Parameters:
//   pTaskData
//     The task data for the task
//
//   popTime
//     The target time for the timer to pop - this is an OS specific value
//     in the same format as that returned by UTPopTime().
//
//
void UTStartDelayedEventTimer(PUT_CLIENT putTask, UINT popTime);



#endif // _H_UT