// // Whiteboard Applet Functions // #ifndef _HPP_WB #define _HPP_WB extern "C" { #include } // // Page in use flag for page state structure // #define PAGE_IN_USE 1 #define PAGE_NOT_IN_USE 2 // // Page sub-states used during add and delete of pages. Different actions // are required depending on whether the page is being added/deleted // locally or remotely. // #define PAGE_STATE_EMPTY 1 #define PAGE_STATE_LOCAL_OPEN_CONFIRM 2 #define PAGE_STATE_EXTERNAL_OPEN_CONFIRM 3 #define PAGE_STATE_READY 4 #define PAGE_STATE_EXTERNAL_ADD 5 #define PAGE_STATE_LOCAL_DELETE 6 #define PAGE_STATE_LOCAL_DELETE_CONFIRM 7 #define PAGE_STATE_EXTERNAL_DELETE 8 #define PAGE_STATE_EXTERNAL_DELETE_CONFIRM 9 // // Page manipulation values // #define OPEN_LOCAL 1 #define OPEN_EXTERNAL 2 #define PAGE_FIRST 1 #define PAGE_LAST 2 #define PAGE_BEFORE 3 #define PAGE_AFTER 4 // // Workset Ids // #define USER_INFORMATION_WORKSET 0 #define PAGE_CONTROL_WORKSET 1 #define SYNC_CONTROL_WORKSET 2 #define FIRST_PAGE_WORKSET 5 // // Number of pages to initialize during registration. During registration // the number of pages defined here will have worksets opened for them and // will be ready to be allocated through WBP_PageAdd calls. // #define PREINITIALIZE_PAGES 10 // // Object types for Page Control Workset objects // #define TYPE_CONTROL_PAGE_ORDER 1 #define TYPE_CONTROL_LOCK 2 // // Registration state table // // The following table shows the transitions made during registration. // // S0 = STATE_ERROR // S1 = STATE_REG_START // S2 = STATE_REG_PENDING_WSGROUP_CON // S3 = STATE_REG_PENDING_WORKSET_OPEN // S4 = STATE_REG_PENDING_LOCK // S5 = STATE_REG_PENDING_PAGE_CONTROL // S6 = STATE_REG_PENDING_UNLOCK // SIDLE = STATE_IDLE // // S0 S1 S2 S3 S4 S5 S6 SIDLE // // WBP_Start - A1 AE AE AE AE AE AE // OM_WSGROUP_REGISTER_CON i i A2 e e e e e // OM_WORKSET_OPEN_CON i i e A3 e e e * // OM_WORKSET_LOCK_CON i i e e A4 e e e // OM_OBJECT_ADD_IND i i i i i A5 e * // OM_WORKSET_UNLOCK_IND i i i i i i A6 * // OM_NETWORK_LOST_IND A7 i A7 A7 A7 A7 A7 A7 // OM_OUT_OF_RESOURCES_IND i i AR1 AR1 AR2 AR2 AR1 AR1 // WBP_Stop AD0 AN AD0 AD0 AD2 AD2 AD0 AD0 // // WBP_... called AE AN AN AN AN AN AN * // // Actions: // // e Error - log unexpected event and ignore // i Ignore // * Not described in this table // // AN Return a "Not registered" error to caller // (No state change) // // AE Return an "Out of resources" error to caller // (No state change) // // A1 Call OM_Register // Call OM_WSGroupRegister // Move to S2 // // A2 Open all worksets (0, 1, 2, and 5-254) // If error perform AD0 // Else move to S3 // // A3 If all worksets open // If Page Control Object exists // Move to SIDLE // Else // Request lock // Move to S4 // Endif // Endif // // A4 If lock acquired OK // Add Page Control Object // Move to S5 // Else // If locked by another person // Move to S5 // Else // Perform AD // Endif // Endif // // A5 If add is for Page Control Object // If we have the Page Control Workset lock // Release the lock // Else // Perform A6 // Endif // Endif // // A6 Post WBP_EVENT_REGISTERED to client // If a lock is present // Post lock notification to client // Endif // Move to SIDLE // // A7 Post WBP_EVENT_NETWORK_LOST to client // (No state change.) // // AD2 Unlock Page Control Workset // AD0 Deregister from ObMan // Post WBP_EVENT_DEREGISTERED to client // Move to S1 // // // // Major states occupied by a client // #define STATE_EMPTY 0 #define STATE_STARTING 1 #define STATE_STARTED 2 #define STATE_REGISTERING 3 #define STATE_IDLE 4 // // Sub-states occupied during start-up // #define STATE_START_START 1 #define STATE_START_REGISTERED_EVENT 2 #define STATE_START_REGISTERED_OM 3 #define STATE_START_REGISTERED_EXIT 4 // // Sub-states occupied after start-up, but before joining a call. // #define STATE_STARTED_START 5 // // Sub-states occupied during registration. These must be defined to // increase monotonically as we step through the registration process. // #define STATE_REG_START 6 #define STATE_REG_PENDING_WSGROUP_CON 7 #define STATE_REG_PENDING_USER_WORKSET 8 #define STATE_REG_PENDING_WORKSET_OPEN 9 #define STATE_REG_USER_OBJECT_ADDED 10 #define STATE_REG_PENDING_LOCK 11 #define STATE_REG_PENDING_PAGE_CONTROL 12 #define STATE_REG_PENDING_SYNC_CONTROL 13 #define STATE_REG_PENDING_UNLOCK 14 #define STATE_REG_PENDING_PAGE_ORDER 15 #define STATE_REG_PENDING_READY_PAGES 16 #define STATE_REG_END 17 #define STATE_REG_PENDING_WSGROUP_MOVE 18 #define STATE_REG_PENDING_NEW_USER_OBJECT 19 // // Error states // #define ERROR_STATE_EMPTY 0 #define ERROR_STATE_FATAL 1 // // Lock states // typedef enum { LOCK_STATE_EMPTY = 0, LOCK_STATE_PENDING_LOCK, LOCK_STATE_PENDING_ADD, LOCK_STATE_GOT_LOCK, LOCK_STATE_PENDING_DELETE, LOCK_STATE_LOCKED_OUT, LOCK_STATE_CANCEL_LOCK } WB_LOCK_STATE; // // Load states // #define LOAD_STATE_EMPTY 0 #define LOAD_STATE_PENDING_CLEAR 1 #define LOAD_STATE_PENDING_DELETE 2 #define LOAD_STATE_LOADING 3 #define LOAD_STATE_PENDING_NEW_PAGE 4 // // Call id for local calls // #define WB_NO_CALL OM_NO_CALL // // Limit defines // // Maximum number of pages allowed in the Whiteboard // #define WB_MAX_PAGES 250 // // Length of font face (must be a multiple of 4) // #define WB_FACENAME_LEN 32 // // Lock type definitions // typedef enum { WB_LOCK_TYPE_NONE = 0, WB_LOCK_TYPE_PAGE_ORDER, WB_LOCK_TYPE_CONTENTS } WB_LOCK_TYPE; // // Graphic lock definitions // typedef enum { WB_GRAPHIC_LOCK_NONE = 0, WB_GRAPHIC_LOCK_LOCAL, WB_GRAPHIC_LOCK_REMOTE } WB_GRAPHIC_LOCK_TYPE; // // Return codes // enum { WB_RC_NOT_LOCKED = WB_BASE_RC, WB_RC_LOCKED, WB_RC_BAD_FILE_FORMAT, WB_RC_WRITE_FAILED, WB_RC_BAD_PAGE_HANDLE, WB_RC_BAD_PAGE_NUMBER, WB_RC_CHANGED, WB_RC_NOT_CHANGED, WB_RC_NO_SUCH_PAGE, WB_RC_NO_SUCH_GRAPHIC, WB_RC_NO_SUCH_PERSON, WB_RC_TOO_MANY_PAGES, WB_RC_ALREADY_LOADING, WB_RC_BUSY, WB_RC_GRAPHIC_LOCKED, WB_RC_GRAPHIC_NOT_LOCKED, WB_RC_NOT_LOADING, WB_RC_CREATE_FAILED, WB_RC_READ_FAILED }; // // Events // enum { WBPI_EVENT_LOAD_NEXT = WB_BASE_EVENT, WBP_EVENT_JOIN_CALL_OK, WBP_EVENT_JOIN_CALL_FAILED, WBP_EVENT_NETWORK_LOST, WBP_EVENT_ERROR, WBP_EVENT_CONTENTS_LOCKED, WBP_EVENT_UNLOCKED, WBP_EVENT_LOCK_FAILED, WBP_EVENT_PAGE_CLEAR_IND, WBP_EVENT_PAGE_ORDER_UPDATED, WBP_EVENT_PAGE_DELETE_IND, WBP_EVENT_PAGE_ORDER_LOCKED, WBP_EVENT_GRAPHIC_ADDED, WBP_EVENT_GRAPHIC_MOVED, WBP_EVENT_GRAPHIC_UPDATE_IND, WBP_EVENT_GRAPHIC_REPLACE_IND, WBP_EVENT_GRAPHIC_DELETE_IND, WBP_EVENT_PERSON_JOINED, WBP_EVENT_PERSON_LEFT, WBP_EVENT_PERSON_UPDATE, WBP_EVENT_PERSON_REPLACE, WBP_EVENT_LOAD_FAILED, WBP_EVENT_INSERT_OBJECTS, WBP_EVENT_INSERT_NEXT, WBP_EVENT_SYNC_POSITION_UPDATED, WBP_EVENT_LOAD_COMPLETE }; // // Type declarations // // // Page handle. This is actually an index into the array of pages. // typedef OM_WORKSET_ID WB_PAGE_HANDLE; typedef WB_PAGE_HANDLE * PWB_PAGE_HANDLE; typedef PWB_PAGE_HANDLE * PPWB_PAGE_HANDLE; #define WB_PAGE_HANDLE_NULL ((WB_PAGE_HANDLE) 0) // // Graphic handle. These are handles to graphic objects in the various // page worksets. // typedef POM_OBJECT WB_GRAPHIC_HANDLE; typedef WB_GRAPHIC_HANDLE * PWB_GRAPHIC_HANDLE; typedef PWB_GRAPHIC_HANDLE * PPWB_GRAPHIC_HANDLE; // // Workset type constants // #define TYPE_FILE_HEADER 0 #define TYPE_END_OF_PAGE 1 #define TYPE_END_OF_FILE 2 // // Graphic type constants // #define TYPE_GRAPHIC_FREEHAND 3 #define TYPE_GRAPHIC_LINE 4 #define TYPE_GRAPHIC_RECTANGLE 5 #define TYPE_GRAPHIC_FILLED_RECTANGLE 6 #define TYPE_GRAPHIC_ELLIPSE 7 #define TYPE_GRAPHIC_FILLED_ELLIPSE 8 #define TYPE_GRAPHIC_TEXT 9 #define TYPE_GRAPHIC_DIB 10 // // Objects used in the Page Control and Lock worksets are used only by the // API functions. They are never passed back to the Client. // // // Structure used to build the Page Control Object kept in the Page Control // Workset. This object contains a list of workset IDs in page order (i.e. // the ID for page 1 comes first). // // The structure allows for the maximum number of pages. When it is // written to the Page Control Object only as many entries as are in use // are written. // // Note that the generation number field has been split into a hiword and // a loword - this is because the original definition had an unaligned // TSHR_UINT32 which caused the compiler to insert padding into the structure, // thus breaking backwards compatibility. // typedef struct tagWB_PAGE_ORDER { TSHR_UINT16 objectType; // Object type = TYPE_CONTROL_PAGES TSHR_UINT16 generationLo; // Generation number of object TSHR_UINT16 generationHi; TSHR_UINT16 countPages; // Number of active pages OM_WORKSET_ID pages[WB_MAX_PAGES]; // List of worksets (in page order) } WB_PAGE_ORDER; typedef WB_PAGE_ORDER * PWB_PAGE_ORDER; typedef PWB_PAGE_ORDER * PPWB_PAGE_ORDER; // // Lock object - kept in the Page Control Workset indicating the type and // owner of the current lock. // typedef struct tagWB_LOCK { TSHR_UINT16 objectType; // Object type = TYPE_CONTROL_LOCK TSHR_UINT16 lockType; // Type of lock // WB_LOCK_TYPE_NONE // WB_LOCK_TYPE_PAGE_ORDER // WB_LOCK_TYPE_CONTENTS OM_OBJECT_ID personID; // Id of person holding lock } WB_LOCK; typedef WB_LOCK * PWB_LOCK; typedef PWB_LOCK * PPWB_LOCK; // // Graphic object header. // // // WB Tool Types (not type; toolType) // #define WBTOOL_PEN 1 #define WBTOOL_TEXT 3 typedef struct tagWB_GRAPHIC { // // All graphic and file objects must start with these three fields // TSHR_UINT32 length; // Total length of structure TSHR_UINT16 type; // Type of object TSHR_UINT16 dataOffset; // Offset to graphic data from start // // All graphic objects have these fields // TSHR_RECT16 rectBounds; // Bounding rectangle TSHR_COLOR color; // Pen color (3 bytes) TSHR_UINT8 locked; // Flag indicating a person is editing TSHR_UINT16 penWidth; // Pen width TSHR_UINT16 penStyle; // Pen style TSHR_RECT16 rect; // Rectangle used for defining object OM_OBJECT_ID lockPersonID; // ID of locking person. This field is // maintained by the core and should not // be altered by clients. TSHR_UINT16 rasterOp; // Drawing mode TSHR_UINT8 smoothed; // Use curve smoothing algorithm TSHR_UINT8 toolType; // Type of tool used TSHR_UINT16 loadedFromFile; // Was this object loaded from file? NET_UID loadingClientID; // ID of the client which loaded this // object from file (only used if the // loadedFromFile field is set). // (This is defined as a TSHR_UINT16). TSHR_UINT32 reserved1; // Extra space for later additions TSHR_UINT32 reserved2; // Extra space for later additions } WB_GRAPHIC; typedef WB_GRAPHIC * PWB_GRAPHIC; typedef PWB_GRAPHIC * PPWB_GRAPHIC; // // Freehand line // typedef struct tagWB_GRAPHIC_FREEHAND { WB_GRAPHIC header; // Basic information TSHR_UINT16 pointCount; // Number of points in the polyline TSHR_POINT16 points[1]; // Array of points } WB_GRAPHIC_FREEHAND; typedef WB_GRAPHIC_FREEHAND * PWB_GRAPHIC_FREEHAND; typedef PWB_GRAPHIC_FREEHAND * PPWB_GRAPHIC_FREEHAND; // // Text // typedef struct tagWB_GRAPHIC_TEXT { WB_GRAPHIC header; // Basic information TSHR_INT16 charHeight; // Character height TSHR_UINT16 averageCharWidth; // Average character width TSHR_UINT16 strokeWeight; // Stroke weight (normal, bold) TSHR_UINT8 italic; // Italic flag TSHR_UINT8 underline; // Underline flag TSHR_UINT8 strikeout; // Strikeout flag TSHR_UINT8 pitch; // Fixed/variable pitch TSHR_CHAR faceName[WB_FACENAME_LEN]; // Font face name TSHR_UINT16 codePage; // Font code page TSHR_UINT16 stringCount; // Number of lines of text TSHR_CHAR text[1]; // Null-terminated text strings } WB_GRAPHIC_TEXT; typedef WB_GRAPHIC_TEXT * PWB_GRAPHIC_TEXT; typedef PWB_GRAPHIC_TEXT * PPWB_GRAPHIC_TEXT; // // Bitmap image // typedef struct tagWB_GRAPHIC_DIB { WB_GRAPHIC header; // Basic information // Data bytes follow this structure } WB_GRAPHIC_DIB; typedef WB_GRAPHIC_DIB * PWB_GRAPHIC_DIB; typedef PWB_GRAPHIC_DIB * PPWB_GRAPHIC_DIB; // // Person object // typedef struct tagWB_PERSON { TSHR_CHAR personName[TSHR_MAX_PERSON_NAME_LEN]; // Person name TSHR_UINT16 colorId; // Color identifier for the person TSHR_UINT8 synced; // Sync flag WB_PAGE_HANDLE currentPage; // Handle of current page TSHR_RECT16 visibleRect; // Area person can see in window TSHR_UINT8 pointerActive; // Remote pointer in use flag WB_PAGE_HANDLE pointerPage; // Page for remote pointer TSHR_POINT16 pointerPos; // Position of pointer in page TSHR_PERSONID cmgPersonID; // Call Manager personID. TSHR_UINT32 reserved1; // Reserved for future use. TSHR_UINT32 reserved2; // Reserved for future use. } WB_PERSON; typedef WB_PERSON * PWB_PERSON; typedef PWB_PERSON * PPWB_PERSON; // // size used by core to update the user object - front ends should only // replace user objects via the WBP_SetLocalPersonData API function. // #define WB_PERSON_OBJECT_UPDATE_SIZE (FIELD_OFFSET(WB_PERSON, synced)) // // Sync object // typedef struct tagWB_SYNC { TSHR_UINT32 length; // Length of the structure TSHR_UINT16 dataOffset; // Offset to data from start WB_PAGE_HANDLE currentPage; // Handle of current page TSHR_UINT8 pad; // Pad TSHR_RECT16 visibleRect; // Area visible in person's window TSHR_UINT16 zoomed; // Zoom sync participants } WB_SYNC; typedef WB_SYNC * PWB_SYNC; typedef PWB_SYNC * PPWB_SYNC; // // Constant to use instead of sizeof(WB_SYNC). // // The WB_SYNC structure was not defined correctly in previous versions // of Groupware (it was not padded correctly to a multiple of 4 bytes). // Some compilers (e.g. on NT) insert padding, so the structure is not the // same size as on Win95 for example. This results in an assert from // Obman... So we define a constant which is the same whatever compiler we // use. // #define WB_SYNC_SIZE 18 // // File header for Whiteboard format files // typedef struct tagWB_FILE_HEADER { TSHR_UINT32 length; // Total length of object TSHR_UINT16 type; // Type of file object TSHR_UINT16 dataOffset; // Not used (but must be here) char functionProfile[OM_MAX_FP_NAME_LEN]; } WB_FILE_HEADER; typedef WB_FILE_HEADER * PWB_FILE_HEADER; typedef PWB_FILE_HEADER * PPWB_FILE_HEADER; // // End-of-page object for writing to file // typedef struct tagWB_END_OF_PAGE { TSHR_UINT32 length; // Total length of object TSHR_UINT16 type; // Type of file object TSHR_UINT16 dataOffset; // Not used (but must be here) } WB_END_OF_PAGE; typedef WB_END_OF_PAGE * PWB_END_OF_PAGE; typedef PWB_END_OF_PAGE * PPWB_END_OF_PAGE; // // End-of-file object // typedef WB_END_OF_PAGE WB_END_OF_FILE; typedef WB_END_OF_FILE * PWB_END_OF_FILE; typedef PWB_END_OF_FILE * PPWB_END_OF_FILE; // // Structure used for determining the current sync page // typedef struct tagWB_SYNC_CONTROL { OM_OBJECT_ID personID; // ID of person who wrote object WB_SYNC sync; // Sync position details } WB_SYNC_CONTROL; typedef WB_SYNC_CONTROL * PWB_SYNC_CONTROL; typedef PWB_SYNC_CONTROL * PPWB_SYNC_CONTROL; // // Constant to use instead of sizeof(WB_SYNC_CONTROL). // // The WB_SYNC structure was not defined correctly in previous versions // of Groupware (it was not padded correctly to a multiple of 4 bytes). // Some compilers (e.g. on NT) insert padding, so the structure is not the // same size as on Win95 for example. This results in an assert from // Obman... So we define a constant which is the same whatever compiler we // use. // #define WB_SYNC_CONTROL_SIZE (sizeof(OM_OBJECT_ID) + WB_SYNC_SIZE) // // Structures used for maintaining and accessing the page list internally. // The page state structure combine the internal and external page state. // typedef struct tagWB_PAGE_STATE { TSHR_UINT16 state; // Page in use flag TSHR_UINT16 subState; // Page state OM_CORRELATOR worksetOpenCorrelator; } WB_PAGE_STATE; typedef WB_PAGE_STATE * PWB_PAGE_STATE; typedef PWB_PAGE_STATE * PPWB_PAGE_STATE; // // Secondary shared memory structure. // // Although we are adding objects, not pages, since each objects can be // placed on a new page, this structure is limited to the max number of // pages. // #define WB_MAX_INSERTS 250 #if WB_MAX_PAGES > WB_MAX_INSERTS #error Number of pages is now greater than number of insertable objects #endif // WB_MAX_PAGES > WB_MAX_INSERTS // // Values for changedFlagAction // #define RESET_CHANGED_FLAG 0 #define DONT_RESET_CHANGED_FLAG 1 // // Convert between page handles, workset IDs and indices into the page list // array of pages. // #define PAGE_HANDLE_TO_INDEX(hPage) \ ((TSHR_UINT16) ((hPage) - FIRST_PAGE_WORKSET)) #define PAGE_INDEX_TO_HANDLE(index) \ ((WB_PAGE_HANDLE) ((index) + FIRST_PAGE_WORKSET)) #define PAGE_WORKSET_ID_TO_INDEX(worksetID) \ ((TSHR_UINT16) ((worksetID) - FIRST_PAGE_WORKSET)) #define PAGE_INDEX_TO_WORKSET_ID(index) \ ((OM_WORKSET_ID) ((index) + FIRST_PAGE_WORKSET)) // // Client interface // #undef INTERFACE #define INTERFACE IWbClient DECLARE_INTERFACE(IWbClient) { STDMETHOD_(void, WBP_Stop)(THIS_ UTEVENT_PROC) PURE; STDMETHOD_(void, WBP_PostEvent)(THIS_ UINT delay, UINT event, UINT_PTR param1, UINT_PTR param2) PURE; STDMETHOD_(UINT, WBP_JoinCall)(THIS_ BOOL keep, UINT callID) PURE; STDMETHOD_(UINT, WBP_ValidateFile)(THIS_ LPCSTR fileName, HANDLE * phFile) PURE; STDMETHOD_(UINT, WBP_CancelLoad)(THIS_) PURE; STDMETHOD_(UINT, WBP_ContentsLoad)(THIS_ LPCSTR fileName) PURE; STDMETHOD_(UINT, WBP_ContentsSave)(THIS_ LPCSTR fileName) PURE; STDMETHOD_(UINT, WBP_ContentsDelete)(THIS_) PURE; STDMETHOD_(UINT, WBP_ContentsCountPages)(THIS_) PURE; STDMETHOD_(BOOL, WBP_ContentsChanged)(THIS_) PURE; STDMETHOD_(void, WBP_ContentsLock)(THIS_) PURE; STDMETHOD_(void, WBP_PageOrderLock)(THIS_) PURE; STDMETHOD_(void, WBP_Unlock)(THIS_) PURE; STDMETHOD_(WB_LOCK_TYPE, WBP_LockStatus)(THIS_ POM_OBJECT * ppObjPersonLock) PURE; STDMETHOD_(UINT, WBP_PageClear)(THIS_ WB_PAGE_HANDLE hPage) PURE; STDMETHOD_(void, WBP_PageClearConfirm)(THIS_ WB_PAGE_HANDLE hPage) PURE; STDMETHOD_(UINT, WBP_PageAddBefore)(THIS_ WB_PAGE_HANDLE hRefPage, PWB_PAGE_HANDLE phPage) PURE; STDMETHOD_(UINT, WBP_PageAddAfter)(THIS_ WB_PAGE_HANDLE hRefPage, PWB_PAGE_HANDLE phPage) PURE; STDMETHOD_(UINT, WBP_PageHandle)(THIS_ WB_PAGE_HANDLE hRefPage, UINT where, PWB_PAGE_HANDLE phPageResult) PURE; STDMETHOD_(UINT, WBP_PageHandleFromNumber)(THIS_ UINT pageNumber, PWB_PAGE_HANDLE phPage) PURE; STDMETHOD_(UINT, WBP_PageNumberFromHandle)(THIS_ WB_PAGE_HANDLE hPage) PURE; STDMETHOD_(UINT, WBP_PageDelete)(THIS_ WB_PAGE_HANDLE hPage) PURE; STDMETHOD_(void, WBP_PageDeleteConfirm)(THIS_ WB_PAGE_HANDLE hPage) PURE; STDMETHOD_(UINT, WBP_PageMove)(THIS_ WB_PAGE_HANDLE hRefPage, WB_PAGE_HANDLE hPage, UINT where) PURE; STDMETHOD_(UINT, WBP_PageCountGraphics)(THIS_ WB_PAGE_HANDLE hPage) PURE; STDMETHOD_(UINT, WBP_GraphicAllocate)(THIS_ WB_PAGE_HANDLE hPage, UINT length, PPWB_GRAPHIC ppGraphic) PURE; STDMETHOD_(UINT, WBP_GraphicAddLast)(THIS_ WB_PAGE_HANDLE hPage, PWB_GRAPHIC pGraphic, PWB_GRAPHIC_HANDLE phGraphic) PURE; STDMETHOD_(UINT, WBP_GraphicUpdateRequest)(THIS_ WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, PWB_GRAPHIC pGraphic) PURE; STDMETHOD_(void, WBP_GraphicUpdateConfirm)(THIS_ WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic) PURE; STDMETHOD_(UINT, WBP_GraphicReplaceRequest)(THIS_ WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, PWB_GRAPHIC pGraphic) PURE; STDMETHOD_(void, WBP_GraphicReplaceConfirm)(THIS_ WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic) PURE; STDMETHOD_(UINT, WBP_GraphicDeleteRequest)(THIS_ WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic) PURE; STDMETHOD_(void, WBP_GraphicDeleteConfirm)(THIS_ WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic) PURE; STDMETHOD_(UINT, WBP_GraphicMove)(THIS_ WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, UINT where) PURE; STDMETHOD_(UINT, WBP_GraphicSelect)(THIS_ WB_PAGE_HANDLE hPage, POINT pt, WB_GRAPHIC_HANDLE hRefGraphic, UINT where, PWB_GRAPHIC_HANDLE phGraphic) PURE; STDMETHOD_(UINT, WBP_GraphicGet)(THIS_ WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, PPWB_GRAPHIC ppGraphic) PURE; STDMETHOD_(void, WBP_GraphicRelease)(THIS_ WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, PWB_GRAPHIC pGraphic) PURE; STDMETHOD_(void, WBP_GraphicUnlock)(THIS_ WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic) PURE; STDMETHOD_(UINT, WBP_GraphicHandle)(THIS_ WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hRefGraphic, UINT where, PWB_GRAPHIC_HANDLE phGraphic) PURE; STDMETHOD_(void, WBP_PersonHandleFirst)(THIS_ POM_OBJECT * ppObjUser) PURE; STDMETHOD_(UINT, WBP_PersonHandleNext)(THIS_ POM_OBJECT pObj, POM_OBJECT * ppObjNext) PURE; STDMETHOD_(void, WBP_PersonHandleLocal)(THIS_ POM_OBJECT * ppObjLocal) PURE; STDMETHOD_(UINT, WBP_PersonCountInCall)(THIS_) PURE; STDMETHOD_(UINT, WBP_GetPersonData)(THIS_ POM_OBJECT pObjPerson, PWB_PERSON pPerson) PURE; STDMETHOD_(UINT, WBP_SetLocalPersonData)(THIS_ PWB_PERSON pPerson) PURE; STDMETHOD_(void, WBP_PersonUpdateConfirm)(THIS_ POM_OBJECT pObj) PURE; STDMETHOD_(void, WBP_PersonReplaceConfirm)(THIS_ POM_OBJECT pObj) PURE; STDMETHOD_(void, WBP_PersonLeftConfirm)(THIS_ POM_OBJECT pObj) PURE; STDMETHOD_(UINT, WBP_SyncPositionGet)(THIS_ PWB_SYNC pSync) PURE; STDMETHOD_(UINT, WBP_SyncPositionUpdate)(THIS_ PWB_SYNC pSync) PURE; }; class WbClient : public IWbClient { public: // IWbClient interface STDMETHODIMP_(void) WBP_Stop(UTEVENT_PROC eventProc); STDMETHODIMP_(void) WBP_PostEvent(UINT delay, UINT event, UINT_PTR param1, UINT_PTR param2); STDMETHODIMP_(UINT) WBP_JoinCall(BOOL keep, UINT callID); STDMETHODIMP_(UINT) WBP_ValidateFile(LPCSTR fileName, HANDLE * phFile); STDMETHODIMP_(UINT) WBP_CancelLoad(void); STDMETHODIMP_(UINT) WBP_ContentsLoad(LPCSTR fileName); STDMETHODIMP_(UINT) WBP_ContentsSave(LPCSTR fileName); STDMETHODIMP_(UINT) WBP_ContentsDelete(void); STDMETHODIMP_(UINT) WBP_ContentsCountPages(void); STDMETHODIMP_(BOOL) WBP_ContentsChanged(void); STDMETHODIMP_(void) WBP_ContentsLock(void); STDMETHODIMP_(void) WBP_PageOrderLock(void); STDMETHODIMP_(void) WBP_Unlock(void); STDMETHODIMP_(WB_LOCK_TYPE) WBP_LockStatus(POM_OBJECT * ppObjPersonLock); STDMETHODIMP_(UINT) WBP_PageClear(WB_PAGE_HANDLE hPage); STDMETHODIMP_(void) WBP_PageClearConfirm(WB_PAGE_HANDLE hPage); STDMETHODIMP_(UINT) WBP_PageAddBefore(WB_PAGE_HANDLE hRefPage, PWB_PAGE_HANDLE phPage); STDMETHODIMP_(UINT) WBP_PageAddAfter(WB_PAGE_HANDLE hRefPage, PWB_PAGE_HANDLE phPage); STDMETHODIMP_(UINT) WBP_PageHandle(WB_PAGE_HANDLE hRefPage, UINT where, PWB_PAGE_HANDLE phPageResult); STDMETHODIMP_(UINT) WBP_PageHandleFromNumber(UINT pageNumber, PWB_PAGE_HANDLE phPage); STDMETHODIMP_(UINT) WBP_PageNumberFromHandle(WB_PAGE_HANDLE hPage); STDMETHODIMP_(UINT) WBP_PageDelete(WB_PAGE_HANDLE hPage); STDMETHODIMP_(void) WBP_PageDeleteConfirm(WB_PAGE_HANDLE hPage); STDMETHODIMP_(UINT) WBP_PageMove(WB_PAGE_HANDLE hRefPage, WB_PAGE_HANDLE hPage, UINT where); STDMETHODIMP_(UINT) WBP_PageCountGraphics(WB_PAGE_HANDLE hPage); STDMETHODIMP_(UINT) WBP_GraphicAllocate(WB_PAGE_HANDLE hPage, UINT length, PPWB_GRAPHIC ppGraphic); STDMETHODIMP_(UINT) WBP_GraphicAddLast(WB_PAGE_HANDLE hPage, PWB_GRAPHIC pGraphic, PWB_GRAPHIC_HANDLE phGraphic); STDMETHODIMP_(UINT) WBP_GraphicUpdateRequest(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, PWB_GRAPHIC pGraphic); STDMETHODIMP_(void) WBP_GraphicUpdateConfirm(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic); STDMETHODIMP_(UINT) WBP_GraphicReplaceRequest(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, PWB_GRAPHIC pGraphic); STDMETHODIMP_(void) WBP_GraphicReplaceConfirm(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic); STDMETHODIMP_(UINT) WBP_GraphicDeleteRequest(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic); STDMETHODIMP_(void) WBP_GraphicDeleteConfirm(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic); STDMETHODIMP_(UINT) WBP_GraphicMove(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, UINT where); STDMETHODIMP_(UINT) WBP_GraphicSelect(WB_PAGE_HANDLE hPage, POINT pt, WB_GRAPHIC_HANDLE hRefGraphic, UINT where, PWB_GRAPHIC_HANDLE phGraphic); STDMETHODIMP_(UINT) WBP_GraphicGet(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, PPWB_GRAPHIC ppGraphic); STDMETHODIMP_(void) WBP_GraphicRelease(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, PWB_GRAPHIC pGraphic); STDMETHODIMP_(void) WBP_GraphicUnlock(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic); STDMETHODIMP_(UINT) WBP_GraphicHandle(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hRefGraphic, UINT where, PWB_GRAPHIC_HANDLE phGraphic); STDMETHODIMP_(void) WBP_PersonHandleFirst(POM_OBJECT * ppObjUser); STDMETHODIMP_(UINT) WBP_PersonHandleNext(POM_OBJECT pObj, POM_OBJECT * ppObjNext); STDMETHODIMP_(void) WBP_PersonHandleLocal(POM_OBJECT * ppObjLocal); STDMETHODIMP_(UINT) WBP_PersonCountInCall(void); STDMETHODIMP_(UINT) WBP_GetPersonData(POM_OBJECT pObjPerson, PWB_PERSON pPerson); STDMETHODIMP_(UINT) WBP_SetLocalPersonData(PWB_PERSON pPerson); STDMETHODIMP_(void) WBP_PersonUpdateConfirm(POM_OBJECT pObj); STDMETHODIMP_(void) WBP_PersonReplaceConfirm(POM_OBJECT pObj); STDMETHODIMP_(void) WBP_PersonLeftConfirm(POM_OBJECT pObj); STDMETHODIMP_(UINT) WBP_SyncPositionGet(PWB_SYNC pSync); STDMETHODIMP_(UINT) WBP_SyncPositionUpdate(PWB_SYNC pSync); BOOL WbInit(PUT_CLIENT putClient, UTEVENT_PROC eventProc); protected: // Internal functions PWB_PAGE_STATE GetPageState(WB_PAGE_HANDLE hPage) { ASSERT((hPage >= FIRST_PAGE_WORKSET) && (hPage <= FIRST_PAGE_WORKSET + WB_MAX_PAGES - 1)); return(&((m_pageStates)[PAGE_HANDLE_TO_INDEX(hPage)])); } void wbContentsDelete(UINT changedFlagAction); UINT wbLock(WB_LOCK_TYPE lockType); void wbUnlock(void); UINT wbPageHandle(WB_PAGE_HANDLE hPage, UINT where, PWB_PAGE_HANDLE phPage); UINT wbPageHandleFromNumber(UINT pageNumber, PWB_PAGE_HANDLE phPage); UINT wbPageClear(WB_PAGE_HANDLE hPage, UINT changedFlagAction); void wbPageClearConfirm(WB_PAGE_HANDLE hPage); UINT wbPageAdd(WB_PAGE_HANDLE hRefPage, UINT where, PWB_PAGE_HANDLE phPage, UINT changedFlagAction); BOOL wbGetNetUserID(void); UINT wbPageMove(WB_PAGE_HANDLE hRefPage, WB_PAGE_HANDLE hPage, UINT where); UINT wbPersonGet(POM_OBJECT pObjPerson, PWB_PERSON pPerson); UINT wbWriteSyncControl(PWB_SYNC pSync, BOOL create); BOOL wbGraphicLocked(WB_PAGE_HANDLE hPage, WB_GRAPHIC_HANDLE hGraphic, POM_OBJECT* ppObjPersonLock); UINT wbGraphicSelectPrevious(WB_PAGE_HANDLE hPage, LPPOINT pPoint, WB_GRAPHIC_HANDLE hGraphic, PWB_GRAPHIC_HANDLE phGraphic); void wbError(void); void wbJoinCallError(void); UINT wbAddLocalUserObject(void); UINT wbPersonUpdate(PWB_PERSON pUser); WB_PAGE_HANDLE wbGetEmptyPageHandle(void); WB_PAGE_HANDLE wbGetReadyPageHandle(void); PWB_PAGE_STATE wbPageState(WB_PAGE_HANDLE hPage); void wbPagesPageAdd(WB_PAGE_HANDLE hRefPage, WB_PAGE_HANDLE hPage, UINT where); UINT wbPageOrderPageNumber(PWB_PAGE_ORDER pPageOrder, WB_PAGE_HANDLE hPage); void wbPageOrderPageAdd(PWB_PAGE_ORDER pPageOrder, WB_PAGE_HANDLE hRefPage, WB_PAGE_HANDLE hPage, UINT where); void wbPageOrderPageDelete(PWB_PAGE_ORDER pPageOrder, WB_PAGE_HANDLE hPage); friend BOOL CALLBACK wbCoreEventHandler(LPVOID clientData, UINT event, UINT_PTR param1, UINT_PTR param2); BOOL wbEventHandler(UINT event, UINT_PTR param1, UINT_PTR param2); friend void CALLBACK wbCoreExitHandler(LPVOID clientData); void wbExitHandler(void); BOOL wbOnWsGroupRegisterCon(UINT_PTR param1, UINT_PTR param2); BOOL wbOnWsGroupMoveCon(UINT_PTR param1, UINT_PTR param2); BOOL wbOnWsGroupMoveInd(UINT_PTR param1, UINT_PTR param2); BOOL wbOnWorksetOpenCon(UINT_PTR param1, UINT_PTR param2); void wbOnControlWorksetOpenCon(UINT_PTR param1, UINT_PTR param2); BOOL wbOnPageWorksetOpenCon(UINT_PTR param1, UINT_PTR param2); BOOL wbOnWorksetLockCon(UINT_PTR param1, UINT_PTR param2); BOOL wbOnWorksetUnlockInd(UINT_PTR param1, UINT_PTR param2); BOOL wbOnWorksetClearInd(UINT_PTR param1, UINT_PTR param2); BOOL wbOnObjectAddInd(UINT_PTR param1, POM_OBJECT pObj); BOOL wbOnObjectMoveInd(UINT_PTR param1, UINT_PTR param2); BOOL wbOnObjectDeleteInd(UINT_PTR param1, POM_OBJECT pObj); BOOL wbOnObjectUpdateInd(UINT_PTR param1, POM_OBJECT pObj); BOOL wbOnObjectReplaceInd(UINT_PTR param1, POM_OBJECT pObj); void wbOnControlWorksetsReady(void); void wbProcessLockNotification(void); void wbCompleteRegistration(void); void wbLeaveCall(void); void wbOnGraphicObjectAddInd(OM_WORKSET_ID worksetID, POM_OBJECT pObj); void wbOnGraphicObjectUpdateInd(OM_WORKSET_ID worksetID, POM_OBJECT pObj); void wbOnGraphicObjectReplaceInd(OM_WORKSET_ID worksetID, POM_OBJECT pObj); void wbOnGraphicObjectMoveInd(OM_WORKSET_ID worksetID, POM_OBJECT pObj); void wbOnGraphicObjectDeleteInd(OM_WORKSET_ID worksetID, POM_OBJECT pObj); UINT wbPageWorksetOpen(WB_PAGE_HANDLE hPage, UINT localOrExternal); BOOL wbOnWBPPageClearInd(WB_PAGE_HANDLE hPage); void wbOnPageDelete(void); UINT wbPageSave(WB_PAGE_HANDLE hPage, HANDLE hFile); UINT wbObjectSave(HANDLE hFile, LPBYTE pData, UINT length); void wbStartContentsLoad(void); void wbPageLoad(void); UINT wbObjectLoad(HANDLE hFile, WB_PAGE_HANDLE hPage, PPWB_GRAPHIC ppGraphic); UINT wbGetPageObjectType(POM_OBJECT pObj, UINT * pObjectType); void wbOnPageObjectAddInd(POM_OBJECT pObj); void wbOnPageControlObjectAddInd(POM_OBJECT pObj); void wbOnPageObjectReplaceInd(POM_OBJECT pObj); void wbOnPageObjectDeleteInd(POM_OBJECT pObj); void wbOnLockControlObjectDeleteInd(POM_OBJECT pObj); void wbOnPageControlObjectReplaceInd(void); void wbProcessPageControlChanges(void); UINT wbWriteLock(void); void wbReadLock(void); void wbSendLockNotification(void); UINT wbWritePageControl(BOOL create); UINT wbCreateSyncControl(void); void wbOnSyncObjectAddInd(POM_OBJECT pObj); void wbOnSyncObjectReplaceInd(POM_OBJECT pObj); void wbOnUserObjectAddInd(POM_OBJECT pObj); void wbOnUserObjectDeleteInd(POM_OBJECT pObj); void wbOnUserObjectUpdateInd(POM_OBJECT pObj); void wbOnUserObjectReplaceInd(POM_OBJECT pObj); UINT wbSelectPersonColor(void); void wbCheckPersonColor(POM_OBJECT hCheckObject); BOOL wbOnWBPLock(void); BOOL wbOnWBPLockFailed(void); BOOL wbOnWBPUnlocked(void); BOOL wbOnWBPPageOrderUpdated(void); void wbProcessInsertObjects(void); UINT wbDiscardInsertObjects(UINT cObject); void wbClientReset(void); BOOL wbCheckReadyPages(void); // Data PUT_CLIENT m_putTask; // Task handle POM_CLIENT m_pomClient; // ObMan handle PCM_CLIENT m_pcmClient; // Call Manager secondary handle. OM_WSGROUP_HANDLE m_hWSGroup; BYTE m_changed; NET_UID m_clientNetID; // Net ID of local person UINT m_state; // Major state UINT m_subState; // Sub-state of major state UINT m_errorState; // Fatal error indicator OM_CORRELATOR m_wsgroupCorrelator; OM_CORRELATOR m_worksetOpenCorrelator; POM_OBJECT m_pObjPageControl; POM_OBJECT m_pObjSyncControl; POM_OBJECT m_pObjLocal; // Ptr to local person OM_OBJECT_ID m_personID; // OM ID of local person // adding clientNetID field WB_LOCK_STATE m_lockState; // Lock state OM_CORRELATOR m_lockCorrelator; // Correlator for locking WORD m_lockRequestType; // Type of lock request WB_LOCK_TYPE m_lockType; // Current lock type POM_OBJECT m_pObjLock; // Handle of the lock object POM_OBJECT m_pObjPersonLock; // Person who has lock. UINT m_loadState; // Load state HANDLE m_hLoadFile; // File handle (used during loading) WB_PAGE_HANDLE m_loadPageHandle; // Page handle (used during loading) UINT m_colorId; // Color id for the local person UINT m_countReadyPages; // Number of page worksets ready // for use. WB_PAGE_ORDER m_pageOrder; // List of active pages WB_PAGE_STATE m_pageStates[WB_MAX_PAGES]; // List of page state flags }; // // // Name: CreateWBObject() // // Purpose: Register the caller with the Whiteboard Core. This function // gives the core the ability to inform the front-end of events // caused by other call participants. // // The front-end should follow this call by a call to WBP_JoinCall. // // BOOL WINAPI CreateWBObject(UTEVENT_PROC eventProc, IWbClient** ppwbClient); // // Convert between ObMan object pointers and core graphic pointers // PWB_GRAPHIC __inline GraphicPtrFromObjectData(POM_OBJECTDATA pData) { return((PWB_GRAPHIC)&(pData->data)); } POM_OBJECTDATA __inline ObjectDataPtrFromGraphic(PWB_GRAPHIC pGraphic) { return((POM_OBJECTDATA)((LPBYTE)pGraphic - offsetof(OM_OBJECTDATA, data))); } // // QUIT_LOCKED // // Leave the function if another person has the contents or page order // lock. // // #define QUIT_LOCKED(result) \ if (m_lockState == LOCK_STATE_LOCKED_OUT) \ { \ result = WB_RC_LOCKED; \ DC_QUIT; \ } // // QUIT_IF_CANCELLING_LOCK // // Leave the function if we are processing a lock-cancel request // // #define QUIT_IF_CANCELLING_LOCK(result, errCode) \ if (m_lockState == LOCK_STATE_CANCEL_LOCK) \ { \ TRACE_OUT(("Already cancelling lock")); \ result = errCode; \ DC_QUIT; \ } // // QUIT_CONTENTS_LOCKED // // Leave the function if another person has the contents lock. // // #define QUIT_CONTENTS_LOCKED(result) \ if ( (m_lockState == LOCK_STATE_LOCKED_OUT) \ && (m_lockType == WB_LOCK_TYPE_CONTENTS)) \ { \ result = WB_RC_LOCKED; \ DC_QUIT; \ } // // QUIT_NOT_GOT_LOCK // // Leave the function if the client does not have a lock. // // #define QUIT_NOT_GOT_LOCK(result) \ if (m_lockState != LOCK_STATE_GOT_LOCK) \ { \ result = WB_RC_NOT_LOCKED; \ DC_QUIT; \ } // // QUIT_NOT_PROCESSING_LOCK // // Leave the function if the client has not previoulsy requested a lock. // // #define QUIT_NOT_PROCESSING_LOCK(result) \ if ( (m_lockState != LOCK_STATE_GOT_LOCK ) && \ (m_lockState != LOCK_STATE_PENDING_LOCK) && \ (m_lockState != LOCK_STATE_PENDING_ADD) ) \ { \ TRACE_OUT(( \ "Not locked: Client lock state %d", m_lockState)); \ result = WB_RC_NOT_LOCKED; \ DC_QUIT; \ } // // QUIT_NOT_GOT_CONTENTS_LOCK // // Leave the function if the client does not have the contents lock. // // #define QUIT_NOT_GOT_CONTENTS_LOCK(result) \ \ QUIT_NOT_GOT_LOCK(result); \ \ if (m_lockType != WB_LOCK_TYPE_CONTENTS) \ { \ result = WB_RC_NOT_LOCKED; \ DC_QUIT; \ } // // QUIT_NOT_GOT_PAGE_ORDER_LOCK // // This is currently the same as QUIT_NOT_GOT_LOCK as there are only the // page order and contents locks. The contents lock is considered to // include the page order lock. // // #define QUIT_NOT_GOT_PAGE_ORDER_LOCK(result) \ QUIT_NOT_GOT_LOCK(result) // // QUIT_GRAPHIC_LOCKED // // Leave the function if another person has the graphic locked. // // #define QUIT_GRAPHIC_LOCKED(hPage, hGraphic, result) \ { \ POM_OBJECT pObjPerson; \ if (wbGraphicLocked(hPage, hGraphic, &pObjPerson)) \ { \ if (pObjPerson != m_pObjLocal) \ { \ result = WB_RC_GRAPHIC_LOCKED; \ DC_QUIT; \ } \ } \ } // // QUIT_GRAPHIC_NOT_LOCKED // // Leave the function if the local user does not have the graphic locked. // // #define QUIT_GRAPHIC_NOT_LOCKED(pGraphic, result) \ if (pGraphic->locked != WB_GRAPHIC_LOCK_LOCAL) \ { \ result = WB_RC_GRAPHIC_NOT_LOCKED; \ DC_QUIT; \ } // // // Name: WBP_JoinCall // // Purpose: Join a call. This function registers with the Whiteboard // workset group. It is asynchronous giving one of the following // events as a result: // // WBP_EVENT_JOIN_CALL_OK // WBP_EVENT_JOIN_CALL_FAILED. // // No other WBP_... functions should be called until the call // has been successfully joined. // // Returns: 0 if successful // OM_RC_... - in case of workset registration/move failure: // see om.h // // // // // Name: WBP_ContentsLoad // // Purpose: Load a new file from disc into the Whiteboard worksets. The // caller must hold the Whiteboard page order lock before calling // this function. This function is asynchronous; when it returns, // the file will not be completely loaded. The front-end will // receive a WBP_EVENT_LOAD_COMPLETE when the load completes, or // a WBP_EVENT_LOAD_FAILED if an asynchronous error occurs // // Returns: 0 if successful // WB_RC_LOCKED - the whiteboard is locked by another user // WB_RC_NOT_LOCKED - the caller doesnt have the contents lock // WB_RC_NO_FILE - the specified file could not be found // WB_RC_BAD_FILE_FORMAT - the file is not of the correct format // // // // // Name: WBP_ContentsSave // // Purpose: Save the current Whiteboard contents to disc. The Whiteboard // contents can be updated by other users while this function is // processing. To prevent this acquire the Whiteboard contents // lock before calling it. // // Returns: 0 if successful // WB_RC_DISK_FULL - not enough space on disk // WB_RC_PATH_NOT_FOUND - the specified path does not exist // WB_RC_WRITE_FAILED - writing to the file failed - the file is // read-only. // // // // // Name: WBP_ContentsDelete // // Purpose: Delete all the Whiteboard pages (leaving only an empty page 1). // The caller must hold the Whiteboard contents or page order lock // before calling this function. // // For each page to be deleted, each person in the call receives // the following event: // // WBP_EVENT_PAGE_DELETE_IND // // Returns: 0 if successful // WB_RC_LOCKED - another person has the contents lock // WB_RC_NOT_LOCKED - the local person does not hold the page order // lock. // // // // // Name: WBP_ContentsChanged // // Purpose: Returns an indication of whether the contents of the Whiteboard // have changed since WBP_ContentsSave) WBP_ContentsLoad or // WBP_ContentsDelete was last called. // // // // // Name: WBP_ContentsLock // // Purpose: Lock the Whiteboard contents. This is an asynchronous function // generating one of the following events: // // WBP_EVENT_CONTENTS_LOCKED // WBP_EVENT_LOCK_FAILED. // // Returns: none // // // // // Name: WBP_PageOrderLock // // Purpose: Lock the Whiteboard page order. This is an asynchronous // function generating one of the following events: // // WBP_EVENT_PAGES_LOCKED // WBP_EVENT_LOCK_FAILED. // // // Returns: none // // // // // Name: WBP_Unlock // // Purpose: Unlock the Whiteboard. This is an asynchronous function // generating the following event: // // WBP_EVENT_UNLOCKED // // This function may be called anytine after a call to WBP_Lock - // an application does not need to wait for a WBP_EVENT_LOCKED // event after calling WBP_Lock before calling WBP_Unlock. // // // // // Name: WBP_LockStatus // // Purpose: Return the current state of the available locks // // // Returns: None (always succeeds) // // // // // Name: WBP_ContentsCountPages // // Purpose: Return the number of pages in the Whiteboard. // // Returns: None // // // // // Name: WBP_PageClear // // Purpose: Clear the page (deleting all graphic objects on it). This is // an asynchronous function generating the following event: // // WBP_EVENT_PAGE_CLEARED // // No objects are actually deleted until the WBP_PageClearConfirm // function is called in response to the event. // // Returns: 0 if successful // WB_RC_BAD_PAGE_HANDLE - the specified page handle is bad // WB_RC_LOCKED - another user has a lock on the white- // board contents. // // // // // Name: WBP_PageClearConfirm // // Purpose: Confirm the clearing of a page. All graphic objects on the page // will be removed. // // Returns: none // // // // // Name: WBP_PageAddBefore // // Purpose: Add a new page before a specified page. This // function requires that the caller hold the Whiteboard contents // or page order lock before it is called. The following event is // generated for each user in the call: // // WBP_EVENT_PAGE_ORDER_UPDATED // // Returns: 0 if successful // WB_RC_BAD_PAGE_HANDLE - the hRefPage handle is invalid // WB_RC_LOCKED - the whiteboard is locked by another // user // WB_RC_NOT_LOCKED - the local user does not hold the page // order lock // WB_RC_TOO_MANY_PAGES - the maximum number of pages has been // reached. // // // // // Name: WBP_PageAddAfter // // Purpose: Add a new page after a specified page. This // function requires that the caller hold the Whiteboard contents // or page order lock before it is called. The following event is // generated for each user in the call: // // WBP_EVENT_PAGE_ORDER_UPDATED // // Returns: 0 if successful // WB_RC_BAD_PAGE_HANDLE - the hRefPage handle is invalid // WB_RC_LOCKED - the whiteboard is locked by another user // WB_RC_NOT_LOCKED - the local user does not hold the page // order lock // WB_RC_TOO_MANY_PAGES - the maximum number of pages has been // reached. // // // // // Name: WBP_PageHandle // // Purpose: Return the handle of another page in the Whiteboard. // // Returns: 0 if successful // // // // // Name: WBP_PageHandleFromNumber // // Purpose: Return the handle of the page specified by page number // // Returns: 0 if successful // WB_RC_BAD_PAGE_NUMBER - pageNumber is not a valid page number // // // // // Name: WBP_PageNumberFromHandle // // Purpose: Return the number of the page specified by handle // // // // // Name: WBP_PageDelete // // Purpose: Delete the specified page. The local user must have the white- // board contents or page order lock before calling this function. // This call gives rise to two events: // // WBP_EVENT_PAGE_CLEARED_IND - indicating that all the objects in // the page have been deleted. The front-end // must respond by calling // WBP_PageClearConFirm - no graphic objects // will be deleted until this is done. // // WBP_EVENT_PAGE_ORDER_UPDATED - informing the front-end that the // list of pages has changed // // Returns: 0 if successful // WB_RC_BAD_PAGE_HANDLE - the specified page handle is invalid // WB_RC_LOCKED - another client has the contents locked // WB_RC_NOT_LOCKED - the local user does not have the page // order lock. // // // // // Name: WBP_PageDeleteConfirm // // Purpose: Confirm the deletion of a page. // // Returns: none // // // // // Name: WBP_PageMove // // Purpose: Moves one page after or before another. The user must hold // the Whiteboard contents or page order lock before calling this // function. If successful this function will result in a // WBP_EVENT_PAGE_ORDER_UPDATED event. // // Returns: 0 if successful // WB_RC_LOCKED - another client has the contents locked // WB_RC_NOT_LOCKED - the local user does not have the page // order lock. // WB_RC_BAD_PAGE_HANDLE - either hRefPage or hPage is not a valid // page handle // // // // // Name: WBP_PageCountGraphics // // Purpose: Return the number of graphics on the page // // Returns: none // // // // // Name: WBP_GraphicAllocate // // Purpose: Allocate memory for a graphic object. Note: All memory used for // graphics passed to the Whiteboard core must be allocated using // the function described here. // // Returns: 0 if successful // WB_RC_BAD_PAGE_HANDLE - the specified page handle is invalid // WB_RC_OUT_OF_MEMORY - could not allocate the amount of memory // requested. // // // // // Name: WBP_GraphicAddLast // // Purpose: Add a graphic object to the Whiteboard contents. The graphic // must previously have been allocated using WBP_GraphicAllocate. // It is added to the end (topmost Z-Order) of the specified page. // The following event is generated: // // WBP_EVENT_GRAPHIC_ADDED. // // Returns: 0 if successful // WB_RC_BAD_PAGE_HANDLE - the specified page handle is invalid // // // // // Name: WBP_GraphicUpdateRequest // // Purpose: Update a graphic object in the Whiteboard contents. This call // allows only the WB_GRAPHIC header part of the graphic object // to be altered. // // This call only starts the process of updating a graphic. If // this function is successful a WBP_EVENT_GRAPHIC_UPDATE_IND event // will be posted to the caller. The caller must then call // WBP_GraphicUpdateConfirm. // // Returns: 0 if successful // WB_RC_LOCKED - another client has the whiteboard // contents locked // WB_RC_OBJECT_LOCKED - another client has the specified // graphic object locked. // WB_RC_BAD_PAGE_HANDLE - the specified page handle is invalid // WB_RC_BAD_GRAPHIC_HANDLE - the specified graphic handle is // invalid // // // // // // Name: WBP_GraphicUpdateConfirm // // Purpose: Complete the process of updating a graphic object. // (See WBP_GraphicUpdateRequest.) // // Returns: none // // // // // Name: WBP_GraphicReplaceRequest // // Purpose: Replace a graphic object in the Whiteboard contents. This call // allows the entire object to be replaced with another object. // // This call only starts the process of replacing a graphic. If // this function is successful a WBP_EVENT_GRAPHIC_REPLACE_IND // event will be posted to the caller. The caller must then call // WBP_GraphicReplaceConfirm. // // Returns: 0 if successful // WB_RC_LOCKED - another client has the whiteboard // contents locked // WB_RC_OBJECT_LOCKED - another client has the specified // graphic object locked. // WB_RC_BAD_PAGE_HANDLE - the specified page handle is invalid // WB_RC_BAD_GRAPHIC_HANDLE - the specified graphic handle is // invalid // // // // // Name: WBP_GraphicReplaceConfirm // // Purpose: Complete the process of replacing a graphic object. // (See WBP_GraphicReplaceRequest.) // // Returns: none // // // // // Name: WBP_GraphicDeleteRequest // // Purpose: Delete a graphic object in the Whiteboard contents. // // This call only starts the process of deleting a graphic. If // this function is successful a WBP_EVENT_GRAPHIC_DELETE_IND event // will be posted to the caller. The caller must then call // WBP_GraphicDeleteConfirm. // // Returns: 0 if successful // // WB_RC_LOCKED - another client has the whiteboard // contents locked // WB_RC_OBJECT_LOCKED - another client has the specified // graphic object locked. // WB_RC_BAD_PAGE_HANDLE - the specified page handle is invalid // WB_RC_BAD_GRAPHIC_HANDLE - the specified graphic handle is // invalid // // // // Name: WBP_GraphicDeleteConfirm // // Purpose: Complete the process of deleting a graphic object. // (See WBP_UpdateGraphicRequest.) // // Returns: none // // // // // Name: WBP_GraphicMove // // Purpose: Move a graphic to the end of the page (topmost Z-order). // On successful completion, the following event is generated: // // WBP_EVENT_GRAPHIC_MOVED // // Returns: 0 if successful // WB_RC_LOCKED - another user has the whiteboard // contents locked. // WB_RC_BAD_PAGE_HANDLE - the specified page handle is invalid // WB_RC_BAD_GRAPHIC_HANDLE - the specified graphic handle is // invalid // // // // // Name: WBP_GraphicSelect // // Purpose: Retrieve the handle of the topmost Z-order graphic whose // bounding rectangle contains the specified point. // // Returns: 0 if successful // WB_RC_BAD_PAGE_HANDLE - the specified page handle is invalid // WB_RC_NO_SUCH_GRAPHIC - there is no graphic at the point // specified. // // // // // Name: WBP_GraphicGet // // Purpose: Retrieve a graphic object. After this graphic has been // retrieved it will remain in memory until explicitly released // by a call to WBP_ReleaseGraphic. // // Returns: 0 if successful // WB_RC_BAD_PAGE_HANDLE - the specified page handle is invalid // WB_RC_BAD_OBJECT_HANDLE - the specified graphic handle is // invalid. // // // // // Name: WBP_GraphicRelease // // Purpose: Release a previously retrieved graphic. // // Returns: none // // // // // Name: WBP_GraphicUnlock // // Purpose: Unlock a graphic. This function succeeds even if the contents // are locked. // // Returns: none // // // // // Name: WBP_GraphicHandle // // Purpose: Return the handle of the first graphic in the specified page. // // Returns: 0 if successful // WB_RC_BAD_PAGE_HANDLE - the specified page handle is invalid // // // // // Name: WBP_PersonHandleFirst // // Purpose: Return the handle of the first user in the call // // Returns: None // // // // // Name: WBP_PersonHandleNext // // Purpose: Return the handle of the next user in the call // // Returns: 0 if successful // WB_RC_BAD_USER_HANDLE - the specified user handle is invalid // WB_RC_NO_SUCH_USER - there is no next user: hRefUser is // the last in the users workset. // // // // // Name: WBP_PersonHandleLocal // // Purpose: Return the handle of the local user // // Returns: None // // // // // Name: WBP_PersonCountInCall // // Purpose: Retrieves information about the global state of the Whiteboard // FP in the call. // // // // // Name: WBP_GetPersonData // // Purpose: Retrieve the person object specified by . // // Returns: 0 if successful // OM_RC_... // WB_RC_BAD_PERSON_HANDLE - the specified person handle is invalid // // // // // Name: WBP_SetLocalPersonData // // Purpose: Sets the data for the local person. // // Returns: 0 if successful // OM_RC_... // WB_RC_BAD_PERSON_HANDLE - the specified person handle is invalid // // // // // Name: WBP_PersonUpdateConfirm // // Purpose: Complete the process of updating a user object. // // Returns: None // // // // // Name: WBP_PersonReplaceConfirm // // Purpose: Complete the process of replacing a user object. // // Returns: None // // // // // Name: WBP_PersonLeftConfirm // // Purpose: Complete the process of updating a user object. // // Returns: None // // // // // Name: WBP_SyncPositionGet // // Purpose: Retrieve the details of the current sync position. // // Returns: 0 if successful // // // // // Name: WBP_SyncPositionUpdate // // Purpose: Set the current sync details // // Returns: 0 if successful // // // // // Name: WBP_CancelLoad // // Purpose: Cancel a load in progress // // Returns: 0 if successful // WB_RC_NOT_LOADING if a load is not in progress // // // // // Name: WBP_ValidateFile // // Purpose: Validate a whiteboard file // // Returns: 0 if successful // Error if not // // // // // Event Descriptions // // The following event are generated during core processing. // // // // // // Name: WBP_EVENT_JOIN_CALL_OK // // Purpose: Inform the client that the call was joined successfully. // This is the very first event that the client will receive // after successful registration and joining of a call. // // Params: None // // // // // Name: WBP_EVENT_JOIN_CALL_FAILED // // Purpose: Inform the client that joining of the call failed. The core is // not in any call. The next call made to it should be one of // WBP_JoinCall and WBP_Stop. // // Params: None // // // // // Name: WBP_EVENT_NETWORK_LOST // // Purpose: Inform the client that communication with other clients // is no longer possible. The contents of the core are still // available. Any locks held by remote people have been released. // // Params: None // // // // // Name: WBP_EVENT_ERROR // // Purpose: Inform the client that a fatal error has occurred in the core. // The client should deregister (WBP_ContentsSave can be called // before the application quits but may not be successful). // // Params: None // // // // // Name: WBP_EVENT_CONTENTS_LOCKED // WBP_EVENT_PAGE_ORDER_LOCKED // // Purpose: Inform the client that the contents are now locked. This event // is be generated both when remote clients get the lock and when // the local client acquires it. The parameter indicates who now // has the lock. Note that this should always be tested even if // this event arrives when the local client is waiting for lock // confirmation: it may indicate that the remote client got in // just before the local. // // These events can indicate a change in lock status rather than a // lock being acquired. For example a client which holds the // Page Order Lock can upgrade that lock to a Contents Lock by // calling WBP_ContentsLock. All other clients will then receive // WBP_EVENT_CONTENTS_LOCKED events informing them of the change. // // Params: param16 reserved // param32 Handle of person who has acquired the lock // // // // // Name: WBP_EVENT_UNLOCKED // // Purpose: Inform the client that the contents are no longer locked. This // event is only received when a remote client releases the lock. // Local clients call the synchronous WBP_Unlock - the lock is // released on return from the function. // // Params: param16 reserved // param32 Handle of person who has released the lock // // // // // Name: WBP_EVENT_LOCK_FAILED // // Purpose: Inform the client that the lock request issued previously has // failed. This will usually be because another person has acquired // the lock. // // Params: None // // // // // Name: WBP_EVENT_PAGE_CLEAR_IND // // Purpose: Inform the client that a page clear has been requested. The // client should call WBP_PageClearConfirm as soon as possible. // // Params: param16 Handle of the page to be cleared // // // // // Name: WBP_EVENT_PAGE_ORDER_UPDATED // // Purpose: Inform the client that the order of pages has changed. This // event is generated by WBP_PageMove... and WBP_PageAdd... // functions (from both the local and remote clients). // // Params: None // // // // // Name: WBP_EVENT_PAGE_DELETE_IND // // Purpose: Inform the client that a delete request has been issued for // a page. The client should call WBP_PageDeleteConfirm as soon // as possible. // // Params: param16 Handle of the page being deleted // // // // // Name: WBP_EVENT_GRAPHIC_ADDED // // Purpose: Inform the client that a new graphic object has been added to // a page. This event is generated for all object adds including // those originating with the client. // // Params: param16 Handle of the page to which the object has been added // param32 Handle of the object which has been added // // // // // Name: WBP_EVENT_GRAPHIC_MOVED // // Purpose: Inform the client that a graphic object has been moved within // a page. This event is generated for all object moves including // those originating with the client. // // Params: param16 Handle of the page affected // param32 Handle of the object affected // // // // // Name: WBP_EVENT_GRAPHIC_UPDATE_IND // // Purpose: Inform the client that a request to update a graphic object has // been issued. No changes have yet been made to the graphic. // The client should call WBP_GraphicUpdateConfirm as soon as // possible. // // Params: param16 Handle of the page affected // param32 Handle of the object affected // // // // // Name: WBP_EVENT_GRAPHIC_REPLACE_IND // // Purpose: Inform the client that a request to replace a graphic object has // been issued. No changes have yet been made to the graphic. // The client should call WBP_GraphicReplaceConfirm as soon as // possible. // // Params: param16 Handle of the page affected // param32 Handle of the object affected // // // // // Name: WBP_EVENT_GRAPHIC_DELETE_IND // // Purpose: Inform the client that a request to delete a graphic object has // been issued. No changes have yet been made to the graphic. // The client should call WBP_GraphicDeleteConfirm as soon as // possible. // // Params: param16 Handle of the page affected // param32 Handle of the object affected // // // // // Name: WBP_EVENT_PERSON_JOINED // // Purpose: Inform the client that a new person has joined the call. // // Params: param16 reserved // param32 Handle of the person that has just joined // // // // // Name: WBP_EVENT_PERSON_LEFT // // Purpose: Inform the client that a person has left the call. // // Params: param16 reserved // param32 Handle of the person that has just left // // // // // Name: WBP_EVENT_PERSON_UPDATED // // Purpose: Inform the client that the some person information has changed. // // Params: param16 reserved // param32 Handle of the person affected // // // // // Name: WBP_EVENT_LOAD_COMPLETE // // Purpose: Inform the client that an attempt to load a Whiteboard file // has completed successfully. // // Params: none // // // // // Name: WBP_EVENT_LOAD_FAILED // // Purpose: Inform the client that an attempt to load a page from a // whiteboard file has failed. The load is cancelled at the point // the error occurred, but any objects/pages which were // successfully read in will remain. // // Params: none // // // // // Name: WBP_EVENT_INSERT_OBJECTS // // Purpose: Inform the client that objects created by the secondary api // client may be inserted. This event is posted when the whiteboard // lock has been released. // // Params: none // // // // // Name: WBP_EVENT_INSERT_NEXT // // Purpose: Inform the client that the next secondary api object may be // inserted. // // Params: param16 index of the object to be inserted // param32 reserved // // // // // Name: WBP_EVENT_SYNC_POSITION_UPDATED // // Purpose: Inform the client that the sync position information has been // updated. // // Params: param16 reserved // param32 reserved // // #endif // _HPP_WB