2170 lines
66 KiB
C++
2170 lines
66 KiB
C++
//
|
|
// Whiteboard Applet Functions
|
|
//
|
|
|
|
#ifndef _HPP_WB
|
|
#define _HPP_WB
|
|
|
|
|
|
extern "C"
|
|
{
|
|
#include <al.h>
|
|
}
|
|
|
|
|
|
//
|
|
// 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 <hPerson>.
|
|
//
|
|
// 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
|