You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
9790 lines
241 KiB
9790 lines
241 KiB
#include "precomp.h"
|
|
|
|
|
|
//
|
|
// WB.CPP
|
|
// Whiteboard Services
|
|
//
|
|
// Copyright(c) Microsoft 1997-
|
|
//
|
|
|
|
#include <wb.hpp>
|
|
|
|
#define MLZ_FILE_ZONE ZONE_WB
|
|
|
|
|
|
//
|
|
// Constructor
|
|
//
|
|
BOOL WbClient::WbInit(PUT_CLIENT putTask, UTEVENT_PROC eventProc)
|
|
{
|
|
BOOL rc = FALSE;
|
|
|
|
DebugEntry(WbInit);
|
|
|
|
//
|
|
// Fill in the fields
|
|
//
|
|
m_state = STATE_EMPTY;
|
|
m_subState = STATE_EMPTY;
|
|
m_hLoadFile = INVALID_HANDLE_VALUE;
|
|
|
|
wbClientReset();
|
|
|
|
//
|
|
// Set the current state to the start of registration state.
|
|
// Store the UT handle - we will need this in any calls to the UT API.
|
|
// Set the ObMan handle to NULL to show that we have not registered.
|
|
//
|
|
m_state = STATE_STARTING;
|
|
m_subState = STATE_START_START;
|
|
m_putTask = putTask;
|
|
m_pomClient = NULL;
|
|
UT_RegisterEvent(putTask, eventProc, NULL, UT_PRIORITY_NORMAL);
|
|
|
|
|
|
TRACE_OUT(("Initialized state to STATE_STARTING"));
|
|
|
|
//
|
|
// Register an event handler to trap events from ObMan. The third
|
|
// parameter is data that will be passed to the event handler. We give
|
|
// the client data pointer so that we can access the correct data for
|
|
// each message.
|
|
//
|
|
UT_RegisterEvent(putTask, wbCoreEventHandler, this, UT_PRIORITY_NORMAL);
|
|
|
|
//
|
|
// Register as a Call Manager Secondary. This is required to query the
|
|
// Call Manager personID to insert into the WB_PERSON structure.
|
|
//
|
|
if (!CMS_Register(putTask, CMTASK_WB, &(m_pcmClient)))
|
|
{
|
|
ERROR_OUT(("CMS_Register failed"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Update the state
|
|
//
|
|
m_subState = STATE_START_REGISTERED_EVENT;
|
|
TRACE_OUT(("Moved to substate STATE_START_REGISTERED_EVENT"));
|
|
|
|
//
|
|
// Register with ObMan as a client
|
|
//
|
|
if (OM_Register(putTask, OMCLI_WB, &(m_pomClient)) != 0)
|
|
{
|
|
ERROR_OUT(("OM_Register failed"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Update the state
|
|
//
|
|
m_subState = STATE_START_REGISTERED_OM;
|
|
TRACE_OUT(("Moved to substate STATE_START_REGISTERED_OM"));
|
|
|
|
//
|
|
// Register an exit handler. This has to be done after registering with
|
|
// ObMan so that it gets called before the exit procedure registered by
|
|
// ObMan.
|
|
//
|
|
UT_RegisterExit(putTask, wbCoreExitHandler, this);
|
|
|
|
//
|
|
// Update the state
|
|
//
|
|
m_state = STATE_STARTED;
|
|
m_subState = STATE_STARTED_START;
|
|
|
|
rc = TRUE;
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(WbInit, rc);
|
|
return(rc);
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// CreateWBObject()
|
|
//
|
|
BOOL WINAPI CreateWBObject
|
|
(
|
|
UTEVENT_PROC eventProc,
|
|
IWbClient** ppwbClient
|
|
)
|
|
{
|
|
BOOL rc = FALSE;
|
|
WbClient* pwbClient = NULL;
|
|
PUT_CLIENT putTask = NULL;
|
|
|
|
DebugEntry(CreateWBObject);
|
|
|
|
//
|
|
// Initialize the WB task
|
|
//
|
|
if (!UT_InitTask(UTTASK_WB, &putTask))
|
|
{
|
|
ERROR_OUT(("Can't register WB task"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Allocate the WB client object
|
|
//
|
|
pwbClient = new WbClient();
|
|
if (!pwbClient)
|
|
{
|
|
ERROR_OUT(("Couldn't allocate WbClient object"));
|
|
|
|
UT_TermTask(&putTask);
|
|
DC_QUIT;
|
|
}
|
|
else
|
|
{
|
|
rc = pwbClient->WbInit(putTask, eventProc);
|
|
if (!rc)
|
|
{
|
|
pwbClient->WBP_Stop(eventProc);
|
|
pwbClient = NULL;
|
|
}
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
*ppwbClient = (IWbClient *)pwbClient;
|
|
|
|
DebugExitBOOL(CreateWBObject, rc);
|
|
return(rc);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_Stop()
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_Stop(UTEVENT_PROC eventProc)
|
|
{
|
|
PUT_CLIENT putTask;
|
|
|
|
DebugEntry(WBP_Stop);
|
|
|
|
//
|
|
// UT_TermTask() will call our exit handler and cause cleanup.
|
|
//
|
|
|
|
putTask = m_putTask;
|
|
UT_DeregisterEvent(putTask, eventProc, NULL);
|
|
|
|
// NOTE:
|
|
// UT_TermTask() will put NULL into the pointer you pass in after it
|
|
// has finished. But part of its job is to call your exit proc. Our
|
|
// exit handler will call 'delete this' to kill us off. So when it
|
|
// winds back to UT_TermTask(), the UT_CLIENT* pointer will be invalid.
|
|
// That's why we use a temp. variable.
|
|
//
|
|
UT_TermTask(&putTask);
|
|
|
|
DebugExitVOID(WBP_Stop);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PostEvent()
|
|
//
|
|
// Post an event back to the WB applet after a delay
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_PostEvent
|
|
(
|
|
UINT delay,
|
|
UINT event,
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
DebugEntry(WBP_PostEvent);
|
|
|
|
UT_PostEvent(m_putTask, m_putTask, delay, event, param1, param2);
|
|
|
|
DebugExitVOID(WBP_PostEvent);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_JoinCall
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_JoinCall
|
|
(
|
|
BOOL bContentsKeep,
|
|
UINT callID
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(WBP_JoinCall);
|
|
|
|
TRACE_OUT(("Keep contents = %s", (bContentsKeep) ? "TRUE" : "FALSE"));
|
|
TRACE_OUT(("Call ID = %d", callID));
|
|
|
|
//
|
|
// If we are to keep the existing contents, just move our workset group
|
|
// into the specified call.
|
|
//
|
|
if (bContentsKeep)
|
|
{
|
|
result = OM_WSGroupMoveReq(m_pomClient, m_hWSGroup, callID,
|
|
&(m_wsgroupCorrelator));
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_WSGroupMoveReq failed"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// The move request was successful, change the state to show that we
|
|
// are waiting for a move request to complete.
|
|
//
|
|
m_state = STATE_REGISTERING;
|
|
m_subState = STATE_REG_PENDING_WSGROUP_MOVE;
|
|
|
|
TRACE_OUT(("Moved to substate STATE_REG_PENDING_WSGROUP_MOVE"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Leave the current call. This returns the client state to what it
|
|
// should be after a wbStart call.
|
|
//
|
|
wbLeaveCall();
|
|
|
|
//
|
|
// Register with the workset group
|
|
//
|
|
result = OM_WSGroupRegisterPReq(m_pomClient, callID,
|
|
OMFP_WB, OMWSG_WB, &(m_wsgroupCorrelator));
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_WSGroupRegisterReq failed, result = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Update the state
|
|
//
|
|
m_state = STATE_REGISTERING;
|
|
m_subState = STATE_REG_PENDING_WSGROUP_CON;
|
|
TRACE_OUT(("Moved to state STATE_REGISTERING"));
|
|
TRACE_OUT(("Moved to substate STATE_REG_PENDING_WSGROUP_CON"));
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_JoinCall, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_ContentsDelete
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_ContentsDelete(void)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(WBP_ContentsDelete);
|
|
|
|
//
|
|
// Make sure that we have the Page Order Lock
|
|
//
|
|
QUIT_NOT_GOT_PAGE_ORDER_LOCK(result);
|
|
|
|
//
|
|
// Request the lock
|
|
//
|
|
wbContentsDelete(RESET_CHANGED_FLAG);
|
|
|
|
//
|
|
// Reset the flag indicating that the contents have changed
|
|
//
|
|
m_changed = FALSE;
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_ContentsDelete, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_ContentsLoad
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_ContentsLoad(LPCSTR pFileName)
|
|
{
|
|
UINT result = 0;
|
|
HANDLE hFile;
|
|
|
|
DebugEntry(WBP_ContentsLoad);
|
|
|
|
//
|
|
// Check that we have the lock
|
|
//
|
|
QUIT_NOT_GOT_PAGE_ORDER_LOCK(result);
|
|
|
|
//
|
|
// Check the load state
|
|
//
|
|
if (m_loadState != LOAD_STATE_EMPTY)
|
|
{
|
|
result = WB_RC_ALREADY_LOADING;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Validate the file, and get a handle to it.
|
|
// If there is an error, then no file handle is returned.
|
|
//
|
|
result = WBP_ValidateFile(pFileName, &hFile);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Bad file header"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Save the file handle for the rest of the load process
|
|
//
|
|
m_hLoadFile = hFile;
|
|
|
|
//
|
|
// We now need to make sure that the contents are deleted before we start
|
|
// adding the new objects.
|
|
//
|
|
wbContentsDelete(DONT_RESET_CHANGED_FLAG);
|
|
|
|
//
|
|
// Update the load state to show that we are waiting for the contents
|
|
// delete to complete.
|
|
//
|
|
m_loadState = LOAD_STATE_PENDING_CLEAR;
|
|
TRACE_OUT(("Moved load state to LOAD_STATE_PENDING_CLEAR"));
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_ContentsLoad, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_ContentsSave
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_ContentsSave(LPCSTR pFileName)
|
|
{
|
|
UINT result = 0;
|
|
UINT index;
|
|
HANDLE hFile;
|
|
PWB_PAGE_ORDER pPageOrder = &(m_pageOrder);
|
|
WB_FILE_HEADER fileHeader;
|
|
WB_END_OF_FILE endOfFile;
|
|
|
|
DebugEntry(WBP_ContentsSave);
|
|
|
|
//
|
|
// Open the file
|
|
//
|
|
hFile = CreateFile(pFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL, 0);
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
{
|
|
result = WB_RC_CREATE_FAILED;
|
|
ERROR_OUT(("Error creating file, win32 err=%d", GetLastError()));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Write the file header. This contains the name of the function profile
|
|
// that wrote the file and allows the file type to be tested when it is
|
|
// loaded.
|
|
//
|
|
ZeroMemory(&fileHeader, sizeof(fileHeader));
|
|
fileHeader.length = sizeof(fileHeader);
|
|
fileHeader.type = TYPE_FILE_HEADER;
|
|
|
|
lstrcpy(fileHeader.functionProfile, WB_FP_NAME);
|
|
|
|
result = wbObjectSave(hFile, (LPBYTE) &fileHeader, sizeof(fileHeader));
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Error writing end-of-page = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Loop through the pages, saving each as we go
|
|
//
|
|
for (index = 0; index < pPageOrder->countPages; index++)
|
|
{
|
|
//
|
|
// Save the page
|
|
//
|
|
result = wbPageSave((WB_PAGE_HANDLE)pPageOrder->pages[index], hFile);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Error saving page = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we have successfully written the contents, we write an end-of-page
|
|
// marker to the file.
|
|
//
|
|
ZeroMemory(&endOfFile, sizeof(endOfFile));
|
|
endOfFile.length = sizeof(endOfFile);
|
|
endOfFile.type = TYPE_END_OF_FILE;
|
|
|
|
//
|
|
// Write the end-of-file object
|
|
//
|
|
result = wbObjectSave(hFile, (LPBYTE) &endOfFile, sizeof(endOfFile));
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Error writing end-of-page = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Success!
|
|
//
|
|
TRACE_OUT(("Resetting changed flag"));
|
|
m_changed = FALSE;
|
|
|
|
DC_EXIT_POINT:
|
|
|
|
//
|
|
// Close the file
|
|
//
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
CloseHandle(hFile);
|
|
}
|
|
|
|
//
|
|
// If an error occurred in saving the contents to file, and the file was
|
|
// opened, then delete it.
|
|
//
|
|
if (result != 0)
|
|
{
|
|
//
|
|
// If the file was opened successfully, close it
|
|
//
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
DeleteFile(pFileName);
|
|
}
|
|
}
|
|
|
|
|
|
DebugExitDWORD(WBP_ContentsSave, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_ContentsChanged
|
|
//
|
|
STDMETHODIMP_(BOOL) WbClient::WBP_ContentsChanged(void)
|
|
{
|
|
BOOL changed = FALSE;
|
|
UINT result;
|
|
WB_PAGE_HANDLE hPage;
|
|
POM_OBJECT pObj;
|
|
|
|
DebugEntry(WBP_ContentsChanged);
|
|
|
|
TRACE_OUT(("changed %d", m_changed));
|
|
|
|
if (m_changed)
|
|
{
|
|
//
|
|
// The whiteboard may have been changed, but if the change was to
|
|
// empty it then don't bother. This is because we cannot detect that
|
|
// the New operation was a local New or a remote clear and so we would
|
|
// always prompt after New. Assuming that the user never needs to
|
|
// always prompt after New. Assuming that the user will manually save
|
|
// an workset he really wants to empty solves this problem.
|
|
//
|
|
|
|
//
|
|
// Scan all objects looking to see what is there - get handle to first
|
|
// page
|
|
//
|
|
result = wbPageHandle(WB_PAGE_HANDLE_NULL, PAGE_FIRST, &hPage);
|
|
while (result == 0)
|
|
{
|
|
//
|
|
// Get the handle of the first object in the page workset.
|
|
//
|
|
result = OM_ObjectH(m_pomClient, m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage, 0, &pObj, FIRST);
|
|
if (result != OM_RC_NO_SUCH_OBJECT)
|
|
{
|
|
changed = TRUE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Try the next page for an object
|
|
//
|
|
result = wbPageHandle(hPage, PAGE_AFTER, &hPage);
|
|
}
|
|
}
|
|
|
|
DebugExitBOOL(WBP_ContentsChanged, changed);
|
|
return(changed);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_ContentsLock
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_ContentsLock(void)
|
|
{
|
|
UINT result;
|
|
|
|
DebugEntry(WBP_ContentsLock);
|
|
|
|
//
|
|
// Check that there is no lock currently
|
|
//
|
|
QUIT_LOCKED(result);
|
|
QUIT_IF_CANCELLING_LOCK(result, WB_RC_BUSY);
|
|
|
|
//
|
|
// Request the lock
|
|
//
|
|
result = wbLock(WB_LOCK_TYPE_CONTENTS);
|
|
if (result != 0)
|
|
{
|
|
WBP_PostEvent(0, WBP_EVENT_LOCK_FAILED, result, 0);
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(WBP_ContentsLock);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageOrderLock
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_PageOrderLock(void)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(WBP_PageOrderLock);
|
|
|
|
//
|
|
// Check that there is no lock currently
|
|
//
|
|
QUIT_LOCKED(result);
|
|
|
|
//
|
|
// Check that we are not in the process of cancelling a lock request
|
|
//
|
|
QUIT_IF_CANCELLING_LOCK(result, WB_RC_BUSY);
|
|
|
|
//
|
|
// Request the lock
|
|
//
|
|
result = wbLock(WB_LOCK_TYPE_PAGE_ORDER);
|
|
if (result != 0)
|
|
{
|
|
WBP_PostEvent(0, WBP_EVENT_LOCK_FAILED, result, 0);
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(WBP_PageOrderLock);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_Unlock
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_Unlock(void)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(WBP_Unlock);
|
|
|
|
//
|
|
// If we are currently procesing a lock cancel request, leave the
|
|
// function - it should unlock soon anyway.
|
|
//
|
|
QUIT_IF_CANCELLING_LOCK(result, 0);
|
|
|
|
//
|
|
// Check that we are currently processing a lock - the lock need not
|
|
// necessarily have completed as we allow an application to call
|
|
// WBP_Unlock any time after it has called WBP_Lock, effectively
|
|
// cancelling a lock request.
|
|
//
|
|
QUIT_NOT_PROCESSING_LOCK(result);
|
|
|
|
//
|
|
// If we have completed the last lock request, simply do the unlock:
|
|
//
|
|
// The lock is not yet released, but will be when the
|
|
// OM_OBJECT_DELETE_IND is received.
|
|
//
|
|
//
|
|
if (m_lockState == LOCK_STATE_GOT_LOCK)
|
|
{
|
|
TRACE_OUT(("Unlock"));
|
|
wbUnlock();
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Otherwise we are part way through processing the last lock and need
|
|
// to cancel the lock on the next OM/lock event. e.g. when we receive
|
|
// the OM_WS_LOCK indication, we should abandon lock processing and
|
|
// unlock the WS.
|
|
//
|
|
TRACE_OUT((
|
|
"Part way through last lock set state to LOCK_STATE_CANCEL_LOCK"));
|
|
m_lockState = LOCK_STATE_CANCEL_LOCK;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(WBP_Unlock);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_LockStatus
|
|
//
|
|
STDMETHODIMP_(WB_LOCK_TYPE) WbClient::WBP_LockStatus(POM_OBJECT *ppObjPersonLock)
|
|
{
|
|
DebugEntry(WBP_LockStatus);
|
|
|
|
*ppObjPersonLock = m_pObjPersonLock;
|
|
|
|
DebugExitDWORD(WBP_LockStatus, m_lockType);
|
|
return(m_lockType);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_ContentsCountPages
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_ContentsCountPages(void)
|
|
{
|
|
UINT countPages;
|
|
|
|
DebugEntry(WBP_ContentsCountPages);
|
|
|
|
countPages = (m_pageOrder).countPages;
|
|
|
|
DebugExitDWORD(WBP_ContentsCountPages, countPages);
|
|
return(countPages);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageClear
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_PageClear
|
|
(
|
|
WB_PAGE_HANDLE hPage
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(WBP_PageClear);
|
|
|
|
QUIT_CONTENTS_LOCKED(result);
|
|
|
|
result = wbPageClear(hPage, RESET_CHANGED_FLAG);
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_PageClear, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageClearConfirm
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_PageClearConfirm
|
|
(
|
|
WB_PAGE_HANDLE hPage
|
|
)
|
|
{
|
|
DebugEntry(WBP_PageClearConfirm);
|
|
|
|
wbPageClearConfirm(hPage);
|
|
|
|
DebugExitVOID(WBP_PageClearConfirm);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageAddBefore - See wb.h
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_PageAddBefore
|
|
(
|
|
WB_PAGE_HANDLE hRefPage,
|
|
PWB_PAGE_HANDLE phPage
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(WBP_PageAddBefore);
|
|
|
|
//
|
|
// Make sure that we have the page order lock
|
|
//
|
|
QUIT_NOT_GOT_PAGE_ORDER_LOCK(result);
|
|
|
|
//
|
|
// Add a new page before the specified page
|
|
//
|
|
result = wbPageAdd(hRefPage, PAGE_BEFORE, phPage,
|
|
RESET_CHANGED_FLAG);
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_PageAddBefore, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageAddAfter - See wb.h
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_PageAddAfter
|
|
(
|
|
WB_PAGE_HANDLE hRefPage,
|
|
PWB_PAGE_HANDLE phPage
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(WBP_PageAddAfter);
|
|
|
|
//
|
|
// Make sure that we have the Page Order Lock
|
|
//
|
|
QUIT_NOT_GOT_PAGE_ORDER_LOCK(result);
|
|
|
|
//
|
|
// Add a new page before the specified page
|
|
//
|
|
result = wbPageAdd(hRefPage, PAGE_AFTER, phPage,
|
|
RESET_CHANGED_FLAG);
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_PageAddAfter, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageHandle - See wb.h
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_PageHandle
|
|
(
|
|
WB_PAGE_HANDLE hRefPage,
|
|
UINT where,
|
|
PWB_PAGE_HANDLE phPage
|
|
)
|
|
{
|
|
UINT result;
|
|
|
|
DebugEntry(WBP_PageHandle);
|
|
|
|
result = wbPageHandle(hRefPage, where, phPage);
|
|
|
|
DebugExitDWORD(WBP_PageHandle, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageHandleFromNumber
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_PageHandleFromNumber
|
|
(
|
|
UINT pageNumber,
|
|
PWB_PAGE_HANDLE phPage
|
|
)
|
|
{
|
|
UINT result;
|
|
|
|
DebugEntry(WBP_PageHandleFromNumber);
|
|
|
|
result = wbPageHandleFromNumber(pageNumber, phPage);
|
|
|
|
DebugExitDWORD(WBP_PageHandleFromNumber, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageNumberFromHandle
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_PageNumberFromHandle
|
|
(
|
|
WB_PAGE_HANDLE hPage
|
|
)
|
|
{
|
|
UINT pageNumber = 0;
|
|
|
|
DebugEntry(WBP_PageNumberFromHandle);
|
|
|
|
if ((hPage < FIRST_PAGE_WORKSET) || (hPage > FIRST_PAGE_WORKSET + WB_MAX_PAGES - 1))
|
|
{
|
|
WARNING_OUT(("WB: Invalid hPage=%u", (UINT) hPage));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Validate the page handle given
|
|
//
|
|
if (GetPageState(hPage)->state != PAGE_IN_USE)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
pageNumber = wbPageOrderPageNumber(&(m_pageOrder), hPage);
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_PageNumberFromHandle, pageNumber);
|
|
return(pageNumber);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageDelete - See wb.h
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_PageDelete
|
|
(
|
|
WB_PAGE_HANDLE hPage
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
PWB_PAGE_STATE pPageState;
|
|
|
|
DebugEntry(WBP_PageDelete);
|
|
|
|
//
|
|
// Make sure that we have the Page Order Lock
|
|
//
|
|
QUIT_NOT_GOT_PAGE_ORDER_LOCK(result);
|
|
|
|
//
|
|
// Delete the page
|
|
//
|
|
|
|
//
|
|
// Check whether the page is already being deleted
|
|
//
|
|
pPageState = GetPageState(hPage);
|
|
if ( (pPageState->state == PAGE_IN_USE)
|
|
&& (pPageState->subState == PAGE_STATE_EMPTY))
|
|
{
|
|
//
|
|
// Set the page state to show that it is now in the delete process
|
|
//
|
|
pPageState->subState = PAGE_STATE_LOCAL_DELETE;
|
|
TRACE_OUT(("Moved page %d substate to PAGE_STATE_LOCAL_DELETE",
|
|
hPage));
|
|
|
|
//
|
|
// Update the page control object
|
|
//
|
|
if (wbWritePageControl(FALSE) != 0)
|
|
{
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_PageDelete, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageDeleteConfirm - See wb.h
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_PageDeleteConfirm
|
|
(
|
|
WB_PAGE_HANDLE hPage
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
PWB_PAGE_ORDER pPageOrder;
|
|
PWB_PAGE_STATE pPageState;
|
|
|
|
DebugEntry(WBP_PageDeleteConfirm);
|
|
|
|
//
|
|
// Validate the specified page
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Delete the page
|
|
//
|
|
|
|
//
|
|
// Check that the page specified is waiting for a delete confirm
|
|
//
|
|
pPageState = GetPageState(hPage);
|
|
ASSERT(((pPageState->subState == PAGE_STATE_LOCAL_DELETE_CONFIRM) ||
|
|
(pPageState->subState == PAGE_STATE_EXTERNAL_DELETE_CONFIRM)));
|
|
|
|
//
|
|
// Delete the page from the page order
|
|
//
|
|
pPageOrder = &(m_pageOrder);
|
|
|
|
wbPageOrderPageDelete(pPageOrder, hPage);
|
|
|
|
//
|
|
// Clear the page (to free memory)
|
|
//
|
|
if (pPageState->subState == PAGE_STATE_LOCAL_DELETE_CONFIRM)
|
|
{
|
|
TRACE_OUT(("Local delete - clearing the page"));
|
|
if (wbPageClear(hPage, RESET_CHANGED_FLAG) != 0)
|
|
{
|
|
ERROR_OUT(("Unable to clear page"));
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Update the page state to "not in use", with a substate of "ready" (we
|
|
// do not close the associated workset.
|
|
//
|
|
pPageState->state = PAGE_NOT_IN_USE;
|
|
pPageState->subState = PAGE_STATE_READY;
|
|
TRACE_OUT(("Moved page %d state to PAGE_NOT_IN_USE", hPage));
|
|
|
|
//
|
|
// Continue updating the Page Order
|
|
//
|
|
wbProcessPageControlChanges();
|
|
|
|
//
|
|
// Check the load state to see whether we are waiting to load the
|
|
// contents
|
|
//
|
|
if (m_loadState == LOAD_STATE_PENDING_DELETE)
|
|
{
|
|
//
|
|
// We are waiting to load. If there is now only one page available, we
|
|
// are ready to load, otherwise we wait for the further page deletes to
|
|
// happen.
|
|
//
|
|
if (m_pageOrder.countPages == 1)
|
|
{
|
|
//
|
|
// Start the load proper
|
|
//
|
|
wbStartContentsLoad();
|
|
}
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(WBP_PageDeleteConfirm);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageMoveAfter
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_PageMove
|
|
(
|
|
WB_PAGE_HANDLE hRefPage,
|
|
WB_PAGE_HANDLE hPage,
|
|
UINT where
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(WBP_PageMove);
|
|
|
|
//
|
|
// Make sure that we have the Page Order Lock
|
|
//
|
|
QUIT_NOT_GOT_PAGE_ORDER_LOCK(result);
|
|
|
|
//
|
|
// Validate the specified page handles
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
ASSERT(GetPageState(hRefPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Move the page
|
|
//
|
|
result = wbPageMove(hRefPage, hPage, where);
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_PageMove, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PageCountGraphics
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_PageCountGraphics
|
|
(
|
|
WB_PAGE_HANDLE hPage
|
|
)
|
|
{
|
|
UINT count;
|
|
|
|
DebugEntry(WBP_PageCountGraphics);
|
|
|
|
//
|
|
// Count the number of graphics on the page
|
|
//
|
|
OM_WorksetCountObjects(m_pomClient, m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage, &count);
|
|
|
|
DebugExitDWORD(WBP_PageCountGraphics, count);
|
|
return(count);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicAllocate
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_GraphicAllocate
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
UINT length,
|
|
PPWB_GRAPHIC ppGraphic
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
POM_OBJECTDATA pData;
|
|
|
|
DebugEntry(WBP_GraphicAllocate);
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Allocate a graphic object
|
|
//
|
|
result = OM_ObjectAlloc(m_pomClient, m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage, length, &pData);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectAlloc = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Set the length of the object
|
|
//
|
|
pData->length = length;
|
|
|
|
//
|
|
// Convert the ObMan pointer to a core pointer
|
|
//
|
|
*ppGraphic = GraphicPtrFromObjectData(pData);
|
|
|
|
//
|
|
// Initialize the graphic header
|
|
//
|
|
ZeroMemory(*ppGraphic, sizeof(WB_GRAPHIC));
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_GraphicAllocate, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicAddLast
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_GraphicAddLast
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
PWB_GRAPHIC pGraphic,
|
|
PWB_GRAPHIC_HANDLE phGraphic
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
POM_OBJECTDATA pData;
|
|
PWB_PAGE_STATE pPageState;
|
|
|
|
DebugEntry(WBP_GraphicAddLast);
|
|
|
|
//
|
|
// Check whether another person has an active contents lock
|
|
//
|
|
QUIT_CONTENTS_LOCKED(result);
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// If the Client is asking for the lock, copy the local person ID into
|
|
// the graphic object.
|
|
//
|
|
if (pGraphic->locked == WB_GRAPHIC_LOCK_LOCAL)
|
|
{
|
|
pGraphic->lockPersonID = m_personID;
|
|
}
|
|
|
|
//
|
|
// Check whether the page has been deleted but not yet confirmed: in this
|
|
// case return OK but do not add the object to the workset.
|
|
//
|
|
pPageState = GetPageState(hPage);
|
|
if ( (pPageState->subState == PAGE_STATE_EXTERNAL_DELETE)
|
|
|| (pPageState->subState == PAGE_STATE_EXTERNAL_DELETE_CONFIRM))
|
|
{
|
|
TRACE_OUT(("Object add requested in externally deleted page - ignored"));
|
|
*phGraphic = 0;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Add the graphic object to the page
|
|
//
|
|
pData = ObjectDataPtrFromGraphic(pGraphic);
|
|
|
|
result = OM_ObjectAdd(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
&pData,
|
|
sizeof(WB_GRAPHIC),
|
|
phGraphic,
|
|
LAST);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectAdd = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_GraphicAddLast, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicUpdateRequest
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_GraphicUpdateRequest
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic,
|
|
PWB_GRAPHIC pGraphic
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
POM_OBJECTDATA pData;
|
|
PWB_PAGE_STATE pPageState;
|
|
|
|
DebugEntry(WBP_GraphicUpdateRequest);
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Check whether another person has an active contents lock
|
|
//
|
|
QUIT_CONTENTS_LOCKED(result);
|
|
|
|
//
|
|
// Check whether another person has the graphic locked
|
|
//
|
|
QUIT_GRAPHIC_LOCKED(hPage, hGraphic, result);
|
|
|
|
//
|
|
// If the Client is asking for the lock, copy the local person ID into
|
|
// the graphic object.
|
|
//
|
|
if (pGraphic->locked == WB_GRAPHIC_LOCK_LOCAL)
|
|
{
|
|
pGraphic->lockPersonID = m_personID;
|
|
}
|
|
|
|
//
|
|
// Check whether the page has been deleted but not yet confirmed
|
|
//
|
|
pPageState = GetPageState(hPage);
|
|
if ( (pPageState->subState == PAGE_STATE_EXTERNAL_DELETE)
|
|
|| (pPageState->subState == PAGE_STATE_EXTERNAL_DELETE_CONFIRM))
|
|
{
|
|
TRACE_OUT(("Object update requested in externally deleted page - ignored"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Update the object
|
|
//
|
|
pData = ObjectDataPtrFromGraphic(pGraphic);
|
|
|
|
result = OM_ObjectUpdate(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hGraphic,
|
|
&pData);
|
|
|
|
//
|
|
// Dont worry too much if the update fails because the object has been
|
|
// deleted, just trace an alert and return OK - the front end will be
|
|
// told that the object has gone later.
|
|
//
|
|
if (result != 0)
|
|
{
|
|
if (result == OM_RC_OBJECT_DELETED)
|
|
{
|
|
TRACE_OUT(("Update failed because object has been deleted"));
|
|
result = 0;
|
|
DC_QUIT;
|
|
}
|
|
|
|
ERROR_OUT(("OM_ObjectUpdate = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Note that the object has not yet been updated. An
|
|
// OM_OBJECT_UPDATE_IND event will be generated.
|
|
//
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_GraphicUpdateRequest, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicUpdateConfirm
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_GraphicUpdateConfirm
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic
|
|
)
|
|
{
|
|
DebugEntry(WBP_GraphicUpdateConfirm);
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Confirm the update to ObMan
|
|
//
|
|
OM_ObjectUpdateConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hGraphic);
|
|
|
|
|
|
DebugExitVOID(WBP_GraphicUpdateConfirm);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicReplaceRequest
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_GraphicReplaceRequest
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic,
|
|
PWB_GRAPHIC pGraphic
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
POM_OBJECTDATA pData;
|
|
POM_OBJECT pObjPersonLock;
|
|
PWB_PAGE_STATE pPageState;
|
|
|
|
DebugEntry(WBP_GraphicReplaceRequest);
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// We allow the replace to go ahead if:
|
|
// - The object is locked by the local user
|
|
// - The object is not locked and the contents are not locked by
|
|
// a remote user
|
|
//
|
|
// Note that this allow the replace if the contents are locked by another
|
|
// user, but the local user has the object locked.
|
|
//
|
|
if (wbGraphicLocked(hPage, hGraphic, &pObjPersonLock))
|
|
{
|
|
if (pObjPersonLock != m_pObjLocal)
|
|
{
|
|
TRACE_OUT(("Graphic is locked by remote client"));
|
|
result = WB_RC_GRAPHIC_LOCKED;
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
QUIT_CONTENTS_LOCKED(result);
|
|
}
|
|
|
|
//
|
|
// If the Client is asking for the lock, copy the local person ID into
|
|
// the graphic object.
|
|
//
|
|
if (pGraphic->locked == WB_GRAPHIC_LOCK_LOCAL)
|
|
{
|
|
pGraphic->lockPersonID = m_personID;
|
|
}
|
|
|
|
//
|
|
// Check whether the page has been deleted but not yet confirmed
|
|
//
|
|
pPageState = GetPageState(hPage);
|
|
if ( (pPageState->subState == PAGE_STATE_EXTERNAL_DELETE)
|
|
|| (pPageState->subState == PAGE_STATE_EXTERNAL_DELETE_CONFIRM))
|
|
{
|
|
TRACE_OUT(("Object replace requested in externally deleted page - ignored"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Replace the object
|
|
//
|
|
pData = ObjectDataPtrFromGraphic(pGraphic);
|
|
|
|
result = OM_ObjectReplace(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hGraphic,
|
|
&pData);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectReplace = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Note that the object has not yet been updated. An
|
|
// OM_OBJECT_REPLACE_IND event will be generated.
|
|
//
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_GraphicReplaceRequest, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicUpdateConfirm
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_GraphicReplaceConfirm
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic
|
|
)
|
|
{
|
|
DebugEntry(WBP_GraphicReplaceConfirm);
|
|
|
|
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Confirm the update to ObMan
|
|
//
|
|
OM_ObjectReplaceConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hGraphic);
|
|
|
|
DebugExitVOID(WBP_GraphicReplaceConfirm);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicDeleteRequest
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_GraphicDeleteRequest
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(WBP_GraphicDeleteRequest);
|
|
|
|
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Check whether another person has an active contents lock
|
|
//
|
|
QUIT_CONTENTS_LOCKED(result);
|
|
|
|
//
|
|
// Check whether another person has the graphic locked
|
|
//
|
|
QUIT_GRAPHIC_LOCKED(hPage, hGraphic, result);
|
|
|
|
//
|
|
// Delete the object
|
|
//
|
|
result = OM_ObjectDelete(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hGraphic);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectDelete = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Note that at this point the object is not yet deleted. An
|
|
// OM_OBJECT_DELETE_IND event is raised and processed by the Whiteboard
|
|
// Core event handler. A WB_EVENT_GRAPHIC_DELETED is then posted to the
|
|
// client. The client then calls WBP_GraphicDeleteConfirm to complete
|
|
// the deletion.
|
|
//
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_GraphicDeleteRequest, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicDeleteConfirm
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_GraphicDeleteConfirm
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic
|
|
)
|
|
{
|
|
DebugEntry(WBP_GraphicDeleteConfirm);
|
|
|
|
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Confirm the delete
|
|
//
|
|
OM_ObjectDeleteConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hGraphic);
|
|
|
|
|
|
DebugExitVOID(WBP_GraphicDeleteConfirm);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicUnlock
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_GraphicUnlock
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic
|
|
)
|
|
{
|
|
UINT rc;
|
|
POM_OBJECTDATA pData;
|
|
PWB_PAGE_STATE pPageState;
|
|
PWB_GRAPHIC pGraphic = NULL;
|
|
PWB_GRAPHIC pNewGraphic = NULL;
|
|
|
|
DebugEntry(WBP_GraphicUnlock);
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Check whether the page has been deleted but not yet confirmed
|
|
//
|
|
pPageState = GetPageState(hPage);
|
|
if ( (pPageState->subState == PAGE_STATE_EXTERNAL_DELETE)
|
|
|| (pPageState->subState == PAGE_STATE_EXTERNAL_DELETE_CONFIRM))
|
|
{
|
|
TRACE_OUT(("Object update requested in externally deleted page - ignored"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Read the object from ObMan
|
|
//
|
|
if (WBP_GraphicGet(hPage, hGraphic, &pGraphic) != 0)
|
|
{
|
|
TRACE_OUT(("Could not get graphic - leaving function"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Check the local client has the graphic locked
|
|
//
|
|
QUIT_GRAPHIC_NOT_LOCKED(pGraphic, rc);
|
|
|
|
//
|
|
// Allocate a new graphic, copied from the existing one, and clear the
|
|
// lock field.
|
|
//
|
|
if (WBP_GraphicAllocate(hPage, sizeof(WB_GRAPHIC),
|
|
&pNewGraphic) != 0)
|
|
{
|
|
ERROR_OUT(("Could not allocate memory for update object"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
memcpy(pNewGraphic, pGraphic, sizeof(WB_GRAPHIC));
|
|
pNewGraphic->locked = WB_GRAPHIC_LOCK_NONE;
|
|
|
|
//
|
|
// Unlock & update the object
|
|
//
|
|
pData = ObjectDataPtrFromGraphic(pNewGraphic);
|
|
pData->length = sizeof(WB_GRAPHIC);
|
|
|
|
rc = OM_ObjectUpdate(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hGraphic,
|
|
&pData);
|
|
|
|
//
|
|
// Dont worry too much if the update fails because the object has been
|
|
// deleted, just trace an alert and return OK - the front end will be
|
|
// told that the object has gone later.
|
|
//
|
|
if (rc != 0)
|
|
{
|
|
if (rc == OM_RC_OBJECT_DELETED)
|
|
{
|
|
TRACE_OUT(("Update failed because object has been deleted"));
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("OM_ObjectUpdate = %d", rc));
|
|
}
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Note that the object has not yet been updated. An
|
|
// OM_OBJECT_UPDATE_IND event will be generated.
|
|
//
|
|
|
|
DC_EXIT_POINT:
|
|
//
|
|
// If we read the graphic successfully, release it now
|
|
//
|
|
if (pGraphic != NULL)
|
|
{
|
|
WBP_GraphicRelease(hPage, hGraphic, pGraphic);
|
|
}
|
|
|
|
DebugExitVOID(WBP_GraphicUnlock);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicMove
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_GraphicMove
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic,
|
|
UINT where
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
PWB_PAGE_STATE pPageState;
|
|
|
|
DebugEntry(WBP_GraphicMove);
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Check whether another person has an active contents lock
|
|
//
|
|
QUIT_CONTENTS_LOCKED(result);
|
|
|
|
//
|
|
// Check whether the page has been deleted but not yet confirmed
|
|
//
|
|
pPageState = GetPageState(hPage);
|
|
if ( (pPageState->subState == PAGE_STATE_EXTERNAL_DELETE)
|
|
|| (pPageState->subState == PAGE_STATE_EXTERNAL_DELETE_CONFIRM))
|
|
{
|
|
TRACE_OUT(("Object moved in externally deleted page - ignored"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Do the move
|
|
//
|
|
result = OM_ObjectMove(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hGraphic,
|
|
(OM_POSITION)where);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectMove = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_GraphicMove, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicSelectLast
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_GraphicSelect
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
POINT point,
|
|
WB_GRAPHIC_HANDLE hRefGraphic,
|
|
UINT where,
|
|
PWB_GRAPHIC_HANDLE phGraphic
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(WBP_GraphicSelect);
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Get the handle of the last object in the workset
|
|
//
|
|
result = OM_ObjectH(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hRefGraphic,
|
|
&hRefGraphic,
|
|
(OM_POSITION)where);
|
|
|
|
if (result == OM_RC_NO_SUCH_OBJECT)
|
|
{
|
|
result = WB_RC_NO_SUCH_GRAPHIC;
|
|
DC_QUIT;
|
|
}
|
|
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectH = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Get the previous matching graphic - this function starts from the
|
|
// object in hRefGraphic and works back.
|
|
//
|
|
result = wbGraphicSelectPrevious(hPage,
|
|
&point,
|
|
hRefGraphic,
|
|
phGraphic);
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_GraphicSelect, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicGet
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_GraphicGet
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic,
|
|
PPWB_GRAPHIC ppGraphic
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
UINT rc;
|
|
POM_OBJECTDATA pData;
|
|
PWB_GRAPHIC pGraphic;
|
|
POM_OBJECT pObjPersonLock;
|
|
|
|
DebugEntry(WBP_GraphicGet);
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Read the object.
|
|
//
|
|
result = OM_ObjectRead(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hGraphic,
|
|
&pData);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectRead = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Convert the ObMan pointer to a core pointer
|
|
//
|
|
pGraphic = GraphicPtrFromObjectData(pData);
|
|
|
|
//
|
|
// If the graphic object indicates that it is locked - verify that the
|
|
// locking person is still in the call.
|
|
//
|
|
if (pGraphic->locked != WB_GRAPHIC_LOCK_NONE)
|
|
{
|
|
TRACE_OUT(("Graphic has lock flag set"));
|
|
|
|
//
|
|
// Convert the lock person ID in the graphic to a person handle
|
|
//
|
|
rc = OM_ObjectIDToPtr(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pGraphic->lockPersonID,
|
|
&pObjPersonLock);
|
|
|
|
if (rc == OM_RC_BAD_OBJECT_ID)
|
|
{
|
|
//
|
|
// The locking person is no longer in the call - reset the lock flag
|
|
// in the graphic. This tells the client that the graphic can be
|
|
// changed.
|
|
//
|
|
TRACE_OUT(("Lock person has left call - resetting lock flag"));
|
|
pGraphic->locked = WB_GRAPHIC_LOCK_NONE;
|
|
}
|
|
else
|
|
{
|
|
if (rc == 0)
|
|
{
|
|
//
|
|
// The object is locked - check whether the lock belongs to the
|
|
// local person or a remote person.
|
|
//
|
|
if (pObjPersonLock == m_pObjLocal)
|
|
{
|
|
//
|
|
// Change the lock type to local to tell the client that they
|
|
// have the lock on this object.
|
|
//
|
|
TRACE_OUT(("Lock belongs to local person"));
|
|
pGraphic->locked = WB_GRAPHIC_LOCK_LOCAL;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Change the lock type to remote to tell the client that another
|
|
// person has the lock on this object.
|
|
//
|
|
TRACE_OUT(("Lock belongs to remote person"));
|
|
pGraphic->locked = WB_GRAPHIC_LOCK_REMOTE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Return the pointer to the graphic data
|
|
//
|
|
*ppGraphic = pGraphic;
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_GraphicGet, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicRelease
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_GraphicRelease
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic,
|
|
PWB_GRAPHIC pGraphic
|
|
)
|
|
{
|
|
POM_OBJECTDATA pData;
|
|
|
|
DebugEntry(WBP_GraphicRelease);
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Release the object.
|
|
//
|
|
pData = ObjectDataPtrFromGraphic(pGraphic);
|
|
OM_ObjectRelease(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hGraphic,
|
|
&pData);
|
|
|
|
|
|
DebugExitVOID(WBP_GraphicRelease);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_GraphicHandle
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_GraphicHandle
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hRefGraphic,
|
|
UINT where,
|
|
PWB_GRAPHIC_HANDLE phGraphic
|
|
)
|
|
{
|
|
UINT result;
|
|
|
|
DebugEntry(WBP_GraphicHandle);
|
|
|
|
|
|
|
|
//
|
|
// Check that the page handle is valid
|
|
//
|
|
ASSERT(GetPageState(hPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Get the handle of the first object in the page workset.
|
|
//
|
|
result = OM_ObjectH(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
hRefGraphic,
|
|
phGraphic,
|
|
(OM_POSITION)where);
|
|
if (result == OM_RC_NO_SUCH_OBJECT)
|
|
{
|
|
TRACE_OUT(("No objects there"));
|
|
result = WB_RC_NO_SUCH_GRAPHIC;
|
|
}
|
|
|
|
|
|
DebugExitDWORD(WBP_GraphicHandle, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_PersonHandleFirst
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_PersonHandleFirst
|
|
(
|
|
POM_OBJECT * ppObjPerson
|
|
)
|
|
{
|
|
DebugEntry(WBP_PersonHandleFirst);
|
|
|
|
OM_ObjectH(m_pomClient, m_hWSGroup,
|
|
USER_INFORMATION_WORKSET, 0, ppObjPerson, FIRST);
|
|
|
|
DebugExitVOID(WBP_PersonHandleFirst);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_PersonHandleNext
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_PersonHandleNext
|
|
(
|
|
POM_OBJECT pObjPerson,
|
|
POM_OBJECT * ppObjPersonNext
|
|
)
|
|
{
|
|
UINT rc;
|
|
|
|
DebugEntry(WBP_PersonHandleNext);
|
|
|
|
//
|
|
// Get the handle of the next object in the user information workset.
|
|
//
|
|
rc = OM_ObjectH(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pObjPerson,
|
|
ppObjPersonNext,
|
|
AFTER);
|
|
|
|
if (rc == OM_RC_NO_SUCH_OBJECT)
|
|
{
|
|
rc = WB_RC_NO_SUCH_PERSON;
|
|
}
|
|
else if (rc != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectNextH = %d", rc));
|
|
}
|
|
|
|
|
|
DebugExitDWORD(WBP_PersonHandleNext, rc);
|
|
return(rc);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PersonHandleLocal
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_PersonHandleLocal
|
|
(
|
|
POM_OBJECT * ppObjPerson
|
|
)
|
|
{
|
|
DebugEntry(WBP_PersonHandleLocal);
|
|
|
|
*ppObjPerson = m_pObjLocal;
|
|
|
|
DebugExitVOID(WBP_PersonHandleLocal);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PersonCountInCall
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_PersonCountInCall(void)
|
|
{
|
|
UINT count;
|
|
POM_OBJECT pObj;
|
|
|
|
DebugEntry(WBP_PersonCountInCall);
|
|
|
|
//
|
|
// Get the count:
|
|
//
|
|
pObj = NULL;
|
|
WBP_PersonHandleFirst(&pObj);
|
|
for (count = 1; ; count++)
|
|
{
|
|
if (WBP_PersonHandleNext(pObj, &pObj) == WB_RC_NO_SUCH_PERSON)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
DebugExitDWORD(WBP_PersonCountInCall, count);
|
|
return(count);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_GetPersonData
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_GetPersonData
|
|
(
|
|
POM_OBJECT pObjPerson,
|
|
PWB_PERSON pPerson
|
|
)
|
|
{
|
|
UINT rc;
|
|
|
|
DebugEntry(WBP_GetPersonData);
|
|
|
|
ASSERT(!IsBadWritePtr(pPerson, sizeof(WB_PERSON)));
|
|
|
|
//
|
|
// Get the object.
|
|
//
|
|
rc = wbPersonGet(pObjPerson, pPerson);
|
|
|
|
DebugExitDWORD(WBP_GetPersonData, rc);
|
|
return(rc);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_SetLocalPersonData
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_SetLocalPersonData(PWB_PERSON pPerson)
|
|
{
|
|
UINT rc;
|
|
POM_OBJECTDATA pUserObject;
|
|
|
|
DebugEntry(WBP_SetPersonData);
|
|
|
|
ASSERT(!IsBadReadPtr(pPerson, sizeof(WB_PERSON)));
|
|
|
|
//
|
|
// Allocate a user object
|
|
//
|
|
rc = OM_ObjectAlloc(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
sizeof(WB_PERSON),
|
|
&pUserObject);
|
|
if (rc != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectAlloc = %d", rc));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Set the length of the object
|
|
//
|
|
pUserObject->length = sizeof(WB_PERSON);
|
|
|
|
//
|
|
// Copy the user information into the ObMan object
|
|
//
|
|
memcpy(pUserObject->data, pPerson, sizeof(WB_PERSON));
|
|
|
|
//
|
|
// Replace the user object
|
|
//
|
|
rc = OM_ObjectReplace(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
m_pObjLocal,
|
|
&pUserObject);
|
|
if (rc != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectReplace"));
|
|
|
|
//
|
|
// Discard the object
|
|
//
|
|
OM_ObjectDiscard(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
&pUserObject);
|
|
|
|
DC_QUIT;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
//
|
|
// Note that the object has not yet been updated. An
|
|
// OM_OBJECT_UPDATE_IND event will be generated.
|
|
//
|
|
DebugExitDWORD(WBP_SetPersonData, rc);
|
|
return(rc);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PersonUpdateConfirm
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_PersonUpdateConfirm
|
|
(
|
|
POM_OBJECT pObjPerson
|
|
)
|
|
{
|
|
DebugEntry(WBP_PersonUpdateConfirm);
|
|
|
|
//
|
|
// Confirm the update to ObMan
|
|
//
|
|
OM_ObjectUpdateConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pObjPerson);
|
|
|
|
DebugExitVOID(WBP_PersonUpdateConfirm);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// WBP_PersonReplaceConfirm
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_PersonReplaceConfirm
|
|
(
|
|
POM_OBJECT pObjPerson
|
|
)
|
|
{
|
|
DebugEntry(WBP_PersonReplaceConfirm);
|
|
|
|
//
|
|
// Confirm the replace to ObMan
|
|
//
|
|
OM_ObjectReplaceConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pObjPerson);
|
|
|
|
DebugExitVOID(WBP_PersonReplaceConfirm);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_PersonLeftConfirm
|
|
//
|
|
STDMETHODIMP_(void) WbClient::WBP_PersonLeftConfirm
|
|
(
|
|
POM_OBJECT pObjPerson
|
|
)
|
|
{
|
|
DebugEntry(WBP_PersonLeftConfirm);
|
|
|
|
//
|
|
// Confirm the update to ObMan
|
|
//
|
|
OM_ObjectDeleteConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pObjPerson);
|
|
|
|
DebugExitVOID(WBP_PersonLeftConfirm);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_SyncPositionGet
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_SyncPositionGet
|
|
(
|
|
PWB_SYNC pSync
|
|
)
|
|
{
|
|
UINT result;
|
|
POM_OBJECTDATA pSyncObject = NULL;
|
|
PWB_SYNC_CONTROL pSyncControl = NULL;
|
|
|
|
DebugEntry(WBP_SyncPositionGet);
|
|
|
|
|
|
ASSERT(!IsBadWritePtr(pSync, sizeof(WB_SYNC)));
|
|
|
|
//
|
|
// Read the Sync Control object
|
|
//
|
|
result = OM_ObjectRead(m_pomClient,
|
|
m_hWSGroup,
|
|
SYNC_CONTROL_WORKSET,
|
|
m_pObjSyncControl,
|
|
&pSyncObject);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Error reading Sync Control Object = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
pSyncControl = (PWB_SYNC_CONTROL) pSyncObject->data;
|
|
|
|
//
|
|
// Copy the Sync Person details to the result field
|
|
// NOTE:
|
|
// LiveLan sends a larger object, we need to ignore the stuff past the
|
|
// end.
|
|
//
|
|
if (pSyncControl->sync.length != sizeof(WB_SYNC))
|
|
{
|
|
WARNING_OUT(("WBP_SyncPositionGet (interop): Remote created WB_SYNC of size %d, we expected size %d",
|
|
pSyncControl->sync.length, sizeof(WB_SYNC)));
|
|
}
|
|
memcpy(pSync, &pSyncControl->sync, min(sizeof(WB_SYNC), pSyncControl->sync.length));
|
|
|
|
//
|
|
// Release the Sync Control Object
|
|
//
|
|
OM_ObjectRelease(m_pomClient,
|
|
m_hWSGroup,
|
|
SYNC_CONTROL_WORKSET,
|
|
m_pObjSyncControl,
|
|
&pSyncObject);
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_SyncPositionGet, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_SyncPositionUpdate
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_SyncPositionUpdate
|
|
(
|
|
PWB_SYNC pSync
|
|
)
|
|
{
|
|
UINT result;
|
|
POM_OBJECTDATA pSyncObject = NULL;
|
|
PWB_SYNC_CONTROL pSyncControl = NULL;
|
|
|
|
DebugEntry(WBP_SyncPositionUpdate);
|
|
|
|
ASSERT(!IsBadReadPtr(pSync, sizeof(WB_SYNC)));
|
|
|
|
//
|
|
// Write the new sync control object (do not create it)
|
|
//
|
|
result = wbWriteSyncControl(pSync, FALSE);
|
|
|
|
DebugExitDWORD(WBP_SyncPositionUpdate, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// WBP_CancelLoad
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_CancelLoad(void)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(WBP_CancelLoad);
|
|
|
|
//
|
|
// Check a load is in progress
|
|
//
|
|
if (m_loadState == LOAD_STATE_EMPTY)
|
|
{
|
|
TRACE_OUT(("request to cancel load, but there is no load in progress"));
|
|
result = WB_RC_NOT_LOADING;
|
|
DC_QUIT;
|
|
}
|
|
|
|
TRACE_OUT(("Cancelling load in progress"));
|
|
|
|
//
|
|
// Close the file
|
|
//
|
|
if (m_hLoadFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
CloseHandle(m_hLoadFile);
|
|
m_hLoadFile = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
//
|
|
// reset the load state to show we're no longer loading.
|
|
//
|
|
m_loadState = LOAD_STATE_EMPTY;
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(WBP_CancelLoad, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: WBP_ValidateFile
|
|
//
|
|
// Purpose: Validate that a passed filename holds a valid whiteboard file
|
|
//
|
|
// Returns: 0 if successful
|
|
// !0 if an error
|
|
//
|
|
//
|
|
STDMETHODIMP_(UINT) WbClient::WBP_ValidateFile
|
|
(
|
|
LPCSTR pFileName,
|
|
HANDLE * phFile
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
HANDLE hFile;
|
|
WB_FILE_HEADER fileHeader;
|
|
UINT length;
|
|
ULONG cbSizeRead;
|
|
BOOL fileOpen = FALSE;
|
|
|
|
DebugEntry(WBP_ValidateFile);
|
|
|
|
//
|
|
// Open the file
|
|
//
|
|
hFile = CreateFile(pFileName, GENERIC_READ, 0, NULL,
|
|
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
{
|
|
WARNING_OUT(("Error opening file, win32 err=%d", GetLastError()));
|
|
result = WB_RC_CREATE_FAILED;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Show that we have opened the file successfully
|
|
//
|
|
fileOpen = TRUE;
|
|
|
|
//
|
|
// Read the file header length
|
|
//
|
|
if (! ReadFile(hFile, (void *) &length, sizeof(length), &cbSizeRead, NULL))
|
|
{
|
|
WARNING_OUT(("Error reading file header length, win32 err=%d", GetLastError()));
|
|
result = WB_RC_READ_FAILED;
|
|
DC_QUIT;
|
|
}
|
|
ASSERT(cbSizeRead == sizeof(length));
|
|
|
|
if (length != sizeof(fileHeader))
|
|
{
|
|
WARNING_OUT(("Bad file header"));
|
|
result = WB_RC_BAD_FILE_FORMAT;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Read the file header
|
|
//
|
|
if (! ReadFile(hFile, (void *) &fileHeader, sizeof(fileHeader), &cbSizeRead, NULL))
|
|
{
|
|
WARNING_OUT(("Error reading file header, win32 err=%d", GetLastError()));
|
|
result = WB_RC_READ_FAILED;
|
|
DC_QUIT;
|
|
}
|
|
|
|
if (cbSizeRead != sizeof(fileHeader))
|
|
{
|
|
WARNING_OUT(("Could not read file header"));
|
|
result = WB_RC_BAD_FILE_FORMAT;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Validate the file header
|
|
//
|
|
if ( (fileHeader.type != TYPE_FILE_HEADER)
|
|
|| lstrcmp(fileHeader.functionProfile, WB_FP_NAME))
|
|
{
|
|
WARNING_OUT(("Bad function profile in file header"));
|
|
result = WB_RC_BAD_FILE_FORMAT;
|
|
DC_QUIT;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
|
|
//
|
|
// Return the handle, if the user needs it.
|
|
//
|
|
if ( (result == 0) && (phFile != NULL))
|
|
{
|
|
TRACE_OUT(("return file handle"));
|
|
*phFile = hFile;
|
|
}
|
|
|
|
//
|
|
// Close the file if there has been an error or the caller simply
|
|
// doesnt want the file handle.
|
|
//
|
|
if ( (fileOpen) &&
|
|
((phFile == NULL) || (result != 0)) )
|
|
{
|
|
CloseHandle(hFile);
|
|
}
|
|
|
|
DebugExitDWORD(WBP_ValidateFile, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbGraphicLocked
|
|
//
|
|
// Purpose: Test whether a client has a lock on the specified graphic, and
|
|
// if so, return the person handle of the client holding the lock.
|
|
//
|
|
// Returns: TRUE if a client has a lock
|
|
// FALSE otherwise
|
|
//
|
|
//
|
|
BOOL WbClient::wbGraphicLocked
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
WB_GRAPHIC_HANDLE hGraphic,
|
|
POM_OBJECT * ppObjLock
|
|
)
|
|
{
|
|
BOOL result = FALSE;
|
|
UINT rc;
|
|
PWB_GRAPHIC pGraphic = NULL;
|
|
|
|
DebugEntry(wbGraphicLocked);
|
|
|
|
//
|
|
// Read the object
|
|
//
|
|
if (WBP_GraphicGet(hPage, hGraphic, &pGraphic) != 0)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Look at its lock details
|
|
//
|
|
if (pGraphic->locked != WB_GRAPHIC_LOCK_NONE)
|
|
{
|
|
//
|
|
// The lock flag in the graphic is set
|
|
//
|
|
|
|
//
|
|
// Convert the lock user ID in the graphic to a handle
|
|
//
|
|
rc = OM_ObjectIDToPtr(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pGraphic->lockPersonID,
|
|
ppObjLock);
|
|
|
|
if (rc == 0)
|
|
{
|
|
|
|
TRACE_OUT(("Graphic is locked"));
|
|
result = TRUE;
|
|
DC_QUIT;
|
|
}
|
|
|
|
if (rc != OM_RC_BAD_OBJECT_ID)
|
|
{
|
|
//
|
|
// An error occurred in converting the objectID
|
|
//
|
|
TRACE_OUT(("Error converting object ID to handle"));
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// The object is not locked (or the lock user has left the call)
|
|
//
|
|
TRACE_OUT(("Graphic is not locked"));
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
//
|
|
// If the graphic is still held by us, release it
|
|
//
|
|
if (pGraphic != NULL)
|
|
{
|
|
WBP_GraphicRelease(hPage, hGraphic, pGraphic);
|
|
}
|
|
|
|
DebugExitBOOL(wbGraphicLocked, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbAddLocalUserObject
|
|
//
|
|
// Purpose: Add an object to the user information workset for the local
|
|
// user.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbAddLocalUserObject(void)
|
|
{
|
|
UINT rc;
|
|
POM_OBJECTDATA pData;
|
|
PWB_PERSON pUser;
|
|
CM_STATUS cmStatus;
|
|
|
|
DebugEntry(wbAddLocalUserObject);
|
|
|
|
TRACE_OUT(("Adding the necessary control objects"));
|
|
|
|
//
|
|
// Build a user object for this user and write it to the User Information
|
|
// Workset.
|
|
//
|
|
rc = OM_ObjectAlloc(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
sizeof(WB_PERSON),
|
|
&pData);
|
|
if (rc != 0)
|
|
{
|
|
ERROR_OUT(("Error allocating object = %d", rc));
|
|
DC_QUIT;
|
|
}
|
|
|
|
pData->length = sizeof(WB_PERSON);
|
|
pUser = (PWB_PERSON) (pData->data);
|
|
|
|
//
|
|
// Initialize the contents of the user object for this user
|
|
//
|
|
TRACE_OUT(("Initialising user contents"));
|
|
|
|
ZeroMemory(pUser, sizeof(WB_PERSON));
|
|
|
|
pUser->currentPage = FIRST_PAGE_WORKSET; // lonchanc: it was 1.
|
|
pUser->synced = FALSE;
|
|
pUser->pointerActive = FALSE;
|
|
pUser->pointerPage = FIRST_PAGE_WORKSET; // lonchanc: it was 1.
|
|
pUser->colorId = (TSHR_UINT16)wbSelectPersonColor();
|
|
|
|
//
|
|
// Fill in the Call Manager personID if we are in a call.
|
|
//
|
|
if (CMS_GetStatus(&cmStatus))
|
|
{
|
|
TRACE_OUT(("CMG personID %u", cmStatus.localHandle));
|
|
pUser->cmgPersonID = cmStatus.localHandle;
|
|
}
|
|
else
|
|
{
|
|
pUser->cmgPersonID = 0;
|
|
}
|
|
|
|
//
|
|
// Copy the user name into the object:
|
|
//
|
|
lstrcpy(pUser->personName, cmStatus.localName);
|
|
|
|
//
|
|
// Copy the person's color into the client's data
|
|
//
|
|
m_colorId = pUser->colorId;
|
|
|
|
//
|
|
// Add the object to the User Information Workset, saving the handle of
|
|
// the user object in the client details.
|
|
//
|
|
rc = OM_ObjectAdd(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
&pData,
|
|
WB_PERSON_OBJECT_UPDATE_SIZE,
|
|
&m_pObjLocal,
|
|
LAST);
|
|
if (rc != 0)
|
|
{
|
|
//
|
|
// The add failed, we must discard the object
|
|
//
|
|
OM_ObjectDiscard(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
&pData);
|
|
|
|
ERROR_OUT(("Error adding user object = %d", rc));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Save the ID of this user in the client details (for later use in the
|
|
// lock information).
|
|
//
|
|
OM_ObjectPtrToID(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
m_pObjLocal,
|
|
&(m_personID));
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbAddLocalUserObject, rc);
|
|
return(rc);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbGetEmptyPageHandle
|
|
//
|
|
// Purpose: Return a handle for a page that does not have its workset open.
|
|
//
|
|
// Returns: Handle of free page (or 0 if none exists)
|
|
//
|
|
//
|
|
WB_PAGE_HANDLE WbClient::wbGetEmptyPageHandle(void)
|
|
{
|
|
UINT index;
|
|
WB_PAGE_HANDLE hPage = WB_PAGE_HANDLE_NULL;
|
|
PWB_PAGE_STATE pPageState = m_pageStates;
|
|
|
|
//
|
|
// Search the page list for an empty entry
|
|
//
|
|
for (index = 0; index < WB_MAX_PAGES; index++, pPageState++)
|
|
{
|
|
if ( (pPageState->state == PAGE_NOT_IN_USE)
|
|
&& (pPageState->subState == PAGE_STATE_EMPTY))
|
|
{
|
|
hPage = PAGE_INDEX_TO_HANDLE(index);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
return(hPage);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbGetReadyPageHandle
|
|
//
|
|
// Purpose: Return a handle for a page that has its workset open but is not
|
|
// currently in use.
|
|
//
|
|
// Returns: Handle of free page (or 0 if none exists)
|
|
//
|
|
//
|
|
WB_PAGE_HANDLE WbClient::wbGetReadyPageHandle(void)
|
|
{
|
|
UINT index;
|
|
WB_PAGE_HANDLE hPage = WB_PAGE_HANDLE_NULL;
|
|
PWB_PAGE_STATE pPageState = m_pageStates;
|
|
|
|
//
|
|
// Search the page list for a ready entry
|
|
//
|
|
for (index = 0; index < WB_MAX_PAGES; index++, pPageState++)
|
|
{
|
|
if ( (pPageState->state == PAGE_NOT_IN_USE)
|
|
&& (pPageState->subState == PAGE_STATE_READY))
|
|
{
|
|
hPage = PAGE_INDEX_TO_HANDLE(index);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(hPage);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageOrderPageNumber
|
|
//
|
|
// Purpose: Return the number of the specified page.
|
|
// This function performs no validation on its parameters.
|
|
//
|
|
// Returns: None
|
|
//
|
|
//
|
|
UINT WbClient::wbPageOrderPageNumber
|
|
(
|
|
PWB_PAGE_ORDER pPageOrder,
|
|
WB_PAGE_HANDLE hPage
|
|
)
|
|
{
|
|
UINT index;
|
|
POM_WORKSET_ID pPage = pPageOrder->pages;
|
|
|
|
DebugEntry(wbPageOrderPageNumber);
|
|
|
|
//
|
|
// Search the page order list for the page handle (workset ID)
|
|
//
|
|
for (index = 0; index <= pPageOrder->countPages; index++)
|
|
{
|
|
if (pPage[index] == (OM_WORKSET_ID)hPage)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// The page was not found - this is an internal error
|
|
//
|
|
ERROR_OUT(("Page handle not found"));
|
|
|
|
//
|
|
// Return the page number starting from 1.
|
|
//
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbPageOrderPageNumber, index + 1);
|
|
return(index + 1);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageOrderPageAdd
|
|
//
|
|
// Purpose: Add a new page to a page order structure. This function expects
|
|
// the parameters to be valid - they must be checked before
|
|
// calling it. It also assumes that there is space in the page
|
|
// list for the new page.
|
|
//
|
|
// Params: pPageOrder - pointer to page list
|
|
// hRefPage - page used as a reference point for the new page
|
|
// hPage - handle of the page to be added
|
|
// where - relative position - before or after hRefPage
|
|
//
|
|
// Returns: None
|
|
//
|
|
//
|
|
void WbClient::wbPageOrderPageAdd
|
|
(
|
|
PWB_PAGE_ORDER pPageOrder,
|
|
WB_PAGE_HANDLE hRefPage,
|
|
WB_PAGE_HANDLE hPage,
|
|
UINT where
|
|
)
|
|
{
|
|
UINT index;
|
|
POM_WORKSET_ID pPage = pPageOrder->pages;
|
|
|
|
DebugEntry(wbPageOrderPageAdd);
|
|
|
|
//
|
|
// Process according to the add position
|
|
//
|
|
switch(where)
|
|
{
|
|
case PAGE_FIRST:
|
|
index = 0;
|
|
if (pPageOrder->countPages != 0)
|
|
{
|
|
UT_MoveMemory(&pPage[1], &pPage[0], pPageOrder->countPages*sizeof(pPage[0]));
|
|
}
|
|
break;
|
|
|
|
case PAGE_LAST:
|
|
index = pPageOrder->countPages;
|
|
break;
|
|
|
|
case PAGE_AFTER:
|
|
case PAGE_BEFORE:
|
|
//
|
|
// Make an empty space in the page order list
|
|
//
|
|
index = wbPageOrderPageNumber(pPageOrder, hRefPage);
|
|
if (where == PAGE_BEFORE)
|
|
{
|
|
index--;
|
|
}
|
|
|
|
UT_MoveMemory(&pPage[index + 1], &pPage[index],
|
|
(pPageOrder->countPages - index)*sizeof(pPage[0]));
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad where parameter"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Save the new page handle in the list
|
|
//
|
|
pPage[index] = hPage;
|
|
|
|
//
|
|
// Show that the extra page is now present
|
|
//
|
|
pPageOrder->countPages += 1;
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbPageOrderPageAdd);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageOrderPageDelete
|
|
//
|
|
// Purpose: Remove the specified page from a page order structure. This
|
|
// function expects its the parameters to be valid - they must be
|
|
// checked before calling it.
|
|
//
|
|
// Returns: None
|
|
//
|
|
//
|
|
void WbClient::wbPageOrderPageDelete
|
|
(
|
|
PWB_PAGE_ORDER pPageOrder,
|
|
WB_PAGE_HANDLE hPage
|
|
)
|
|
{
|
|
UINT index;
|
|
POM_WORKSET_ID pPage = pPageOrder->pages;
|
|
|
|
DebugEntry(wbPageOrderPageDelete);
|
|
|
|
index = wbPageOrderPageNumber(pPageOrder, hPage);
|
|
UT_MoveMemory(&pPage[index - 1],
|
|
&pPage[index],
|
|
(pPageOrder->countPages - index)*sizeof(pPage[0]));
|
|
|
|
pPageOrder->countPages -= 1;
|
|
|
|
DebugExitVOID(wbPageOrderPageDelete);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPagesPageAdd
|
|
//
|
|
// Purpose: Add a new page to the internal page list. This function expects
|
|
// the parameters to be valid - they must be checked before
|
|
// calling it. It also assumes that there is space in the page
|
|
// list for the new page.
|
|
//
|
|
// Returns: None
|
|
//
|
|
//
|
|
void WbClient::wbPagesPageAdd
|
|
(
|
|
WB_PAGE_HANDLE hRefPage,
|
|
WB_PAGE_HANDLE hPage,
|
|
UINT where
|
|
)
|
|
{
|
|
PWB_PAGE_STATE pPageState;
|
|
|
|
DebugEntry(wbPagesPageAdd);
|
|
|
|
//
|
|
// Add the page to the page order structure
|
|
//
|
|
wbPageOrderPageAdd(&(m_pageOrder), hRefPage, hPage, where);
|
|
|
|
//
|
|
// Update the page state information
|
|
//
|
|
pPageState = GetPageState(hPage);
|
|
pPageState->state = PAGE_IN_USE;
|
|
pPageState->subState = PAGE_STATE_EMPTY;
|
|
|
|
DebugExitVOID(wbPagesPageAdd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbClientReset
|
|
//
|
|
// Purpose: Reset the client data to a state where the client is not in a
|
|
// call, but is registered with ObMan and has event and exit
|
|
// handlers registered with utilities.
|
|
//
|
|
// Returns: None
|
|
//
|
|
//
|
|
void WbClient::wbClientReset(void)
|
|
{
|
|
UINT index;
|
|
PWB_PAGE_ORDER pPageOrder = &(m_pageOrder);
|
|
PWB_PAGE_STATE pPageState = m_pageStates;
|
|
|
|
DebugEntry(wbClientReset);
|
|
|
|
//
|
|
// Initialize object handles
|
|
//
|
|
m_hWSGroup = (OM_WSGROUP_HANDLE) NULL;
|
|
|
|
m_pObjPageControl = NULL;
|
|
m_pObjSyncControl = NULL;
|
|
m_pObjLocal = NULL;
|
|
|
|
m_pObjLock = NULL;
|
|
m_pObjPersonLock = NULL;
|
|
|
|
//
|
|
// Initialize the status variables
|
|
//
|
|
m_errorState = ERROR_STATE_EMPTY;
|
|
m_changed = FALSE;
|
|
m_lockState = LOCK_STATE_EMPTY;
|
|
m_lockType = WB_LOCK_TYPE_NONE;
|
|
m_lockRequestType = WB_LOCK_TYPE_NONE;
|
|
|
|
m_loadState = LOAD_STATE_EMPTY;
|
|
if (m_hLoadFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
CloseHandle(m_hLoadFile);
|
|
m_hLoadFile = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
m_countReadyPages = 0;
|
|
|
|
|
|
//
|
|
// Zero the whole structure
|
|
//
|
|
ZeroMemory(pPageOrder, sizeof(*pPageOrder));
|
|
|
|
//
|
|
// Set the object type
|
|
//
|
|
pPageOrder->objectType = TYPE_CONTROL_PAGE_ORDER;
|
|
|
|
//
|
|
// Set up the page control elements
|
|
//
|
|
pPageOrder->generationLo = 1;
|
|
pPageOrder->generationHi = 0;
|
|
pPageOrder->countPages = 0;
|
|
|
|
//
|
|
// Initialize the page state structures
|
|
//
|
|
for (index = 0; index < WB_MAX_PAGES; index++, pPageState++)
|
|
{
|
|
pPageState->state = PAGE_NOT_IN_USE;
|
|
pPageState->subState = PAGE_STATE_EMPTY;
|
|
}
|
|
|
|
DebugExitVOID(wbClientReset);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWsGroupRegisterCon
|
|
//
|
|
// Purpose: Routine processing OM_WSGROUP_REGISTER_CON events.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWsGroupRegisterCon
|
|
(
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
POM_EVENT_DATA32 pEvent32 = (POM_EVENT_DATA32) ¶m2;
|
|
BOOL processed;
|
|
|
|
DebugEntry(wbOnWsGroupRegisterCon);
|
|
|
|
//
|
|
// Check that this is the event we are expecting
|
|
//
|
|
if (pEvent32->correlator != m_wsgroupCorrelator)
|
|
{
|
|
//
|
|
// We are not expecting this event, this means that it must be for a
|
|
// workset group which we wanted to deregister from (but had not yet
|
|
// received confirmation). So deregister immediately.
|
|
//
|
|
|
|
//
|
|
// Check that the return code for the registration is OK
|
|
//
|
|
if (pEvent32->result == 0)
|
|
{
|
|
OM_WSGroupDeregister(m_pomClient, &(pEvent16->hWSGroup));
|
|
}
|
|
|
|
processed = FALSE;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Show that we have processed the event
|
|
//
|
|
processed = TRUE;
|
|
|
|
//
|
|
// Test for the correct state
|
|
//
|
|
if (m_subState != STATE_REG_PENDING_WSGROUP_CON)
|
|
{
|
|
//
|
|
// We are not in the correct state for this event - this is an internal
|
|
// error.
|
|
//
|
|
ERROR_OUT(("Not in correct state for WSGroupRegisterCon"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Check that the return code for the registration is OK
|
|
//
|
|
if (pEvent32->result != 0)
|
|
{
|
|
//
|
|
// Registration with the workset group failed - tidy up
|
|
//
|
|
wbError();
|
|
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Registration with the workset group succeeded
|
|
//
|
|
m_hWSGroup = pEvent16->hWSGroup;
|
|
|
|
//
|
|
// Get the clients network ID, used in graphic objects to determine where
|
|
// they are loaded.
|
|
//
|
|
if (!wbGetNetUserID())
|
|
{
|
|
//
|
|
// Tidy up (and post an error event to the client)
|
|
//
|
|
ERROR_OUT(("Failed to get user ID"));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Start opening the worksets. We open them one at a time and wait for
|
|
// the response to avoid flooding the message queue.
|
|
// The user information workset is given high priority. This allows
|
|
// remote pointer movements to travel quickly.
|
|
//
|
|
if (OM_WorksetOpenPReq(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
NET_HIGH_PRIORITY,
|
|
TRUE,
|
|
&(m_worksetOpenCorrelator)) != 0)
|
|
{
|
|
ERROR_OUT(("User Information Workset Open Failed"));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Move to the next state
|
|
//
|
|
m_subState = STATE_REG_PENDING_USER_WORKSET;
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnWsGroupRegisterCon, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWorksetOpenCon
|
|
//
|
|
// Purpose: Routine processing OM_WORKSET_OPEN_CON events.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWorksetOpenCon
|
|
(
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
POM_EVENT_DATA32 pEvent32 = (POM_EVENT_DATA32) ¶m2;
|
|
BOOL processed = FALSE;
|
|
OM_WORKSET_ID eventWorksetID;
|
|
|
|
DebugEntry(wbOnWorksetOpenCon);
|
|
|
|
//
|
|
// Process according to the workset ID
|
|
//
|
|
eventWorksetID = pEvent16->worksetID;
|
|
|
|
//
|
|
// If the event is for a page workset
|
|
//
|
|
if (eventWorksetID >= FIRST_PAGE_WORKSET)
|
|
{
|
|
//
|
|
// We are opening a page workset
|
|
//
|
|
processed = wbOnPageWorksetOpenCon(param1, param2);
|
|
if (!processed)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We are done if this is a page workset other than the 1st page workset
|
|
//
|
|
if (eventWorksetID > FIRST_PAGE_WORKSET)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Now check if it is one of the control worksets (the first page workset
|
|
// is both a control workset and a page workset).
|
|
//
|
|
if (eventWorksetID != FIRST_PAGE_WORKSET)
|
|
{
|
|
//
|
|
// Check the message correlator
|
|
//
|
|
if (pEvent32->correlator != m_worksetOpenCorrelator)
|
|
{
|
|
TRACE_OUT(("Correlators do not match - quitting"));
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We are opening a control workset - process the event
|
|
//
|
|
wbOnControlWorksetOpenCon(param1, param2);
|
|
processed = TRUE;
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnWorksetOpenCon, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnControlWorksetOpenCon
|
|
//
|
|
// Purpose: Routine processing OM_WORKSET_OPEN_CON events for control
|
|
// worksets.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnControlWorksetOpenCon
|
|
(
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
POM_EVENT_DATA32 pEvent32 = (POM_EVENT_DATA32) ¶m2;
|
|
UINT rc;
|
|
OM_WORKSET_ID eventId;
|
|
|
|
DebugEntry(wbOnControlWorksetOpenCon);
|
|
|
|
//
|
|
// Check the return code in the open
|
|
//
|
|
if (pEvent32->result != 0)
|
|
{
|
|
ERROR_OUT(("Error reported on workset open = %d", pEvent32->result));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// If we are in registration, we are opening the required worksets -
|
|
// continue the process.
|
|
//
|
|
if (m_state > STATE_REGISTERING)
|
|
{
|
|
ERROR_OUT(("Control workset open con after registration"));
|
|
}
|
|
|
|
//
|
|
// Set up for opening the next workset
|
|
//
|
|
eventId = pEvent16->worksetID;
|
|
switch(eventId)
|
|
{
|
|
case USER_INFORMATION_WORKSET:
|
|
//
|
|
// The user information workset is given high priority. This allows
|
|
// remote pointer movements to travel quickly.
|
|
//
|
|
TRACE_OUT(("Opening Page Control workset"));
|
|
rc = OM_WorksetOpenPReq(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
NET_HIGH_PRIORITY,
|
|
FALSE,
|
|
&(m_worksetOpenCorrelator));
|
|
|
|
m_subState = STATE_REG_PENDING_WORKSET_OPEN;
|
|
break;
|
|
|
|
case PAGE_CONTROL_WORKSET:
|
|
//
|
|
// The sync control workset is given high priority to allow sync
|
|
// updates to travel quickly.
|
|
//
|
|
TRACE_OUT(("Opening Sync Control workset"));
|
|
rc = OM_WorksetOpenPReq(m_pomClient,
|
|
m_hWSGroup,
|
|
SYNC_CONTROL_WORKSET,
|
|
NET_HIGH_PRIORITY,
|
|
FALSE,
|
|
&(m_worksetOpenCorrelator));
|
|
break;
|
|
|
|
case SYNC_CONTROL_WORKSET:
|
|
//
|
|
// Open the first of the page worksets - we must do this to allow us
|
|
// to use it as the only page available if we are the first person in
|
|
// the call.
|
|
//
|
|
TRACE_OUT(("Opening first page workset"));
|
|
rc = wbPageWorksetOpen((WB_PAGE_HANDLE)FIRST_PAGE_WORKSET,
|
|
OPEN_LOCAL);
|
|
break;
|
|
|
|
case FIRST_PAGE_WORKSET:
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad workset ID"));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Check whether we have just opened another workset
|
|
//
|
|
if (eventId != FIRST_PAGE_WORKSET)
|
|
{
|
|
//
|
|
// Test the return code from the open
|
|
//
|
|
if (rc != 0)
|
|
{
|
|
ERROR_OUT(("Workset open failed = %d", rc));
|
|
wbError();
|
|
}
|
|
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We have now opened all the control worksets. We now add the required
|
|
// control objects.
|
|
//
|
|
rc = wbAddLocalUserObject();
|
|
if (rc != 0)
|
|
{
|
|
//
|
|
// Stop the join call process, tidy up and send an error message to the
|
|
// client.
|
|
//
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
m_subState = STATE_REG_USER_OBJECT_ADDED;
|
|
TRACE_OUT(("Moved to substate STATE_REG_USER_OBJECT_ADDED"));
|
|
|
|
//
|
|
// Check whether the Page Control objects are available yet (they could
|
|
// have been added by another user in the call).
|
|
//
|
|
TRACE_OUT(("%x PAGE WS object, %x SYNC WS object",
|
|
m_pObjPageControl,
|
|
m_pObjSyncControl));
|
|
if ( (m_pObjPageControl == 0) &&
|
|
(m_pObjSyncControl == 0))
|
|
{
|
|
TRACE_OUT(("No control objects - WE MIGHT BE FIRST IN CALL - get lock"));
|
|
|
|
//
|
|
// We may be the first user to register - request the lock on the Page
|
|
// Control Workset.
|
|
//
|
|
rc = wbLock(WB_LOCK_TYPE_PAGE_ORDER);
|
|
if (rc != 0)
|
|
{
|
|
ERROR_OUT(("Error from wbLock = %d", rc));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Set the new registration state
|
|
//
|
|
m_subState = STATE_REG_PENDING_LOCK;
|
|
TRACE_OUT(("Moved to substate STATE_REG_PENDING_LOCK"));
|
|
DC_QUIT;
|
|
}
|
|
else
|
|
{
|
|
if (m_pObjSyncControl == 0)
|
|
{
|
|
TRACE_OUT(("Waiting for sync control"));
|
|
m_subState = STATE_REG_PENDING_SYNC_CONTROL;
|
|
DC_QUIT;
|
|
}
|
|
|
|
if (m_pObjPageControl == 0)
|
|
{
|
|
TRACE_OUT(("Waiting for page control"));
|
|
m_subState = STATE_REG_PENDING_PAGE_CONTROL;
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Complete registration
|
|
//
|
|
TRACE_OUT(("Page Control and Sync Control objects both there."));
|
|
TRACE_OUT(("Registration can be completed"));
|
|
|
|
wbOnControlWorksetsReady();
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnControlWorksetOpenCon);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageWorksetOpen
|
|
//
|
|
// Purpose: Open a page workset
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbPageWorksetOpen
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
UINT localOrExternal
|
|
)
|
|
{
|
|
UINT result;
|
|
PWB_PAGE_STATE pPageState;
|
|
|
|
DebugEntry(wbPageWorksetOpen);
|
|
|
|
//
|
|
// Get the page state
|
|
//
|
|
pPageState = GetPageState(hPage);
|
|
ASSERT((pPageState->state == PAGE_NOT_IN_USE));
|
|
ASSERT((pPageState->subState == PAGE_STATE_EMPTY));
|
|
|
|
//
|
|
// Open the workset. We allow ObMan to choose the priority, this means
|
|
// that ObMan uses a variable priority scheme allowing small objects to
|
|
// overtake large ones.
|
|
//
|
|
result = OM_WorksetOpenPReq(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
OM_OBMAN_CHOOSES_PRIORITY,
|
|
FALSE,
|
|
&(pPageState->worksetOpenCorrelator));
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("WorksetOpen failed = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Update the page state
|
|
//
|
|
if (localOrExternal == OPEN_LOCAL)
|
|
{
|
|
pPageState->subState = PAGE_STATE_LOCAL_OPEN_CONFIRM;
|
|
TRACE_OUT(("Moved page %d state to PAGE_STATE_PENDING_OPEN_CONFIRM",
|
|
(UINT) hPage));
|
|
}
|
|
else
|
|
{
|
|
pPageState->subState = PAGE_STATE_EXTERNAL_OPEN_CONFIRM;
|
|
TRACE_OUT(("Moved page %d state to PAGE_STATE_PENDING_OPEN_CONFIRM",
|
|
(UINT) hPage));
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbPageWorksetOpen, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnPageWorksetOpenCon
|
|
//
|
|
// Purpose: Routine processing OM_WORKSET_OPEN_CON events for page worksets
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnPageWorksetOpenCon
|
|
(
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
POM_EVENT_DATA32 pEvent32 = (POM_EVENT_DATA32) ¶m2;
|
|
BOOL processed = FALSE;
|
|
OM_WORKSET_ID eventId;
|
|
PWB_PAGE_STATE pPageState;
|
|
WB_PAGE_HANDLE hPage;
|
|
UINT oldState;
|
|
|
|
DebugEntry(wbOnPageWorksetOpenCon);
|
|
|
|
//
|
|
// Get the page state pointer
|
|
//
|
|
eventId = pEvent16->worksetID;
|
|
hPage = (WB_PAGE_HANDLE)eventId;
|
|
pPageState = GetPageState(hPage);
|
|
|
|
//
|
|
// Check the message correlator
|
|
//
|
|
if (pEvent32->correlator != pPageState->worksetOpenCorrelator)
|
|
{
|
|
TRACE_OUT(("Correlators do not match - quitting"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Show that we have processed this event
|
|
//
|
|
processed = TRUE;
|
|
|
|
//
|
|
// Check the return code in the open
|
|
//
|
|
if (pEvent32->result != 0)
|
|
{
|
|
ERROR_OUT(("Error reported on page workset open = %d",
|
|
pEvent32->result));
|
|
|
|
pPageState->subState = PAGE_STATE_EMPTY;
|
|
TRACE_OUT(("Moved page %d substate to PAGE_STATE_EMPTY",
|
|
(UINT)hPage));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Update the page state to indicate that the page is now ready for use
|
|
//
|
|
oldState = pPageState->subState;
|
|
pPageState->subState = PAGE_STATE_READY;
|
|
TRACE_OUT(("Moved page %d to substate to PAGE_STATE_READY",
|
|
(UINT)hPage));
|
|
|
|
switch (oldState)
|
|
{
|
|
case PAGE_STATE_LOCAL_OPEN_CONFIRM:
|
|
//
|
|
// This workset was opened locally, therefore it is being opened as
|
|
// part of the workset cache. Nothing more to do.
|
|
//
|
|
break;
|
|
|
|
case PAGE_STATE_EXTERNAL_OPEN_CONFIRM:
|
|
//
|
|
// This workset was opened as a result of external updates to the
|
|
// Page Control object. We therefore need to add the page to the
|
|
// page list now that the workset is open. We no longer know where
|
|
// the page is to be added - so call the main Page Control update
|
|
// routine again to get all the information.
|
|
//
|
|
wbProcessPageControlChanges();
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad page state %d", pPageState->subState));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Increment the number of pages in ready state. This count is never
|
|
// decremented - once a workset is open it stays open.
|
|
//
|
|
m_countReadyPages += 1;
|
|
|
|
//
|
|
// If we are in registration and are waiting for the cache of ready
|
|
// pages, we must complete registration now.
|
|
//
|
|
if ( (m_state == STATE_REGISTERING) &&
|
|
(m_subState == STATE_REG_PENDING_READY_PAGES) )
|
|
{
|
|
//
|
|
// If there are enough pages in the cache
|
|
//
|
|
if (wbCheckReadyPages())
|
|
{
|
|
//
|
|
// We have enough ready pages - complete registration
|
|
//
|
|
wbCompleteRegistration();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// There are not yet enough pages in the cache. CheckReadyPages will
|
|
// have made a new workset open request, so we will receive another
|
|
// workset open confirm soon.
|
|
//
|
|
DC_QUIT;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnPageWorksetOpenCon, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWorksetLockCon
|
|
//
|
|
// Purpose: Routine processing OM_WORKSET_LOCK_CON events.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWorksetLockCon
|
|
(
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
POM_EVENT_DATA32 pEvent32 = (POM_EVENT_DATA32) ¶m2;
|
|
BOOL processed = FALSE;
|
|
UINT rc;
|
|
|
|
DebugEntry(wbOnWorksetLockCon);
|
|
|
|
//
|
|
// Check the message correlator
|
|
//
|
|
if (pEvent32->correlator != m_lockCorrelator)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// The message is for us - set the result to "processed"
|
|
//
|
|
processed = TRUE;
|
|
|
|
//
|
|
// Check that the event is for the Page Control Workset (this is the
|
|
// only expected workset).
|
|
//
|
|
if (pEvent16->worksetID != PAGE_CONTROL_WORKSET)
|
|
{
|
|
ERROR_OUT(("Unexpected workset in LockCon = %d",
|
|
pEvent16->worksetID));
|
|
}
|
|
|
|
//
|
|
// Process according to the current lock state
|
|
//
|
|
switch (m_lockState)
|
|
{
|
|
//
|
|
// We were waiting for lock confirmation
|
|
//
|
|
case LOCK_STATE_PENDING_LOCK:
|
|
//
|
|
// Check the return code in the event
|
|
//
|
|
if (pEvent32->result != 0)
|
|
{
|
|
TRACE_OUT(("Posting WBP_EVENT_LOCK_FAILED, rc %d",
|
|
pEvent32->result));
|
|
WBP_PostEvent(0, // No delay
|
|
WBP_EVENT_LOCK_FAILED, // Lock request failed
|
|
0, // No parameters
|
|
0);
|
|
|
|
//
|
|
// The lock failed - update the state. This means that
|
|
// another user has acquired the lock. We expect to get a
|
|
// lock object add indication soon.
|
|
//
|
|
m_lockState = LOCK_STATE_EMPTY;
|
|
TRACE_OUT(("Lock request failed - lock state is now EMPTY"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Write the lock details to the Page Control Workset
|
|
//
|
|
rc = wbWriteLock();
|
|
if (rc != 0)
|
|
{
|
|
ERROR_OUT(("Unable to write lock details = %d", rc));
|
|
|
|
//
|
|
// Tidy up by unlocking the Page Control Workset
|
|
//
|
|
OM_WorksetUnlock(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET);
|
|
|
|
//
|
|
// Tell the client of the failure
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_LOCK_FAILED"));
|
|
WBP_PostEvent(0, // No delay
|
|
WBP_EVENT_LOCK_FAILED, // Lock request failed
|
|
0, // No parameters
|
|
0);
|
|
|
|
//
|
|
// Update the lock state
|
|
//
|
|
m_lockState = LOCK_STATE_EMPTY;
|
|
TRACE_OUT(("Moved lock state to LOCK_STATE_EMPTY"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Once we get here the write of the lock object above will
|
|
// trigger an object add event that completes the lock
|
|
// processing.
|
|
//
|
|
m_lockState = LOCK_STATE_PENDING_ADD;
|
|
TRACE_OUT(("Moved lock state to LOCK_STATE_PENDING_ADD"));
|
|
break;
|
|
|
|
//
|
|
// The application has cancelled the lock request before it has had
|
|
// time to complete - tidy up.
|
|
//
|
|
case LOCK_STATE_CANCEL_LOCK:
|
|
TRACE_OUT(("LOCK_STATE_CANCEL_LOCK"));
|
|
|
|
//
|
|
// If the request failed, just reset the state.
|
|
//
|
|
//
|
|
// The lock was cancelled - unlock the workset if necessary,
|
|
// and notify the front-end of the unlock.
|
|
//
|
|
if (pEvent32->result == 0)
|
|
{
|
|
//
|
|
// We have locked the workset successfully, but in the
|
|
// meantime the front-end has cancelled the lock, so unlock
|
|
// the workset now.
|
|
//
|
|
TRACE_OUT((
|
|
"Lock cancelled before workset locked, so unlock now"));
|
|
OM_WorksetUnlock(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET);
|
|
}
|
|
m_lockState = LOCK_STATE_EMPTY;
|
|
|
|
//
|
|
// Tell the app that we have cancelled the lock.
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_UNLOCKED"));
|
|
WBP_PostEvent(0,
|
|
WBP_EVENT_UNLOCKED,
|
|
0,
|
|
0);
|
|
break;
|
|
|
|
//
|
|
// Another has got in before us
|
|
//
|
|
case LOCK_STATE_LOCKED_OUT:
|
|
|
|
//
|
|
// We have received a lock confirmation and should have been
|
|
// expecting the lock. But we are locked out. This means that
|
|
// another user has got in just before us, acquired the lock
|
|
// and added the lock object. We have processed the add and
|
|
// changed the lock state accordingly. This lock confirmation
|
|
// will therefore normally be a failure. If by some fluke it
|
|
// isn't, then we treat it as a failure for safety.
|
|
//
|
|
if (pEvent32->result == 0)
|
|
{
|
|
ERROR_OUT(("Lock violation"));
|
|
|
|
//
|
|
// Tidy up by unlocking the Page Control Workset - leave
|
|
// the state as LOCKED_OUT; we'll clear it on receipt of
|
|
// the unlock (either local, or from the locking user).
|
|
//
|
|
OM_WorksetUnlock(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad lock state %d", m_lockState));
|
|
break;
|
|
} // Switch on lock state
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnWorksetLockCon, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWorksetUnlockInd
|
|
//
|
|
// Purpose: Routine processing OM_WORKSET_UNLOCK_IND events.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWorksetUnlockInd
|
|
(
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
POM_EVENT_DATA32 pEvent32 = (POM_EVENT_DATA32) ¶m2;
|
|
BOOL processed = TRUE;
|
|
|
|
DebugEntry(wbOnWorksetUnlockInd);
|
|
|
|
//
|
|
// We are only interested if the workset id is that of the Page Control
|
|
// Workset.
|
|
//
|
|
if (pEvent16->worksetID != PAGE_CONTROL_WORKSET)
|
|
{
|
|
TRACE_OUT(("Unexpected workset in unlock = %d", pEvent16->worksetID));
|
|
DC_QUIT;
|
|
}
|
|
|
|
switch (m_lockState)
|
|
{
|
|
//
|
|
// We had the lock and are waiting to unlock or another user had
|
|
// the lock and has now removed it.
|
|
//
|
|
case LOCK_STATE_LOCKED_OUT:
|
|
//
|
|
// We received the unlock of the workset before the removal of
|
|
// the lock object; we just ignore this, since the deletion of
|
|
// the lock object is our indication that the wb lock is removed.
|
|
//
|
|
TRACE_OUT(("Unlock of page control workset while locked out"));
|
|
break;
|
|
|
|
//
|
|
// We are unlocking after an error acquiring the lock or after a
|
|
// user has cancelled alock before we had time to complete it.
|
|
//
|
|
case LOCK_STATE_CANCEL_LOCK:
|
|
|
|
//
|
|
// An error occurred in getting the lock - the client has
|
|
// already been informed so we just record the state change.
|
|
//
|
|
m_lockState = LOCK_STATE_EMPTY;
|
|
TRACE_OUT(("Moved lock state to LOCK_STATE_EMPTY"));
|
|
break;
|
|
|
|
//
|
|
// We are waiting for the lock - but have got an unlock instead.
|
|
// This could be from another user, or from previous aborted
|
|
// attempts by us to get the lock. We ignore the event and wait
|
|
// for our lock confirmation.
|
|
//
|
|
case LOCK_STATE_PENDING_LOCK:
|
|
TRACE_OUT((
|
|
"Got unlock indication while waiting for lock confirmation"));
|
|
break;
|
|
|
|
//
|
|
// We can get an unlock indication without ever having seen the
|
|
// lock object if the lock object was never added (failure at
|
|
// another user) or if ObMan has spoiled the add and delete.
|
|
//
|
|
case LOCK_STATE_EMPTY:
|
|
TRACE_OUT(("Unlock received in LOCK_STATE_EMPTY - ignoring"));
|
|
break;
|
|
|
|
//
|
|
// Unlock not expected in this state
|
|
//
|
|
default:
|
|
ERROR_OUT(("Bad lock state %d", m_lockState));
|
|
break;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnWorksetUnlockInd, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnControlWorksetsReady
|
|
//
|
|
// Purpose: The control worksets have been opened and set up. Continue the
|
|
// registration process by updating the internal page order to
|
|
// ensure that in matches the external order.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnControlWorksetsReady(void)
|
|
{
|
|
DebugEntry(wbOnControlWorksetsReady);
|
|
|
|
//
|
|
// Read the Page Control object and compare its content to the internal
|
|
// Page Order.
|
|
//
|
|
wbProcessPageControlChanges();
|
|
|
|
//
|
|
// Update the state to show that we are waiting for the Page Order
|
|
// Updated event indicating that the internal page order now matches
|
|
// the external order.
|
|
//
|
|
m_subState = STATE_REG_PENDING_PAGE_ORDER;
|
|
TRACE_OUT(("Moved sub state to STATE_REG_PENDING_PAGE_ORDER"));
|
|
|
|
DebugExitVOID(wbOnControlWorksetsReady);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbCompleteRegistration
|
|
//
|
|
// Purpose: Perform the final steps in registering a client. These are:
|
|
// post a WB_EVENT_REGISTERED event to the client; check if
|
|
// another user has a lock on the contents or page order, if so,
|
|
// post a WB_EVENT_CONTENTS_LOCKED or WB_EVENT_PAGE_ORDER_LOCKED
|
|
// to the client.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbCompleteRegistration(void)
|
|
{
|
|
DebugEntry(wbCompleteRegistration);
|
|
|
|
//
|
|
// Inform the client that we are fully registered
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_REGISTER_OK"));
|
|
WBP_PostEvent(0, // No delay
|
|
WBP_EVENT_JOIN_CALL_OK, // Fully registered
|
|
0, // No parameters
|
|
0);
|
|
|
|
//
|
|
// Notify the client of the lock status
|
|
//
|
|
wbSendLockNotification();
|
|
|
|
//
|
|
// Record that we are now fully registered
|
|
//
|
|
m_state = STATE_IDLE;
|
|
m_subState = STATE_EMPTY;
|
|
TRACE_OUT(("Moved to state STATE_IDLE"));
|
|
|
|
DebugExitVOID(wbCompleteRegistration);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbLeaveCall
|
|
//
|
|
// Purpose: Remove a client from a call/workset group
|
|
//
|
|
// Returns: None
|
|
//
|
|
//
|
|
void WbClient::wbLeaveCall(void)
|
|
{
|
|
DebugEntry(wbLeaveCall);
|
|
|
|
//
|
|
// If we have not got far enough to have entered a call - leave now
|
|
// (there is nothing to tidy up).
|
|
//
|
|
if (m_state < STATE_REGISTERING)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// If we have the lock - delete the lock object (the workset will be
|
|
// unlocked by ObMan when we deregister).
|
|
//
|
|
if (m_lockState == LOCK_STATE_GOT_LOCK)
|
|
{
|
|
TRACE_OUT(("Still got lock - deleting lock object, handle %d",
|
|
m_pObjLock));
|
|
if (OM_ObjectDelete(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
m_pObjLock) != 0)
|
|
{
|
|
ERROR_OUT(("Error deleting lock object"));
|
|
}
|
|
|
|
//
|
|
// If all is well at this point the unlock process will be
|
|
// completed when the object delete ind is received.
|
|
//
|
|
m_lockState = LOCK_STATE_PENDING_DELETE;
|
|
TRACE_OUT(("Moved to state LOCK_STATE_PENDING_DELETE"));
|
|
}
|
|
|
|
//
|
|
// Fix up the sub state to indicate that all registration actions have
|
|
// been completed (to ensure that they are all undone).
|
|
//
|
|
if (m_state > STATE_REGISTERING)
|
|
{
|
|
m_subState = STATE_REG_END;
|
|
TRACE_OUT(("Moved to substate STATE_REG_END"));
|
|
}
|
|
|
|
//
|
|
// Delete the user object representing the local user from the User
|
|
// Information Workset (if it is present). Note that we are about to
|
|
// deregister from ObMan - this acts as automatic confirmation of the
|
|
// delete request so we do not need to wait for the
|
|
// OM_OBJECT_DELETE_IND event.
|
|
//
|
|
if (m_subState >= STATE_REG_USER_OBJECT_ADDED)
|
|
{
|
|
TRACE_OUT(("Deleting user object"));
|
|
if (OM_ObjectDelete(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
m_pObjLocal) != 0)
|
|
{
|
|
//
|
|
// Trace the error but do not quit - we expect everything to be
|
|
// tidied up when we deregister from ObMan.
|
|
//
|
|
ERROR_OUT(("Error deleting local user object"));
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we have already registered with the Workset Group, deregister
|
|
// now. we have not yet received the confirmation, and get it later we
|
|
// will deregister immediately.
|
|
//
|
|
if (m_subState > STATE_REG_PENDING_WSGROUP_CON)
|
|
{
|
|
OM_WSGroupDeregister(m_pomClient, &(m_hWSGroup));
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We have not yet received the Workset Group Registration
|
|
// confirmation, change the value in the correlator field so that
|
|
// we recognize the fact that we have cancelled registration later.
|
|
//
|
|
m_wsgroupCorrelator--;
|
|
}
|
|
|
|
//
|
|
// Reset the handles of objects added during registration
|
|
//
|
|
TRACE_OUT(("Resetting client data"));
|
|
wbClientReset();
|
|
|
|
//
|
|
// Set the client state to the appropriate value
|
|
//
|
|
m_state = STATE_STARTED;
|
|
m_subState = STATE_STARTED_START;
|
|
TRACE_OUT(("Moved state to STATE_STARTED"));
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbLeaveCall);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbContentsDelete
|
|
//
|
|
// Purpose: Remove all the current graphics and pages, leaving a single
|
|
// blank page.
|
|
//
|
|
// Returns: None
|
|
//
|
|
//
|
|
void WbClient::wbContentsDelete
|
|
(
|
|
UINT changedFlagAction
|
|
)
|
|
{
|
|
PWB_PAGE_ORDER pPageOrder = &(m_pageOrder);
|
|
PWB_PAGE_STATE pPageState;
|
|
UINT index;
|
|
|
|
DebugEntry(wbContentsDelete);
|
|
|
|
//
|
|
// Just clear the first page in the list
|
|
//
|
|
wbPageClear(pPageOrder->pages[0], changedFlagAction);
|
|
|
|
//
|
|
// If there is only one page left in the list - we're done.
|
|
//
|
|
if (pPageOrder->countPages == 1)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// There is more than one page
|
|
//
|
|
|
|
//
|
|
// Mark all of the active pages (except the first) as "delete pending"
|
|
//
|
|
for (index = 1; index < pPageOrder->countPages; index++)
|
|
{
|
|
pPageState = GetPageState((pPageOrder->pages)[index]);
|
|
|
|
if ((pPageState->state == PAGE_IN_USE) &&
|
|
(pPageState->subState == PAGE_STATE_EMPTY))
|
|
{
|
|
pPageState->subState = PAGE_STATE_LOCAL_DELETE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Write the page control information. The replace event generated by
|
|
// the write will kick off the actual deletion of the pages marked.
|
|
//
|
|
wbWritePageControl(FALSE);
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbContentsDelete);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbStartContentsLoad
|
|
//
|
|
// Purpose: Start the loading of a file (after the contents have been
|
|
// cleared).
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbStartContentsLoad(void)
|
|
{
|
|
DebugEntry(wbStartContentsLoad);
|
|
|
|
//
|
|
// Specify the first (and only) page handle as the page to load to
|
|
//
|
|
wbPageHandleFromNumber(1, &m_loadPageHandle);
|
|
|
|
//
|
|
// Update the load state to show that we are now loading
|
|
//
|
|
m_loadState = LOAD_STATE_LOADING;
|
|
TRACE_OUT(("Moved load state to LOAD_STATE_LOADING"));
|
|
|
|
//
|
|
// Load the first page - subsequent pages are chained from this first one
|
|
//
|
|
wbPageLoad();
|
|
|
|
DebugExitVOID(wbStartContentsLoad);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbLock
|
|
//
|
|
// Purpose: Request the lock for the Whiteboard contents or the page order
|
|
// generating one of the following events:
|
|
//
|
|
// WB_EVENT_CONTENTS_LOCKED
|
|
// WB_EVENT_CONTENTS_LOCK_FAILED.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbLock(WB_LOCK_TYPE lockType)
|
|
{
|
|
UINT result = 0;
|
|
OM_CORRELATOR correlator;
|
|
|
|
DebugEntry(wbLock);
|
|
|
|
//
|
|
// If we already have the lock we can merely change its status
|
|
//
|
|
if (m_lockState == LOCK_STATE_GOT_LOCK)
|
|
{
|
|
TRACE_OUT(("Already got the lock"));
|
|
|
|
m_lockRequestType = lockType;
|
|
result = wbWriteLock();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Request the lock for the Page Control Workset
|
|
//
|
|
result = OM_WorksetLockReq(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
&correlator);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_WorksetLockReq failed, result = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
TRACE_OUT(("Requested lock for the Page Control Workset"));
|
|
|
|
//
|
|
// Save the lock details
|
|
//
|
|
|
|
m_lockState = LOCK_STATE_PENDING_LOCK;
|
|
m_lockCorrelator = correlator;
|
|
m_lockRequestType = lockType;
|
|
|
|
TRACE_OUT(("Moved lock state to LOCK_STATE_PENDING_LOCK"));
|
|
TRACE_OUT(("Lock type requested = %d", lockType));
|
|
|
|
//
|
|
// We return now, further processing is done when the OM_WORKSET_LOCK_CON
|
|
// event is received.
|
|
//
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbLock, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbUnlock
|
|
//
|
|
// Purpose: Unlock the Contents or Page Order.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbUnlock(void)
|
|
{
|
|
DebugEntry(wbUnlock);
|
|
|
|
//
|
|
// Check that we have the lock
|
|
//
|
|
if (m_lockState != LOCK_STATE_GOT_LOCK)
|
|
{
|
|
ERROR_OUT(("Local person doesn't have lock"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Delete the lock object
|
|
//
|
|
TRACE_OUT(("Delete Lock handle %x", m_pObjLock));
|
|
if (OM_ObjectDelete(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
m_pObjLock) != 0)
|
|
{
|
|
ERROR_OUT(("Could not delete lock object"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// If all is well at this point the unlock process will be completed when
|
|
// the object delete ind is received.
|
|
//
|
|
m_lockState = LOCK_STATE_PENDING_DELETE;
|
|
TRACE_OUT(("Moved to state LOCK_STATE_PENDING_DELETE"));
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbUnlock);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbObjectSave
|
|
//
|
|
// Purpose: Save a structure to file
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbObjectSave
|
|
(
|
|
HANDLE hFile,
|
|
LPBYTE pData,
|
|
UINT length
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
ULONG cbSizeWritten;
|
|
|
|
DebugEntry(wbObjectSave);
|
|
|
|
//
|
|
// Save the length
|
|
//
|
|
if (! WriteFile(hFile, (void *) &length, sizeof(length), &cbSizeWritten, NULL))
|
|
{
|
|
result = WB_RC_WRITE_FAILED;
|
|
ERROR_OUT(("Error writing length to file, win32 err=%d", GetLastError()));
|
|
DC_QUIT;
|
|
}
|
|
ASSERT(cbSizeWritten == sizeof(length));
|
|
|
|
//
|
|
// Save the object data
|
|
//
|
|
if (! WriteFile(hFile, pData, length, &cbSizeWritten, NULL))
|
|
{
|
|
result = WB_RC_WRITE_FAILED;
|
|
ERROR_OUT(("Error writing data to file, win32 err=%d", GetLastError()));
|
|
DC_QUIT;
|
|
}
|
|
ASSERT(cbSizeWritten == length);
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbObjectSave, result);
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageSave
|
|
//
|
|
// Purpose: Save the contents of a single page to file.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbPageSave
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
HANDLE hFile
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
UINT rc;
|
|
OM_WORKSET_ID worksetID = (OM_WORKSET_ID)hPage;
|
|
POM_OBJECT pObj;
|
|
POM_OBJECTDATA pData;
|
|
WB_END_OF_PAGE endOfPage;
|
|
|
|
DebugEntry(wbPageSave);
|
|
|
|
//
|
|
// Get the first object
|
|
//
|
|
result = OM_ObjectH(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
0,
|
|
&pObj,
|
|
FIRST);
|
|
if (result == OM_RC_NO_SUCH_OBJECT)
|
|
{
|
|
// This can happen on an empty page, not an error
|
|
TRACE_OUT(("No objects left, quitting with good return"));
|
|
result = 0;
|
|
DC_QUIT;
|
|
}
|
|
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Error getting first object in page"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Loop through the objects
|
|
//
|
|
for( ; ; )
|
|
{
|
|
//
|
|
// Get a pointer to the object
|
|
//
|
|
result = OM_ObjectRead(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
pObj,
|
|
&pData);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Error reading object = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Save the object data
|
|
//
|
|
rc = wbObjectSave(hFile,
|
|
(LPBYTE) pData->data,
|
|
pData->length);
|
|
|
|
//
|
|
// The return code is tested after we have released the object because
|
|
// we must always do the release.
|
|
//
|
|
|
|
//
|
|
// Release the object
|
|
//
|
|
OM_ObjectRelease(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
pObj,
|
|
&pData);
|
|
|
|
//
|
|
// Now test the write return code
|
|
//
|
|
if (rc != 0)
|
|
{
|
|
result = rc;
|
|
ERROR_OUT(("Error writing object data = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Get the next object
|
|
//
|
|
result = OM_ObjectH(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
pObj,
|
|
&pObj,
|
|
AFTER);
|
|
if (result == OM_RC_NO_SUCH_OBJECT)
|
|
{
|
|
TRACE_OUT(("No objects left, quitting with good return"));
|
|
result = 0;
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
|
|
//
|
|
// If we have successfully written the page contents, we write an end-of-
|
|
// page marker to the file.
|
|
//
|
|
if (result == 0)
|
|
{
|
|
//
|
|
// Set the end of page object details
|
|
//
|
|
ZeroMemory(&endOfPage, sizeof(endOfPage));
|
|
|
|
endOfPage.length = sizeof(endOfPage);
|
|
endOfPage.type = TYPE_END_OF_PAGE;
|
|
|
|
//
|
|
// Write the end-of-page object
|
|
//
|
|
result = wbObjectSave(hFile,
|
|
(LPBYTE) &endOfPage,
|
|
sizeof(endOfPage));
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Error writing end-of-page = %d", result));
|
|
}
|
|
}
|
|
|
|
DebugExitDWORD(wbPageSave, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageLoad
|
|
//
|
|
// Purpose: Load the contents of a single page from file.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbPageLoad(void)
|
|
{
|
|
UINT result = 0;
|
|
UINT type;
|
|
POM_OBJECT pObj;
|
|
POM_OBJECTDATA pData = NULL;
|
|
PWB_GRAPHIC pGraphic = NULL;
|
|
WB_PAGE_HANDLE hPage = m_loadPageHandle;
|
|
WB_PAGE_HANDLE hNewPage;
|
|
UINT postDelay = 0;
|
|
|
|
DebugEntry(wbPageLoad);
|
|
TRACE_OUT(("Entered wbPageLoad for page %d", (UINT) hPage));
|
|
|
|
//
|
|
// Check the load state - if we're not loading, then quit (can happen if
|
|
// the load is cancelled).
|
|
//
|
|
if (m_loadState == LOAD_STATE_EMPTY)
|
|
{
|
|
TRACE_OUT(("Load has been cancelled - abandoning page load"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Check that we have a full complement of ready pages before starting
|
|
// the load.
|
|
//
|
|
if (!wbCheckReadyPages())
|
|
{
|
|
//
|
|
// There are not enough pages worksets ready to be used. We exit now
|
|
// to allow the page to be made ready before we continue. We set up a
|
|
// delay on the message that will be used to restart the process to
|
|
// allow the worksets to be opened before we get back in here.
|
|
//
|
|
postDelay = 200;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// If we are waiting to add a new page, get the handle of the page we
|
|
// expect to add next here. (We have to do this as ObMan requires that
|
|
// we allocate memory for the object in the correct workset, but we do
|
|
// not want to actually add the page here because we may not need it.)
|
|
//
|
|
if (m_loadState == LOAD_STATE_PENDING_NEW_PAGE)
|
|
{
|
|
hNewPage = wbGetReadyPageHandle();
|
|
|
|
//
|
|
// If we cannot get a ready page - we must have run out of pages (we
|
|
// have already done a check on the availability of ready pages above).
|
|
// If we cannot get a new page we continue using the old.
|
|
//
|
|
if (hNewPage != WB_PAGE_HANDLE_NULL)
|
|
{
|
|
hPage = hNewPage;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Read the next object
|
|
//
|
|
result = wbObjectLoad(m_hLoadFile,
|
|
(OM_WORKSET_ID)hPage,
|
|
&pGraphic);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Error reading object = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
pData = ObjectDataPtrFromGraphic(pGraphic);
|
|
type = pGraphic->type;
|
|
|
|
//
|
|
// Process the object according to type
|
|
//
|
|
|
|
//
|
|
// End of file marker
|
|
//
|
|
if (type == TYPE_END_OF_FILE)
|
|
{
|
|
//
|
|
// Let the Front End know that the load has completed
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_LOAD_COMPLETE"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_LOAD_COMPLETE, // Load completed
|
|
0, // No parameters
|
|
0);
|
|
|
|
//
|
|
// Leave now - the file will be closed below
|
|
//
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// It is not an end-of file object. So it must be either an end-of page
|
|
// or a graphic object. In either case we may already have flagged the
|
|
// need to add a new page.
|
|
//
|
|
|
|
//
|
|
// Add a new page (if necessary)
|
|
//
|
|
if (m_loadState == LOAD_STATE_PENDING_NEW_PAGE)
|
|
{
|
|
//
|
|
// If we could not get a new page handle above leave with an error
|
|
//
|
|
if (hPage == m_loadPageHandle)
|
|
{
|
|
ERROR_OUT(("Run out of pages for load"));
|
|
result = WB_RC_TOO_MANY_PAGES;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Add a new page after the current page. The new page handle is saved
|
|
// in the client details.
|
|
//
|
|
result = wbPageAdd(m_loadPageHandle,
|
|
PAGE_AFTER,
|
|
&(m_loadPageHandle),
|
|
DONT_RESET_CHANGED_FLAG);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Failed to add page"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Check that we got the page handle we expected
|
|
//
|
|
ASSERT((hPage == m_loadPageHandle));
|
|
|
|
//
|
|
// Show that we are no longer waiting for a new page
|
|
//
|
|
m_loadState = LOAD_STATE_LOADING;
|
|
}
|
|
|
|
//
|
|
// End of page marker
|
|
//
|
|
if (type == TYPE_END_OF_PAGE)
|
|
{
|
|
TRACE_OUT(("End of page object"));
|
|
|
|
//
|
|
// Discard the object
|
|
//
|
|
OM_ObjectDiscard(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
&pData);
|
|
pData = NULL;
|
|
|
|
//
|
|
// Set the load state to "pending new page" and leave the routine
|
|
// immediately. The process continues when we return to this routine.
|
|
//
|
|
m_loadState = LOAD_STATE_PENDING_NEW_PAGE;
|
|
|
|
//
|
|
// Exit (we post ourselves a message below to get us back into this
|
|
// routine later).
|
|
//
|
|
postDelay = 100;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// The object is a standard graphic
|
|
//
|
|
TRACE_OUT(("Graphic object"));
|
|
|
|
//
|
|
// Add the object to the page
|
|
//
|
|
result = OM_ObjectAdd(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
&pData,
|
|
sizeof(WB_GRAPHIC),
|
|
&pObj,
|
|
LAST);
|
|
if (result != 0)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Show that we have finished with the object
|
|
//
|
|
pGraphic = NULL;
|
|
pData = NULL;
|
|
|
|
DC_EXIT_POINT:
|
|
|
|
//
|
|
// If we still have the object - discard it
|
|
//
|
|
if (pData != NULL)
|
|
{
|
|
TRACE_OUT(("Discarding object"));
|
|
OM_ObjectDiscard(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage,
|
|
&pData);
|
|
}
|
|
|
|
//
|
|
// If an error occurred or we have reached the end-of-file - close the
|
|
// file.
|
|
//
|
|
if ((result != 0) || (type == TYPE_END_OF_FILE))
|
|
{
|
|
CloseHandle(m_hLoadFile);
|
|
m_hLoadFile = INVALID_HANDLE_VALUE;
|
|
|
|
//
|
|
// If the final result is an error - post an error message to ourselves
|
|
//
|
|
if (result != 0)
|
|
{
|
|
TRACE_OUT(("Posting WBP_EVENT_LOAD_FAILED"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_LOAD_FAILED, // Load the next object
|
|
0, // No parameters
|
|
0);
|
|
}
|
|
|
|
//
|
|
// Record that we are no longer in the load process
|
|
//
|
|
m_loadState = LOAD_STATE_EMPTY;
|
|
TRACE_OUT(("Moved load state to LOAD_STATE_EMPTY"));
|
|
}
|
|
|
|
//
|
|
// send a message to load the next page, unless the load has been
|
|
// cancelled
|
|
//
|
|
if (m_loadState != LOAD_STATE_EMPTY)
|
|
{
|
|
//
|
|
// We have not reached the end-of-file and there has been no error.
|
|
// Post a message to ourselves to continue the load process.
|
|
//
|
|
TRACE_OUT(("Posting WBPI_EVENT_LOAD_NEXT"));
|
|
WBP_PostEvent(postDelay, // With delay
|
|
WBPI_EVENT_LOAD_NEXT, // Load the next object
|
|
0, // No parameters
|
|
0);
|
|
}
|
|
|
|
DebugExitVOID(wbPageLoad);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbObjectLoad
|
|
//
|
|
// Purpose: Load a single object from file.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbObjectLoad
|
|
(
|
|
HANDLE hFile,
|
|
WB_PAGE_HANDLE hPage,
|
|
PPWB_GRAPHIC ppGraphic
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
OM_WORKSET_ID worksetID = (OM_WORKSET_ID)hPage;
|
|
UINT length;
|
|
ULONG cbSizeRead;
|
|
POM_OBJECTDATA pData = NULL;
|
|
PWB_GRAPHIC pGraphic = NULL;
|
|
|
|
DebugEntry(wbObjectLoad);
|
|
|
|
TRACE_OUT(("Entered wbObjectLoad for page %d", (UINT) hPage));
|
|
|
|
//
|
|
// Read the next object's length
|
|
//
|
|
if ( (! ReadFile(hFile, (void *) &length, sizeof(length), &cbSizeRead, NULL)) ||
|
|
(cbSizeRead != sizeof(length)) ||
|
|
(length > OM_MAX_OBJECT_SIZE) ||
|
|
(length == 0) )
|
|
{
|
|
//
|
|
// Make sure we return a sensible error.
|
|
//
|
|
ERROR_OUT(("reading object length, win32 err=%d, length=%d", GetLastError(), length));
|
|
result = WB_RC_BAD_FILE_FORMAT;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Allocate memory for the object
|
|
//
|
|
result = OM_ObjectAlloc(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
length,
|
|
&pData);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Error allocating object = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
pData->length = length;
|
|
pGraphic = GraphicPtrFromObjectData(pData);
|
|
|
|
//
|
|
// Read the object into memory
|
|
//
|
|
if ( (! ReadFile(hFile, (void *) pGraphic, length, &cbSizeRead, NULL)) ||
|
|
(cbSizeRead != length))
|
|
{
|
|
//
|
|
// Make sure we return a sensible error.
|
|
//
|
|
ERROR_OUT((
|
|
"Reading object from file: win32 err=%d, asked for %d got %d bytes",
|
|
GetLastError(),
|
|
length,
|
|
cbSizeRead));
|
|
result = WB_RC_BAD_FILE_FORMAT;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Validate the object type
|
|
//
|
|
switch (pGraphic->type)
|
|
{
|
|
//
|
|
// Standard type, end-of-page or end-of-file
|
|
//
|
|
case TYPE_END_OF_PAGE:
|
|
case TYPE_END_OF_FILE:
|
|
case TYPE_GRAPHIC_FREEHAND:
|
|
case TYPE_GRAPHIC_LINE:
|
|
case TYPE_GRAPHIC_RECTANGLE:
|
|
case TYPE_GRAPHIC_FILLED_RECTANGLE:
|
|
case TYPE_GRAPHIC_ELLIPSE:
|
|
case TYPE_GRAPHIC_FILLED_ELLIPSE:
|
|
case TYPE_GRAPHIC_TEXT:
|
|
case TYPE_GRAPHIC_DIB:
|
|
break;
|
|
|
|
//
|
|
// Unrecognized object type - probably wrong version
|
|
//
|
|
default:
|
|
result = WB_RC_BAD_FILE_FORMAT;
|
|
DC_QUIT;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// For graphic objects, set the flag in the object header showing that it
|
|
// was loaded from file. Add our user ID so we know where it came from.
|
|
//
|
|
if ( (pGraphic->type != TYPE_END_OF_FILE) &&
|
|
(pGraphic->type != TYPE_END_OF_PAGE))
|
|
{
|
|
pGraphic->loadedFromFile = TRUE;
|
|
pGraphic->loadingClientID = m_clientNetID;
|
|
}
|
|
|
|
*ppGraphic = pGraphic;
|
|
|
|
DC_EXIT_POINT:
|
|
|
|
//
|
|
// If an error has occurred - discard the object (if we have it)
|
|
//
|
|
if ((result != 0) && (pData != NULL))
|
|
{
|
|
OM_ObjectDiscard(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
&pData);
|
|
}
|
|
|
|
DebugExitDWORD(wbObjectLoad, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageHandleFromNumber
|
|
//
|
|
// Purpose: Return the handle of a page specified by page number
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbPageHandleFromNumber
|
|
(
|
|
UINT pageNumber,
|
|
PWB_PAGE_HANDLE phPage
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
WB_PAGE_HANDLE hPage;
|
|
PWB_PAGE_ORDER pPageOrder = &(m_pageOrder);
|
|
|
|
DebugEntry(wbPageHandleFromNumber);
|
|
|
|
//
|
|
// Validate the requested page number
|
|
//
|
|
if ((pageNumber < 1)|| (pageNumber > WB_MAX_PAGES))
|
|
{
|
|
result = WB_RC_BAD_PAGE_NUMBER;
|
|
DC_QUIT;
|
|
}
|
|
|
|
if (pageNumber > pPageOrder->countPages)
|
|
{
|
|
result = WB_RC_NO_SUCH_PAGE;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Get the page handle
|
|
//
|
|
hPage = (pPageOrder->pages)[pageNumber - 1];
|
|
|
|
//
|
|
// Check that this page is in use
|
|
//
|
|
if (GetPageState(hPage)->state != PAGE_IN_USE)
|
|
{
|
|
ERROR_OUT(("Page list is bad"));
|
|
}
|
|
|
|
//
|
|
// Return the page handle
|
|
//
|
|
*phPage = hPage;
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbPageHandleFromNumber, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageClear
|
|
//
|
|
// Purpose: Clear the specified page of all graphic objects
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbPageClear
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
UINT changedFlagAction
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
|
|
DebugEntry(wbPageClear);
|
|
|
|
//
|
|
// Show that the contents have changed, if required.
|
|
//
|
|
if (changedFlagAction == RESET_CHANGED_FLAG)
|
|
{
|
|
m_changed = TRUE;
|
|
TRACE_OUT(("Changed flag now TRUE"));
|
|
}
|
|
|
|
//
|
|
// Request that the page be cleared
|
|
//
|
|
result = OM_WorksetClear(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage);
|
|
|
|
|
|
DebugExitDWORD(wbPageClear, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageClearConfirm
|
|
//
|
|
// Purpose: Complete the clearing of a page
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbPageClearConfirm(WB_PAGE_HANDLE hPage)
|
|
{
|
|
DebugEntry(wbPageClearConfirm);
|
|
|
|
//
|
|
// Request that the page be cleared
|
|
//
|
|
OM_WorksetClearConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
(OM_WORKSET_ID)hPage);
|
|
|
|
|
|
//
|
|
// Check the load state to see whether we are waiting to load the
|
|
// contents
|
|
//
|
|
if (m_loadState == LOAD_STATE_PENDING_CLEAR)
|
|
{
|
|
//
|
|
// We are waiting to load. If there is only one page available (ie the
|
|
// one that has just been cleared) we are ready to load, otherwise we
|
|
// wait for the page deletes to happen.
|
|
//
|
|
if ((m_pageOrder).countPages == 1)
|
|
{
|
|
//
|
|
// Start the load proper
|
|
//
|
|
wbStartContentsLoad();
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Move the load state to show that we are waiting for all the pages
|
|
// to be deleted.
|
|
//
|
|
m_loadState = LOAD_STATE_PENDING_DELETE;
|
|
TRACE_OUT(("Moved load state to LOAD_STATE_PENDING_DELETE"));
|
|
}
|
|
}
|
|
|
|
DebugExitVOID(wbPageClearConfirm);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbCheckReadyPages
|
|
//
|
|
// Purpose: Check that we have enough worksets open for the local user to
|
|
// use immediately (during page adds).
|
|
//
|
|
// Returns: None
|
|
//
|
|
//
|
|
BOOL WbClient::wbCheckReadyPages(void)
|
|
{
|
|
BOOL bResult = TRUE;
|
|
WB_PAGE_HANDLE hNewPage;
|
|
UINT countPages = m_pageOrder.countPages;
|
|
UINT countReadyPages = m_countReadyPages;
|
|
|
|
//
|
|
// If we have opened all the worksets
|
|
//
|
|
if (countReadyPages == WB_MAX_PAGES)
|
|
{
|
|
//
|
|
// Quit there are no more worksets that we can open
|
|
//
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// If the number of pages in use is getting close to the number of ready
|
|
// pages.
|
|
//
|
|
if ( (countReadyPages >= PREINITIALIZE_PAGES)
|
|
&& (countPages <= (countReadyPages - PREINITIALIZE_PAGES)))
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// If the number of pages ready is less than the required cache size,
|
|
// open another one.
|
|
//
|
|
hNewPage = wbGetEmptyPageHandle();
|
|
if (hNewPage != WB_PAGE_HANDLE_NULL)
|
|
{
|
|
//
|
|
// Open the workset associated with the page
|
|
//
|
|
wbPageWorksetOpen(hNewPage, OPEN_LOCAL);
|
|
}
|
|
|
|
bResult = FALSE;
|
|
|
|
DC_EXIT_POINT:
|
|
return(bResult);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageAdd
|
|
//
|
|
// Purpose: Add a new (blank) page in a specified position
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbPageAdd
|
|
(
|
|
WB_PAGE_HANDLE hRefPage,
|
|
UINT where,
|
|
PWB_PAGE_HANDLE phPage,
|
|
UINT changedFlagAction
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
WB_PAGE_HANDLE hNewPage;
|
|
|
|
DebugEntry(wbPageAdd);
|
|
|
|
//
|
|
// Check that there are not too many pages already
|
|
//
|
|
if (m_pageOrder.countPages == WB_MAX_PAGES)
|
|
{
|
|
result = WB_RC_TOO_MANY_PAGES;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Validate the specified reference page
|
|
//
|
|
ASSERT(GetPageState(hRefPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Get a handle for the new page
|
|
//
|
|
hNewPage = wbGetReadyPageHandle();
|
|
|
|
//
|
|
// If there are no handles ready we attempt to create one and return a
|
|
// busy indication.
|
|
//
|
|
if (hNewPage == WB_PAGE_HANDLE_NULL)
|
|
{
|
|
result = WB_RC_BUSY;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Make the internal update immediately - this allows the client to
|
|
// reference the new page as soon as this function has returned.
|
|
//
|
|
wbPagesPageAdd(hRefPage, hNewPage, where);
|
|
|
|
//
|
|
// Update the Page Control Object
|
|
//
|
|
result = wbWritePageControl(FALSE);
|
|
if (result != 0)
|
|
{
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Show that the contents have changed (if required).
|
|
//
|
|
if (changedFlagAction == RESET_CHANGED_FLAG)
|
|
{
|
|
m_changed = TRUE;
|
|
TRACE_OUT(("Changed flag now TRUE"));
|
|
}
|
|
|
|
//
|
|
// Return the handle of the new page
|
|
//
|
|
*phPage = hNewPage;
|
|
|
|
DC_EXIT_POINT:
|
|
//
|
|
// If we successfully added the page, or could not get a spare page
|
|
// handle, attempt to create a spare one for next time.
|
|
//
|
|
if ((result == 0) || (result == WB_RC_BUSY))
|
|
{
|
|
wbCheckReadyPages();
|
|
}
|
|
|
|
DebugExitDWORD(wbPageAdd, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageMove
|
|
//
|
|
// Purpose: Move a page relative to another page
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbPageMove
|
|
(
|
|
WB_PAGE_HANDLE hRefPage,
|
|
WB_PAGE_HANDLE hPage,
|
|
UINT where
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
PWB_PAGE_ORDER pPageOrder = &(m_pageOrder);
|
|
|
|
DebugEntry(wbPageMove);
|
|
|
|
//
|
|
// Extract the page to be moved
|
|
//
|
|
wbPageOrderPageDelete(pPageOrder, hPage);
|
|
|
|
//
|
|
// Add it back at its new position
|
|
//
|
|
wbPageOrderPageAdd(pPageOrder, hRefPage, hPage, where);
|
|
|
|
//
|
|
// Update the page control object
|
|
//
|
|
result = wbWritePageControl(FALSE);
|
|
if (result != 0)
|
|
{
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Show that the contents have changed
|
|
//
|
|
m_changed = TRUE;
|
|
TRACE_OUT(("Changed flag now TRUE"));
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbPageMove, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPageHandle
|
|
//
|
|
// Purpose: Return a page handle. The page for which the handle is
|
|
// required can be specified relative to another page or as the
|
|
// first/last page.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbPageHandle
|
|
(
|
|
WB_PAGE_HANDLE hRefPage,
|
|
UINT where,
|
|
PWB_PAGE_HANDLE phPage
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
UINT pageNumber;
|
|
PWB_PAGE_ORDER pPageOrder = &(m_pageOrder);
|
|
POM_WORKSET_ID pPage = pPageOrder->pages;
|
|
WB_PAGE_HANDLE hPage;
|
|
|
|
DebugEntry(wbPageHandle);
|
|
|
|
//
|
|
// Check the relative position
|
|
//
|
|
switch (where)
|
|
{
|
|
case PAGE_FIRST:
|
|
hPage = pPage[0];
|
|
break;
|
|
|
|
case PAGE_LAST:
|
|
hPage = pPage[pPageOrder->countPages - 1];
|
|
break;
|
|
|
|
case PAGE_AFTER:
|
|
case PAGE_BEFORE:
|
|
//
|
|
// Validate the specified reference page
|
|
//
|
|
ASSERT(GetPageState(hRefPage)->state == PAGE_IN_USE);
|
|
|
|
//
|
|
// Get the page number of the reference page
|
|
//
|
|
pageNumber = wbPageOrderPageNumber(pPageOrder, hRefPage);
|
|
TRACE_OUT(("Reference page number is %d", pageNumber));
|
|
|
|
//
|
|
// Get the page number of the required page
|
|
//
|
|
pageNumber = (UINT)(pageNumber + ((where == PAGE_AFTER) ? 1 : -1));
|
|
TRACE_OUT(("New page number is %d", pageNumber));
|
|
|
|
//
|
|
// Check that the new page is valid
|
|
//
|
|
TRACE_OUT(("Number of pages is %d", pPageOrder->countPages));
|
|
if ( (pageNumber < 1)
|
|
|| (pageNumber > pPageOrder->countPages))
|
|
{
|
|
TRACE_OUT(("Returning WB_RC_NO_SUCH_PAGE"));
|
|
result = WB_RC_NO_SUCH_PAGE;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Get the handle of the page
|
|
//
|
|
hPage = pPage[pageNumber - 1];
|
|
TRACE_OUT(("Returning handle %d", (UINT) hPage));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Return the page handle
|
|
//
|
|
*phPage = hPage;
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbPageHandle, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbGraphicSelectPrevious
|
|
//
|
|
// Purpose: Return the next graphic object in the specified page whose
|
|
// bounding rectangle contains the specified point. The function
|
|
// starts with the graphic whose handle is given as parameter and
|
|
// will return this graphic if it contains the point.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbGraphicSelectPrevious
|
|
(
|
|
WB_PAGE_HANDLE hPage,
|
|
LPPOINT pPoint,
|
|
WB_GRAPHIC_HANDLE hGraphic,
|
|
PWB_GRAPHIC_HANDLE phGraphic
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
OM_WORKSET_ID worksetID = (OM_WORKSET_ID)hPage;
|
|
PWB_GRAPHIC pGraphic;
|
|
POM_OBJECTDATA pData;
|
|
RECT rect;
|
|
|
|
DebugEntry(wbGraphicSelectPrevious);
|
|
|
|
*phGraphic = (WB_GRAPHIC_HANDLE) NULL;
|
|
|
|
//
|
|
// Loop back through the objects starting at the reference point
|
|
//
|
|
do
|
|
{
|
|
//
|
|
// Get the object from ObMan
|
|
//
|
|
result = OM_ObjectRead(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
hGraphic,
|
|
&pData);
|
|
|
|
//
|
|
// Leave the loop if error on read - we do not need to do the release
|
|
//
|
|
if (result != 0)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
pGraphic = GraphicPtrFromObjectData(pData);
|
|
|
|
//
|
|
// Extract the bounding rectangle of the object
|
|
//
|
|
RECT_FROM_TSHR_RECT16(&rect, pGraphic->rectBounds);
|
|
|
|
//
|
|
// Release the object
|
|
//
|
|
OM_ObjectRelease(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
hGraphic,
|
|
&pData);
|
|
|
|
//
|
|
// Check whether the point lies in bounds
|
|
//
|
|
if (PtInRect(&rect, *pPoint))
|
|
{
|
|
//
|
|
// Set the result handle
|
|
//
|
|
TRACE_OUT(("Returning graphic handle"));
|
|
*phGraphic = hGraphic;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Get the next object to test
|
|
//
|
|
result = OM_ObjectH(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
hGraphic,
|
|
&hGraphic,
|
|
BEFORE);
|
|
}
|
|
while (result == 0);
|
|
|
|
//
|
|
// Correct the return code (if necessary)
|
|
//
|
|
if (result == OM_RC_NO_SUCH_OBJECT)
|
|
{
|
|
TRACE_OUT(("Returning WB_RC_NO_SUCH_GRAPHIC"));
|
|
result = WB_RC_NO_SUCH_GRAPHIC;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbGraphicSelectPrevious, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbCoreExitHandler
|
|
//
|
|
// Purpose: Exit handler for the Whiteboard Core. This handler is
|
|
// registered with the Utilities by the WBP_Start call. It is
|
|
// deregistered by the client deregistration process, so it is
|
|
// only called when an abnormal termination occurs.
|
|
//
|
|
// Returns: None
|
|
//
|
|
//
|
|
void CALLBACK wbCoreExitHandler(LPVOID clientData)
|
|
{
|
|
WbClient* pwbClient = (WbClient *)clientData;
|
|
|
|
pwbClient->wbExitHandler();
|
|
}
|
|
|
|
|
|
void WbClient::wbExitHandler(void)
|
|
{
|
|
DebugEntry(wbExitHandler);
|
|
|
|
//
|
|
// Leave the current call if there is one, removing any locks etc.
|
|
//
|
|
wbLeaveCall();
|
|
|
|
//
|
|
// Dereg from call manager
|
|
//
|
|
if (m_pcmClient != NULL)
|
|
{
|
|
CMS_Deregister(&(m_pcmClient));
|
|
}
|
|
|
|
//
|
|
// Dereg exit handler
|
|
//
|
|
if (m_subState >= STATE_START_REGISTERED_EXIT)
|
|
{
|
|
UT_DeregisterExit(m_putTask, wbCoreExitHandler, this);
|
|
}
|
|
|
|
//
|
|
// Dereg obman
|
|
//
|
|
if (m_subState >= STATE_START_REGISTERED_OM)
|
|
{
|
|
OM_Deregister(&m_pomClient);
|
|
}
|
|
|
|
//
|
|
// Dereg event handler
|
|
//
|
|
if (m_subState >= STATE_START_REGISTERED_EVENT)
|
|
{
|
|
UT_DeregisterEvent(m_putTask, wbCoreEventHandler, this);
|
|
}
|
|
|
|
//
|
|
// delete ourself!
|
|
//
|
|
delete this;
|
|
|
|
DebugExitVOID(wbExitHandler);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbCoreEventHandler
|
|
//
|
|
// Purpose: Event handler for the Whiteboard Core. This handler is
|
|
// registered with the Utilities by the WBP_Start call.
|
|
//
|
|
// Params: clientData - pointer to the data stored for a client
|
|
// event - event identifier
|
|
// param1 - word event parameter (content depends on event)
|
|
// param2 - long event parameter (content depends on event)
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL CALLBACK wbCoreEventHandler
|
|
(
|
|
LPVOID clientData,
|
|
UINT event,
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
WbClient* pwbClient = (WbClient *)clientData;
|
|
|
|
return(pwbClient->wbEventHandler(event, param1, param2));
|
|
}
|
|
|
|
|
|
BOOL WbClient::wbEventHandler
|
|
(
|
|
UINT event,
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
POM_EVENT_DATA32 pEvent32 = (POM_EVENT_DATA32) ¶m2;
|
|
BOOL processed = FALSE;
|
|
|
|
DebugEntry(wbEventHandler);
|
|
|
|
TRACE_OUT(("event %d, param1 %d, param2 %d", event, param1, param2));
|
|
|
|
switch (event)
|
|
{
|
|
//
|
|
// Confirmation that we have registered with a workset group
|
|
//
|
|
case OM_WSGROUP_REGISTER_CON:
|
|
TRACE_OUT(("OM_WSGROUP_REGISTER_CON %x %x",param1,param2));
|
|
processed = wbOnWsGroupRegisterCon(param1, param2);
|
|
break;
|
|
|
|
//
|
|
// Confirmation that we have moved a workset group
|
|
//
|
|
case OM_WSGROUP_MOVE_CON:
|
|
TRACE_OUT(("OM_WSGROUP_MOVE_CON %x %x",param1,param2));
|
|
processed = wbOnWsGroupMoveCon(param1, param2);
|
|
break;
|
|
|
|
//
|
|
// Our workset group has been moved
|
|
//
|
|
case OM_WSGROUP_MOVE_IND:
|
|
TRACE_OUT(("OM_WSGROUP_MOVE_IND %x %x",param1,param2));
|
|
processed = wbOnWsGroupMoveInd(param1, param2);
|
|
break;
|
|
|
|
//
|
|
// A workset has been created - we do nothing
|
|
//
|
|
case OM_WORKSET_NEW_IND:
|
|
TRACE_OUT(("OM_WORKSET_NEW_IND %x %x",param1,param2));
|
|
processed = TRUE;
|
|
break;
|
|
|
|
//
|
|
// A workset has been opened
|
|
//
|
|
case OM_WORKSET_OPEN_CON:
|
|
TRACE_OUT(("OM_WORKSET_OPEN_CON %x %x",param1,param2));
|
|
processed = wbOnWorksetOpenCon(param1, param2);
|
|
break;
|
|
|
|
//
|
|
// A workset has been locked
|
|
//
|
|
case OM_WORKSET_LOCK_CON:
|
|
TRACE_OUT(("OM_WORKSET_LOCK_CON %x %x",param1,param2));
|
|
processed = wbOnWorksetLockCon(param1, param2);
|
|
break;
|
|
|
|
//
|
|
// A workset has been unlocked
|
|
//
|
|
case OM_WORKSET_UNLOCK_IND:
|
|
TRACE_OUT(("OM_WORKSET_UNLOCK_IND %x %x",param1,param2));
|
|
processed = wbOnWorksetUnlockInd(param1, param2);
|
|
break;
|
|
|
|
//
|
|
// ObMan has run out of resources
|
|
//
|
|
case OM_OUT_OF_RESOURCES_IND:
|
|
TRACE_OUT(("OM_OUT_OF_RESOURCES_IND %x %x",param1,param2));
|
|
wbError();
|
|
processed = TRUE;
|
|
break;
|
|
|
|
//
|
|
// A workset has been cleared
|
|
//
|
|
case OM_WORKSET_CLEAR_IND:
|
|
TRACE_OUT(("OM_WORKSET_CLEAR_IND %x %x",param1,param2));
|
|
processed = wbOnWorksetClearInd(param1, param2);
|
|
break;
|
|
|
|
//
|
|
// A new object has been added to a workset
|
|
//
|
|
case OM_OBJECT_ADD_IND:
|
|
TRACE_OUT(("OM_OBJECT_ADD_IND %x %x",param1,param2));
|
|
processed = wbOnObjectAddInd(param1, (POM_OBJECT)param2);
|
|
break;
|
|
|
|
//
|
|
// An object has been moved
|
|
//
|
|
case OM_OBJECT_MOVE_IND:
|
|
TRACE_OUT(("OM_OBJECT_MOVE_IND %x %x",param1,param2));
|
|
processed = wbOnObjectMoveInd(param1, param2);
|
|
break;
|
|
|
|
//
|
|
// An object has been deleted
|
|
//
|
|
case OM_OBJECT_DELETE_IND:
|
|
TRACE_OUT(("OM_OBJECT_DELETE_IND %x %x",param1,param2));
|
|
processed = wbOnObjectDeleteInd(param1, (POM_OBJECT)param2);
|
|
break;
|
|
|
|
//
|
|
// An object has been updated
|
|
//
|
|
case OM_OBJECT_UPDATE_IND:
|
|
TRACE_OUT(("OM_OBJECT_UPDATE_IND %x %x",param1,param2));
|
|
processed = wbOnObjectUpdateInd(param1, (POM_OBJECT)param2);
|
|
break;
|
|
|
|
//
|
|
// An object has been updated
|
|
//
|
|
case OM_OBJECT_REPLACE_IND:
|
|
TRACE_OUT(("OM_OBJECT_REPLACE_IND %x %x",param1,param2));
|
|
processed = wbOnObjectReplaceInd(param1, (POM_OBJECT)param2);
|
|
break;
|
|
|
|
//
|
|
// Load chaining event
|
|
//
|
|
case WBPI_EVENT_LOAD_NEXT:
|
|
TRACE_OUT(("WBPI_EVENT_LOAD_NEXT"));
|
|
wbPageLoad();
|
|
processed = TRUE;
|
|
break;
|
|
|
|
//
|
|
// Whiteboard page clear indication
|
|
//
|
|
case WBP_EVENT_PAGE_CLEAR_IND:
|
|
TRACE_OUT(("WBP_EVENT_PAGE_CLEAR_IND"));
|
|
processed = wbOnWBPPageClearInd((WB_PAGE_HANDLE) param1);
|
|
break;
|
|
|
|
//
|
|
// Whiteboard lock notification
|
|
//
|
|
case WBP_EVENT_PAGE_ORDER_LOCKED:
|
|
case WBP_EVENT_CONTENTS_LOCKED:
|
|
TRACE_OUT(("WBP_EVENT_xxx_LOCKED (%#hx) %#hx %#lx",
|
|
event,
|
|
param1,
|
|
param2));
|
|
processed = wbOnWBPLock();
|
|
break;
|
|
|
|
//
|
|
// Whiteboard lock failure notification
|
|
//
|
|
case WBP_EVENT_LOCK_FAILED:
|
|
TRACE_OUT(("WBP_EVENT_LOCK_FAILED %x %x",param1,param2));
|
|
processed = wbOnWBPLockFailed();
|
|
break;
|
|
|
|
//
|
|
// Whiteboard Unlock notification
|
|
//
|
|
case WBP_EVENT_UNLOCKED:
|
|
TRACE_OUT(("WBP_EVENT_UNLOCKED %x %x",param1,param2));
|
|
processed = wbOnWBPUnlocked();
|
|
break;
|
|
|
|
//
|
|
// Whiteboard Page Order Updated notification
|
|
//
|
|
case WBP_EVENT_PAGE_ORDER_UPDATED:
|
|
TRACE_OUT(("WBP_EVENT_PAGE_ORDER_UPDATED %x %x",
|
|
param1,
|
|
param2));
|
|
processed = wbOnWBPPageOrderUpdated();
|
|
break;
|
|
|
|
//
|
|
// We are not interested in this event - do nothing
|
|
//
|
|
default:
|
|
TRACE_OUT(("Event ignored"));
|
|
break;
|
|
} // Switch on event type
|
|
|
|
|
|
DebugExitBOOL(wbEventHandler, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// wbJoinCallError
|
|
//
|
|
// This function should be called in STATE_REGISTERING only.
|
|
//
|
|
//
|
|
void WbClient::wbJoinCallError(void)
|
|
{
|
|
DebugEntry(wbJoinCallError);
|
|
|
|
ASSERT((m_state == STATE_REGISTERING));
|
|
|
|
//
|
|
// Post a registration failed message to the client
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_REGISTER_FAILED"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_JOIN_CALL_FAILED, // Failure
|
|
0, // No parameters
|
|
0);
|
|
|
|
//
|
|
// Tidy up after the attempt to join the call
|
|
//
|
|
wbLeaveCall();
|
|
|
|
DebugExitVOID(wbJoinCallError);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// wbError
|
|
//
|
|
void WbClient::wbError(void)
|
|
{
|
|
DebugEntry(wbError);
|
|
|
|
//
|
|
// An error has occurred during Core processing. We act according to the
|
|
// current state.
|
|
//
|
|
switch (m_state)
|
|
{
|
|
//
|
|
// If the error has occurred during registration, post a registration
|
|
// failure message to the client and cancel registration.
|
|
//
|
|
case STATE_REGISTERING:
|
|
wbJoinCallError();
|
|
break;
|
|
|
|
//
|
|
// If the error occurred during normal running, we tell the client who
|
|
// must deregister.
|
|
//
|
|
case STATE_IDLE:
|
|
//
|
|
// Only take action if we are not already in fatal error state
|
|
//
|
|
if (m_errorState == ERROR_STATE_EMPTY)
|
|
{
|
|
//
|
|
// Post an error message to the client
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_ERROR"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_ERROR, // Error
|
|
0, // No parameters
|
|
0);
|
|
|
|
//
|
|
// Record that an error has occurred
|
|
//
|
|
m_errorState = ERROR_STATE_FATAL;
|
|
TRACE_OUT(("Moved error state to ERROR_STATE_FATAL"));
|
|
}
|
|
break;
|
|
|
|
//
|
|
// Client is in an unknown state
|
|
//
|
|
default:
|
|
ERROR_OUT(("Bad main state for call"));
|
|
break;
|
|
}
|
|
|
|
DebugExitVOID(wbError);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWSGroupMoveCon
|
|
//
|
|
// Purpose: Routine processing OM_WSGROUP_MOVE_CON events.
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWsGroupMoveCon
|
|
(
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
POM_EVENT_DATA32 pEvent32 = (POM_EVENT_DATA32) ¶m2;
|
|
BOOL processed = FALSE;
|
|
UINT rc;
|
|
BOOL failedToJoin = FALSE;
|
|
|
|
DebugEntry(wbOnWsGroupMoveCon);
|
|
|
|
//
|
|
// Check that this is the event we are expecting
|
|
//
|
|
if (pEvent32->correlator != m_wsgroupCorrelator)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Show that we have processed the event
|
|
//
|
|
processed = TRUE;
|
|
|
|
//
|
|
// Test for the correct state
|
|
//
|
|
if (m_subState != STATE_REG_PENDING_WSGROUP_MOVE)
|
|
{
|
|
//
|
|
// We are not in the correct state for this event - this is an internal
|
|
// error.
|
|
//
|
|
ERROR_OUT(("Wrong state for WSGroupMoveCon"));
|
|
}
|
|
|
|
//
|
|
// Check that the return code for the move is OK
|
|
//
|
|
if (pEvent32->result != 0)
|
|
{
|
|
//
|
|
// Moving the workset group failed - post a "join call failed" message
|
|
// to the front-end.
|
|
//
|
|
TRACE_OUT(("WSGroup move failed, result = %d", pEvent32->result));
|
|
failedToJoin = TRUE;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// The WSGroupMove has completed successfully. Replace our local user
|
|
// object by deleting the current one (we must have one to get to this
|
|
// point) and adding a new one.
|
|
//
|
|
// The reason we do this is that our existing user object has been moved
|
|
// from the local domain into a call, but since it is in a non-persistent
|
|
// workset, the Obman behaviour for this object when the call ends is
|
|
// undefined. So we replace the object to get a defined behaviour.
|
|
//
|
|
TRACE_OUT(("Deleting local user object"));
|
|
rc = OM_ObjectDelete(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
m_pObjLocal);
|
|
if (rc != 0)
|
|
{
|
|
ERROR_OUT(("Error deleting local user object = %u", rc));
|
|
}
|
|
|
|
TRACE_OUT(("Adding new local user object"));
|
|
rc = wbAddLocalUserObject();
|
|
if (rc != 0)
|
|
{
|
|
TRACE_OUT(("Failed to add local user object"));
|
|
failedToJoin = TRUE;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Get the clients network ID, used in graphic objects to determine where
|
|
// they are loaded.
|
|
//
|
|
if (!wbGetNetUserID())
|
|
{
|
|
//
|
|
// Tidy up (and post an error event to the client)
|
|
//
|
|
ERROR_OUT(("Failed to get user ID, rc %u", rc));
|
|
failedToJoin = TRUE;
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We added our user object successfully, so now wait for the
|
|
// OBJECT_ADD_IND to arrive.
|
|
//
|
|
m_subState = STATE_REG_PENDING_NEW_USER_OBJECT;
|
|
|
|
DC_EXIT_POINT:
|
|
if (failedToJoin)
|
|
{
|
|
//
|
|
// We have failed to join the call, so clean up.
|
|
//
|
|
wbError();
|
|
}
|
|
|
|
DebugExitBOOL(wbOnWsGroupMoveCon, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWSGroupMoveInd
|
|
//
|
|
// Purpose: Routine processing OM_WSGROUP_MOVE_IND events.
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWsGroupMoveInd
|
|
(
|
|
UINT_PTR param1,
|
|
UINT_PTR callID
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
BOOL processed = TRUE;
|
|
|
|
DebugEntry(wbOnWsGroupMoveInd);
|
|
|
|
if (callID != OM_NO_CALL)
|
|
{
|
|
TRACE_OUT(("Moved into new call"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// If we are registering, treat it as a failure to join the call,
|
|
// otherwise let the client know about the network failure.
|
|
//
|
|
if (m_state == STATE_REGISTERING)
|
|
{
|
|
TRACE_OUT(("Call went down while registering"));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
TRACE_OUT(("Posting WBP_EVENT_NETWORK_LOST"));
|
|
WBP_PostEvent(0,
|
|
WBP_EVENT_NETWORK_LOST, // Unlocked
|
|
0, // No parameters
|
|
0);
|
|
|
|
//
|
|
// Tidy up the User Information workset (the local client is now the
|
|
// only user). Note that since the user information workset it
|
|
// non-persistent, Obman will delete the remote user objects for us.
|
|
//
|
|
|
|
//
|
|
// - check we have opened the user workset
|
|
//
|
|
if ( (m_state > STATE_REGISTERING) ||
|
|
(m_subState > STATE_REG_PENDING_USER_WORKSET))
|
|
{
|
|
//
|
|
// Delete the lock object.
|
|
//
|
|
if (m_pObjLock != NULL)
|
|
{
|
|
TRACE_OUT(("Deleting lock object %d", m_pObjLock));
|
|
if (OM_ObjectDelete(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
m_pObjLock) != 0)
|
|
{
|
|
ERROR_OUT(("Error deleting lock object"));
|
|
}
|
|
|
|
if (m_lockState == LOCK_STATE_GOT_LOCK)
|
|
{
|
|
//
|
|
// If all is well at this point the unlock process will be
|
|
// completed when the object delete ind is received.
|
|
//
|
|
m_lockState = LOCK_STATE_PENDING_DELETE;
|
|
TRACE_OUT(("Moved to state LOCK_STATE_PENDING_DELETE"));
|
|
}
|
|
else
|
|
{
|
|
m_lockState = LOCK_STATE_EMPTY;
|
|
TRACE_OUT(("Moved to state LOCK_STATE_EMPTY"));
|
|
}
|
|
}
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnWSGroupMoveInd, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWorksetClearInd
|
|
//
|
|
// Purpose: Routine processing OM_WORKSET_CLEAR_IND events.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWorksetClearInd
|
|
(
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
POM_EVENT_DATA32 pEvent32 = (POM_EVENT_DATA32) ¶m2;
|
|
BOOL processed = FALSE;
|
|
|
|
DebugEntry(wbOnWorksetClearInd);
|
|
|
|
//
|
|
// Check that the workset group is ours
|
|
//
|
|
if (pEvent16->hWSGroup != m_hWSGroup)
|
|
{
|
|
ERROR_OUT(("Event for unknown workset group = %d", pEvent16->hWSGroup));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We will process the event
|
|
//
|
|
processed = TRUE;
|
|
|
|
//
|
|
// Process the event according to the workset ID
|
|
//
|
|
switch(pEvent16->worksetID)
|
|
{
|
|
//
|
|
// Page Control Workset
|
|
//
|
|
case PAGE_CONTROL_WORKSET:
|
|
ERROR_OUT(("Unexpected clear for Page Control Workset"));
|
|
break;
|
|
|
|
//
|
|
// Lock Workset
|
|
//
|
|
case SYNC_CONTROL_WORKSET:
|
|
ERROR_OUT(("Unexpected clear for Sync Control Workset"));
|
|
break;
|
|
|
|
//
|
|
// User Information Workset
|
|
//
|
|
case USER_INFORMATION_WORKSET:
|
|
ERROR_OUT(("Unexpected clear for User Information Workset"));
|
|
break;
|
|
|
|
//
|
|
// Other (should be a Page Workset)
|
|
//
|
|
default:
|
|
//
|
|
// Tell the client that the page has been cleared - the client must then
|
|
// confirm the clear.
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_PAGE_CLEAR_IND"));
|
|
WBP_PostEvent(
|
|
0,
|
|
WBP_EVENT_PAGE_CLEAR_IND,
|
|
pEvent16->worksetID,
|
|
0);
|
|
break;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnWorksetClearInd, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWBPPageClearInd
|
|
//
|
|
// Purpose: Routine processing WBP_PAGE_CLEAR_IND events.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWBPPageClearInd(WB_PAGE_HANDLE hPage)
|
|
{
|
|
BOOL processed;
|
|
|
|
DebugEntry(wbOnWBPPageClearInd);
|
|
|
|
//
|
|
// This routine catches WB_PAGE_CLEAR_IND events posted to the client.
|
|
// Because of the asynchronous nature of page order updates these can
|
|
// sometimes have been sent previously for pages that are now no longer
|
|
// in use. We trap these events here, confirm the clear to ObMan and
|
|
// discard the event.
|
|
//
|
|
if (GetPageState(hPage)->state != PAGE_IN_USE)
|
|
{
|
|
TRACE_OUT(("Page is not in use - confirming workset clear immediately"));
|
|
|
|
//
|
|
// Accept the page clear immediately
|
|
//
|
|
wbPageClearConfirm(hPage);
|
|
processed = TRUE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If we get here the page is in use - so we must pass the event on to
|
|
// the client. Resetting the result code of this routine to "not
|
|
// processed" will ask the utilities to pass it on to the next event
|
|
// handler.
|
|
//
|
|
processed = FALSE;
|
|
}
|
|
|
|
|
|
DebugExitBOOL(wbOnWBPPageClearInd, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnObjectAddInd
|
|
//
|
|
// Purpose: Routine processing OM_OBJECT_ADD_IND events.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnObjectAddInd
|
|
(
|
|
UINT_PTR param1,
|
|
POM_OBJECT pObj
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
BOOL processed = FALSE;
|
|
|
|
DebugEntry(wbOnObjectAddInd);
|
|
|
|
//
|
|
// Check that the workset group is ours
|
|
//
|
|
if (pEvent16->hWSGroup != m_hWSGroup)
|
|
{
|
|
ERROR_OUT(("Event for unknown workset group = %d", pEvent16->hWSGroup));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We will process the event
|
|
//
|
|
processed = TRUE;
|
|
|
|
//
|
|
// Process the event according to the workset ID
|
|
//
|
|
switch(pEvent16->worksetID)
|
|
{
|
|
//
|
|
// Page Control Workset
|
|
//
|
|
case PAGE_CONTROL_WORKSET:
|
|
wbOnPageObjectAddInd(pObj);
|
|
break;
|
|
|
|
//
|
|
// Sync Control Workset
|
|
//
|
|
case SYNC_CONTROL_WORKSET:
|
|
wbOnSyncObjectAddInd(pObj);
|
|
break;
|
|
|
|
//
|
|
// User Information Workset
|
|
//
|
|
case USER_INFORMATION_WORKSET:
|
|
wbOnUserObjectAddInd(pObj);
|
|
break;
|
|
|
|
//
|
|
// Other (should be a Page Workset)
|
|
//
|
|
default:
|
|
wbOnGraphicObjectAddInd(pEvent16->worksetID, pObj);
|
|
break;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnObjectAddInd, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbGetPageObjectType
|
|
//
|
|
// Purpose: Get the type of an object in the Page Control Workset
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbGetPageObjectType
|
|
(
|
|
POM_OBJECT pObj,
|
|
UINT * pObjectType
|
|
)
|
|
{
|
|
UINT result;
|
|
POM_OBJECTDATA pData;
|
|
|
|
DebugEntry(wbGetPageObjectType);
|
|
|
|
//
|
|
// Read the object to get its type
|
|
//
|
|
result = OM_ObjectRead(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
pObj,
|
|
&pData);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Error reading object = %d", result));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// The first two bytes of the object data give its type
|
|
//
|
|
*pObjectType = *((TSHR_UINT16 *)pData->data);
|
|
|
|
//
|
|
// Release the object
|
|
//
|
|
OM_ObjectRelease(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
pObj,
|
|
&pData);
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbGetPageObjectType, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnPageObjectAddInd
|
|
//
|
|
// Purpose: Routine processing OM_OBJECT_ADD_IND events occurring on the
|
|
// Page Control Workset.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnPageObjectAddInd(POM_OBJECT pObj)
|
|
{
|
|
UINT objectType;
|
|
|
|
DebugEntry(wbOnPageObjectAddInd);
|
|
|
|
//
|
|
// Read the object to get its type
|
|
//
|
|
if (wbGetPageObjectType(pObj, &objectType) != 0)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Act according to the type of object added
|
|
//
|
|
switch (objectType)
|
|
{
|
|
case TYPE_CONTROL_LOCK:
|
|
TRACE_OUT(("It is a lock object"));
|
|
wbReadLock();
|
|
break;
|
|
|
|
case TYPE_CONTROL_PAGE_ORDER:
|
|
TRACE_OUT(("It is the Page Control object"));
|
|
wbOnPageControlObjectAddInd(pObj);
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Unknown object type added to Page Control Workset"));
|
|
break;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnPageObjectAddInd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnPageControlObjectAddInd
|
|
//
|
|
// Purpose: Routine processing add of page control object
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnPageControlObjectAddInd(POM_OBJECT pObj)
|
|
{
|
|
DebugEntry(wbOnPageControlObjectAddInd);
|
|
|
|
//
|
|
// We only ever expect to get one of these objects
|
|
//
|
|
if (m_pObjPageControl != 0)
|
|
{
|
|
//
|
|
// Check that this is the same object - the add has been triggered by
|
|
// the workset open but we have already read the contents.
|
|
//
|
|
ASSERT((m_pObjPageControl == pObj));
|
|
}
|
|
|
|
//
|
|
// Save the handle of the object
|
|
//
|
|
m_pObjPageControl = pObj;
|
|
TRACE_OUT(("Got Page Control object"));
|
|
|
|
//
|
|
// Continue according to the current state
|
|
//
|
|
switch (m_state)
|
|
{
|
|
case STATE_REGISTERING:
|
|
//
|
|
// We now have a Page Control Object - if we are waiting for the
|
|
// object we can now move to the next stage.
|
|
//
|
|
if (m_subState == STATE_REG_PENDING_PAGE_CONTROL)
|
|
{
|
|
//
|
|
// If we have the lock on the Page Control Workset then we are in
|
|
// control of the registration process. We must add the sync
|
|
// control object to the Sync Workset.
|
|
//
|
|
if (m_lockState == LOCK_STATE_GOT_LOCK)
|
|
{
|
|
//
|
|
// Create the Sync Control Object
|
|
//
|
|
if (wbCreateSyncControl() != 0)
|
|
{
|
|
ERROR_OUT(("Error adding Sync Control Object"));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we do not have the sync control object then wait for it -
|
|
// otherwise we can complete initialisation.
|
|
//
|
|
if (m_pObjSyncControl == 0)
|
|
{
|
|
m_subState = STATE_REG_PENDING_SYNC_CONTROL;
|
|
TRACE_OUT(("Moved substate to STATE_REG_PENDING_SYNC_CONTROL"));
|
|
DC_QUIT;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If it is us who has the Page Control Workset locked - release
|
|
// the lock.
|
|
//
|
|
if (m_lockState == LOCK_STATE_GOT_LOCK)
|
|
{
|
|
//
|
|
// Unlock the workset
|
|
//
|
|
wbUnlock();
|
|
|
|
//
|
|
// Wait for notification of the lock being released
|
|
//
|
|
TRACE_OUT(("Sub state change %d to %d",
|
|
m_subState, STATE_REG_PENDING_UNLOCK));
|
|
|
|
m_subState = STATE_REG_PENDING_UNLOCK;
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT(("Page Control and Sync Control objects both there."));
|
|
TRACE_OUT(("Registration can be completed"));
|
|
wbOnControlWorksetsReady();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// In other registration states we are not ready to process the
|
|
// event. It will be dealt with later.
|
|
//
|
|
break;
|
|
|
|
case STATE_IDLE:
|
|
//
|
|
// We must already have a Page COntrol Object since we are in idle
|
|
// state. So this is an error. It may have been caused by another
|
|
// client so we just trace it rather than asserting.
|
|
//
|
|
ERROR_OUT(("Unexpected add of Page Control Object in idle state"));
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad main state"));
|
|
break;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnPageControlObjectAddInd);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnSyncObjectAddInd
|
|
//
|
|
// Purpose: Routine processing OM_OBJECT_ADD_IND events occurring on the
|
|
// Sync Control Workset.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnSyncObjectAddInd(POM_OBJECT pObj)
|
|
{
|
|
DebugEntry(wbOnSyncObjectAddInd);
|
|
|
|
//
|
|
// We only expect this during registration
|
|
//
|
|
switch(m_state)
|
|
{
|
|
//
|
|
// We are waiting for registration to continue
|
|
//
|
|
case STATE_REGISTERING:
|
|
switch(m_subState)
|
|
{
|
|
//
|
|
// We are waiting for a Sync Control Object
|
|
//
|
|
case STATE_REG_PENDING_SYNC_CONTROL:
|
|
m_pObjSyncControl = pObj;
|
|
|
|
//
|
|
// The Sync Control object has been added. We do not need to do
|
|
// anything with it yet.
|
|
//
|
|
|
|
//
|
|
// If we already have the page control object then we can
|
|
// complete initilisation, otherwise we have to wait for it.
|
|
//
|
|
if (m_pObjPageControl == 0)
|
|
{
|
|
TRACE_OUT(("Sub state change %d to %d",
|
|
m_subState, STATE_REG_PENDING_PAGE_CONTROL));
|
|
m_subState = STATE_REG_PENDING_PAGE_CONTROL;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If it is us who has the Page Control Workset locked -
|
|
// release the lock.
|
|
//
|
|
if (m_lockState == LOCK_STATE_GOT_LOCK)
|
|
{
|
|
//
|
|
// Unlock the workset
|
|
//
|
|
wbUnlock();
|
|
|
|
//
|
|
// Wait for notification of the lock being released
|
|
//
|
|
TRACE_OUT(("Sub state change %d to %d",
|
|
m_subState, STATE_REG_PENDING_UNLOCK));
|
|
m_subState = STATE_REG_PENDING_UNLOCK;
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT(("Page Control and Sync Control objects both there."));
|
|
TRACE_OUT(("Registration can be completed"));
|
|
wbOnControlWorksetsReady();
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
//
|
|
// Save the handle of the Sync Control Object
|
|
//
|
|
m_pObjSyncControl = pObj;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
//
|
|
// We are fully registered and are therefore not expecting an add event
|
|
// on this workset. However, since we are registered we must be
|
|
// satisfied that we have a Sync Control Object - so ignore the error.
|
|
//
|
|
case STATE_IDLE:
|
|
ERROR_OUT(("Sync object add not expected in idle state"));
|
|
break;
|
|
|
|
//
|
|
// The client is in an unknown state
|
|
//
|
|
default:
|
|
ERROR_OUT(("Client in unknown state = %d", m_state));
|
|
break;
|
|
}
|
|
|
|
DebugExitVOID(wbOnSyncObjectAddInd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnUserObjectAddInd
|
|
//
|
|
// Purpose: A user object has been added to the User Information Workset.
|
|
// Inform the client that a new user has joined the call.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnUserObjectAddInd(POM_OBJECT pObj)
|
|
{
|
|
UINT countUsers;
|
|
|
|
DebugEntry(wbOnUserObjectAddInd);
|
|
|
|
OM_WorksetCountObjects(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
&countUsers);
|
|
TRACE_OUT(("Number of users is now %d", countUsers));
|
|
|
|
//
|
|
// Ignore the add indication for our own user.
|
|
//
|
|
if (m_pObjLocal == pObj)
|
|
{
|
|
TRACE_OUT(("Got add of own user object"));
|
|
//
|
|
// If we have the lock (temporarily, with NULL lock owner handle),
|
|
// then we need to update the lock object with our actual handle.
|
|
//
|
|
if ((m_pObjLock != NULL) &&
|
|
(m_lockState == LOCK_STATE_GOT_LOCK))
|
|
{
|
|
TRACE_OUT(("Got the lock - update lock object"));
|
|
wbWriteLock();
|
|
}
|
|
|
|
if ((m_state == STATE_REGISTERING) &&
|
|
(m_subState == STATE_REG_PENDING_NEW_USER_OBJECT))
|
|
{
|
|
//
|
|
// We have successfully joined the call.
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_JOIN_CALL_OK"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_JOIN_CALL_OK, // Unlocked
|
|
0, // No parameters
|
|
0);
|
|
|
|
//
|
|
// Update the state to show that we are ready for work again
|
|
//
|
|
m_state = STATE_IDLE;
|
|
m_subState = STATE_EMPTY;
|
|
TRACE_OUT(("Moved state back to STATE_IDLE"));
|
|
}
|
|
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// If we have created our user object we must check to see if the new
|
|
// user has usurped our color. If so we may need to change color.
|
|
//
|
|
if (m_pObjLocal != NULL)
|
|
{
|
|
TRACE_OUT(("We have added our user object - check colors"));
|
|
wbCheckPersonColor(pObj);
|
|
}
|
|
|
|
//
|
|
// Ignore these events unless we are fully registered
|
|
//
|
|
if (m_state != STATE_IDLE)
|
|
{
|
|
TRACE_OUT(("Ignoring user object add - not fully registered"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Tell the client that a new user has joined
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_USER_JOINED"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_PERSON_JOINED, // Event type
|
|
0, // No short parameter
|
|
(UINT_PTR) pObj); // User object handle
|
|
|
|
//
|
|
// Try to read the lock object - we may not have been able to do this
|
|
// yet.
|
|
//
|
|
wbReadLock();
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnUserObjectAddInd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnGraphicObjectAddInd
|
|
//
|
|
// Purpose: A graphic object has been added to a page workset.
|
|
// Inform the client that a new graphic has been added.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnGraphicObjectAddInd
|
|
(
|
|
OM_WORKSET_ID worksetID,
|
|
POM_OBJECT pObj
|
|
)
|
|
{
|
|
WB_PAGE_HANDLE hPage = (WB_PAGE_HANDLE)worksetID;
|
|
POM_OBJECTDATA pData;
|
|
PWB_GRAPHIC pGraphic;
|
|
UINT result;
|
|
|
|
DebugEntry(wbOnGraphicObjectAddInd);
|
|
|
|
//
|
|
// NFC, SFR 6450. If this object was loaded from file on this machine,
|
|
// then we dont need to set the "changed flag". Otherwise record that
|
|
// the contents have changed
|
|
//
|
|
//
|
|
// Read the object.
|
|
//
|
|
result = OM_ObjectRead(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
pObj,
|
|
&pData);
|
|
if (result != 0)
|
|
{
|
|
WARNING_OUT(("OM_ObjectRead (%u) failed, set changed flag anyway ", result));
|
|
m_changed = TRUE;
|
|
TRACE_OUT(("changed flag now TRUE"));
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Convert the ObMan pointer to a core pointer
|
|
//
|
|
pGraphic = GraphicPtrFromObjectData(pData);
|
|
|
|
if ( ! ((pGraphic->loadedFromFile) &&
|
|
(pGraphic->loadingClientID == m_clientNetID)))
|
|
{
|
|
TRACE_OUT(("Not loaded from file locally - Set changed flag on"));
|
|
m_changed = TRUE;
|
|
TRACE_OUT(("Changed flag now TRUE"));
|
|
}
|
|
|
|
//
|
|
// Finished with the object, so release it.
|
|
//
|
|
OM_ObjectRelease(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
pObj,
|
|
&pData);
|
|
}
|
|
|
|
//
|
|
// These events are ignored unless we are fully registered (the client
|
|
// can do nothing about them if it is not registered correctly).
|
|
//
|
|
if (m_state != STATE_IDLE)
|
|
{
|
|
TRACE_OUT(("Ignoring add of graphic object - not registered"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Check that this page is actually in use
|
|
//
|
|
if (GetPageState(hPage)->state != PAGE_IN_USE)
|
|
{
|
|
TRACE_OUT(("Ignoring add to page not in use"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Inform the client of the object being added
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_GRAPHIC_ADDED"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_GRAPHIC_ADDED, // Event type
|
|
hPage, //
|
|
(UINT_PTR)pObj); // User object handle
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnGraphicObjectAddInd);
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnObjectMoveInd
|
|
//
|
|
// Purpose: This routine is called whenever OM_OBJECT_MOVE_IND events are
|
|
// received.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnObjectMoveInd
|
|
(
|
|
UINT_PTR param1,
|
|
UINT_PTR param2
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
POM_EVENT_DATA32 pEvent32 = (POM_EVENT_DATA32) ¶m2;
|
|
BOOL processed = FALSE;
|
|
|
|
DebugEntry(wbOnObjectMoveInd);
|
|
|
|
//
|
|
// Check that the workset group is ours
|
|
//
|
|
if (pEvent16->hWSGroup != m_hWSGroup)
|
|
{
|
|
ERROR_OUT(("Event for unknown workset group = %d", pEvent16->hWSGroup));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We will process the event
|
|
//
|
|
processed = TRUE;
|
|
|
|
//
|
|
// Process the event according to the workset ID
|
|
//
|
|
switch(pEvent16->worksetID)
|
|
{
|
|
//
|
|
// Page Control Workset Lock Workset User Information Workset
|
|
//
|
|
case PAGE_CONTROL_WORKSET:
|
|
case SYNC_CONTROL_WORKSET:
|
|
case USER_INFORMATION_WORKSET:
|
|
//
|
|
// Event not expected for these worksets
|
|
//
|
|
ERROR_OUT(("Unexpected for workset %d", (UINT) pEvent16->worksetID));
|
|
break;
|
|
|
|
//
|
|
// Other (should be a Page Workset)
|
|
//
|
|
default:
|
|
wbOnGraphicObjectMoveInd(pEvent16->worksetID,
|
|
(POM_OBJECT) param2);
|
|
break;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnObjectMoveInd, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnGraphicObjectMoveInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_MOVE_IND is
|
|
// received for a graphic object.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnGraphicObjectMoveInd
|
|
(
|
|
OM_WORKSET_ID worksetID,
|
|
POM_OBJECT pObj
|
|
)
|
|
{
|
|
WB_PAGE_HANDLE hPage = (WB_PAGE_HANDLE)worksetID;
|
|
|
|
DebugEntry(wbOnGraphicObjectMoveInd);
|
|
|
|
//
|
|
// Record that the contents have changed
|
|
//
|
|
m_changed = TRUE;
|
|
|
|
//
|
|
// These events are ignored unless we are fully registered (the client
|
|
// can do nothing about them).
|
|
//
|
|
if (m_state != STATE_IDLE)
|
|
{
|
|
TRACE_OUT(("Ignoring move of graphic object before registration"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Check that this page is actually in use
|
|
//
|
|
if (GetPageState(hPage)->state != PAGE_IN_USE)
|
|
{
|
|
TRACE_OUT(("Ignoring move in page not in use"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Inform the client of the object being added
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_GRAPHIC_MOVED"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_GRAPHIC_MOVED, // Event type
|
|
hPage, // Page handle
|
|
(UINT_PTR)pObj); // Object handle
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnGraphicObjectMoveInd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnObjectDeleteInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_DELETE_IND is
|
|
// received.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnObjectDeleteInd
|
|
(
|
|
UINT_PTR param1,
|
|
POM_OBJECT pObj
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
BOOL processed = FALSE;
|
|
|
|
DebugEntry(wbOnObjectDeleteInd);
|
|
|
|
//
|
|
// Check that the workset group is ours
|
|
//
|
|
if (pEvent16->hWSGroup != m_hWSGroup)
|
|
{
|
|
ERROR_OUT(("Event for unknown workset group = %d", pEvent16->hWSGroup));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We will process the event
|
|
//
|
|
processed = TRUE;
|
|
|
|
//
|
|
// Process the event according to the workset ID
|
|
//
|
|
switch(pEvent16->worksetID)
|
|
{
|
|
//
|
|
// Page Control Workset
|
|
//
|
|
case PAGE_CONTROL_WORKSET:
|
|
wbOnPageObjectDeleteInd(pObj);
|
|
break;
|
|
|
|
//
|
|
// Sync Workset
|
|
//
|
|
case SYNC_CONTROL_WORKSET:
|
|
ERROR_OUT(("Illegal object delete on sync control workset - ignored"));
|
|
|
|
//
|
|
// We do not confirm the delete since we do not want to lose the Sync
|
|
// Control Object.
|
|
//
|
|
break;
|
|
|
|
//
|
|
// User Information Workset
|
|
//
|
|
case USER_INFORMATION_WORKSET:
|
|
wbOnUserObjectDeleteInd(pObj);
|
|
break;
|
|
|
|
//
|
|
// Other (should be a Page Workset)
|
|
//
|
|
default:
|
|
wbOnGraphicObjectDeleteInd(pEvent16->worksetID, pObj);
|
|
break;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnObjectDeleteInd, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnPageObjectDeleteInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_DELETE_IND is
|
|
// received for an object in the Page Control Workset.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnPageObjectDeleteInd(POM_OBJECT pObj)
|
|
{
|
|
UINT objectType;
|
|
|
|
DebugEntry(wbOnPageObjectDeleteInd);
|
|
|
|
//
|
|
// Get the type of object that is being deleted
|
|
//
|
|
if (wbGetPageObjectType(pObj, &objectType) != 0)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
switch(objectType)
|
|
{
|
|
case TYPE_CONTROL_PAGE_ORDER:
|
|
//
|
|
// The object is the Page Control Object - something serious is wrong
|
|
// as this object should never be deleted.
|
|
//
|
|
ERROR_OUT(("Attempt to delete page control object"));
|
|
break;
|
|
|
|
case TYPE_CONTROL_LOCK:
|
|
TRACE_OUT(("Lock object being deleted"));
|
|
wbOnLockControlObjectDeleteInd(pObj);
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad object type"));
|
|
break;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnPageObjectDeleteInd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnLockControlObjectDeleteInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_DELETE_IND is
|
|
// received for a lock object in the Page Control Workset.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnLockControlObjectDeleteInd(POM_OBJECT pObj
|
|
)
|
|
{
|
|
DebugEntry(wbOnLockControlObjectDeleteInd);
|
|
|
|
//
|
|
// Confirm the delete to ObMan
|
|
//
|
|
TRACE_OUT(("Lock handle %x, expecting %x", pObj, m_pObjLock));
|
|
if (pObj != m_pObjLock)
|
|
{
|
|
WARNING_OUT(("Unexpected lock handle %x, expecting %x",
|
|
pObj, m_pObjLock));
|
|
}
|
|
|
|
OM_ObjectDeleteConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
pObj);
|
|
m_pObjLock = NULL;
|
|
|
|
//
|
|
// Process according to the current lock state
|
|
//
|
|
switch(m_lockState)
|
|
{
|
|
case LOCK_STATE_PENDING_DELETE:
|
|
//
|
|
// We are deleting our lock object. We must unlock the
|
|
// workset.
|
|
//
|
|
TRACE_OUT(("Our lock object delete confirmed - unlocking the workset"));
|
|
OM_WorksetUnlock(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET);
|
|
break;
|
|
|
|
case LOCK_STATE_LOCKED_OUT:
|
|
//
|
|
// The user with the lock has deleted the lock object. We treat
|
|
// this as a removal of the whiteboard lock - we reset the
|
|
// state at the end of this function.
|
|
//
|
|
TRACE_OUT(("Remote user's lock object deleted"));
|
|
break;
|
|
|
|
case LOCK_STATE_EMPTY:
|
|
//
|
|
// We have just deleted the object at the end of a call to tidy
|
|
// up. Carry on so we reset lockType / pObjPersonLock etc.
|
|
//
|
|
TRACE_OUT(("LOCK_STATE_EMPTY"));
|
|
break;
|
|
|
|
case LOCK_STATE_PENDING_LOCK:
|
|
WARNING_OUT(("LOCK_STATE_PENDING_LOCK"));
|
|
//
|
|
// We don't expect to get here. If by some chance we do, then
|
|
// just quit, since we should still get the workset lock con.
|
|
//
|
|
DC_QUIT;
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad lock state %d", m_lockState));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// The lock object has been deleted, so there is no lock active
|
|
//
|
|
m_lockType = WB_LOCK_TYPE_NONE;
|
|
m_pObjPersonLock = NULL;
|
|
|
|
//
|
|
// Record that there is now no lock
|
|
//
|
|
m_lockState = LOCK_STATE_EMPTY;
|
|
TRACE_OUT(("Moved lock state to LOCK_STATE_EMPTY"));
|
|
|
|
//
|
|
// Notify the client of the lock status change
|
|
//
|
|
wbSendLockNotification();
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnLockControlObjectDeleteInd);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnGraphicObjectDeleteInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_DELETE_IND is
|
|
// received for an object in a page workset.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnGraphicObjectDeleteInd
|
|
(
|
|
OM_WORKSET_ID worksetID,
|
|
POM_OBJECT pObj
|
|
)
|
|
{
|
|
WB_PAGE_HANDLE hPage = (WB_PAGE_HANDLE)worksetID;
|
|
BOOL bConfirm = FALSE;
|
|
|
|
DebugEntry(wbOnGraphicObjectDeleteInd);
|
|
|
|
//
|
|
// Record that the contents have changed
|
|
//
|
|
m_changed = TRUE;
|
|
TRACE_OUT(("Changed flag now TRUE"));
|
|
|
|
//
|
|
// These events are handled within the core until the client is ready.
|
|
//
|
|
if (m_state != STATE_IDLE)
|
|
{
|
|
TRACE_OUT(("Delete of graphic object before registration"));
|
|
bConfirm = TRUE;
|
|
}
|
|
|
|
//
|
|
// Check that this page is actually in use
|
|
//
|
|
if (GetPageState(hPage)->state != PAGE_IN_USE)
|
|
{
|
|
TRACE_OUT(("Delete in page that is not in use"));
|
|
bConfirm = TRUE;
|
|
}
|
|
|
|
//
|
|
// Check whether we are to pass the event on to the client
|
|
//
|
|
if (bConfirm)
|
|
{
|
|
//
|
|
// Confirm the delete to ObMan
|
|
//
|
|
TRACE_OUT(("Confirming delete immediately"));
|
|
OM_ObjectDeleteConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
pObj);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Inform the client of the object being added
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_GRAPHIC_DELETE_IND"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_GRAPHIC_DELETE_IND, // Event type
|
|
hPage, // Page handle
|
|
(UINT_PTR)pObj); // Object handle
|
|
}
|
|
|
|
DebugExitVOID(wbOnGraphicObjectDeleteInd);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnUserObjectDeleteInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_DELETE_IND is
|
|
// received for an object in the User Information Workset.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnUserObjectDeleteInd
|
|
(
|
|
POM_OBJECT pObjPerson
|
|
)
|
|
{
|
|
DebugEntry(wbOnUserObjectDeleteInd);
|
|
|
|
//
|
|
// If the user which has been removed had a lock then remove its user
|
|
// handle from the client data. The lock is still there, and will be
|
|
// removed when we get the WORKSET_UNLOCK_IND for the lock workset. This
|
|
// arrives after the user-object delete, because the user workset is of
|
|
// higher priority.
|
|
//
|
|
if (m_pObjPersonLock == pObjPerson)
|
|
{
|
|
m_pObjPersonLock = NULL;
|
|
}
|
|
|
|
//
|
|
// These events are ignored unless we are fully registered (the client
|
|
// can do nothing about them).
|
|
//
|
|
if (m_state != STATE_IDLE)
|
|
{
|
|
TRACE_OUT(("Delete of user object before registration - confirming"));
|
|
|
|
//
|
|
// Confirm the delete
|
|
//
|
|
OM_ObjectDeleteConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pObjPerson);
|
|
|
|
//
|
|
// Nothing more to be done
|
|
//
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Inform the client of the user leaving
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_USER_LEFT_IND"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_PERSON_LEFT, // Event type
|
|
0, // No short parameter
|
|
(UINT_PTR) pObjPerson); // User object handle
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnUserObjectDeleteInd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnObjectUpdateInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_UPDATE_IND is
|
|
// received for an object in a page workset.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnObjectUpdateInd
|
|
(
|
|
UINT_PTR param1,
|
|
POM_OBJECT pObj
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent16 = (POM_EVENT_DATA16) ¶m1;
|
|
BOOL processed = FALSE;
|
|
|
|
DebugEntry(wbOnObjectUpdateInd);
|
|
|
|
//
|
|
// Check that the workset group is ours
|
|
//
|
|
if (pEvent16->hWSGroup != m_hWSGroup)
|
|
{
|
|
ERROR_OUT(("Event for unknown workset group = %d", pEvent16->hWSGroup));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We will process the event
|
|
//
|
|
processed = TRUE;
|
|
|
|
//
|
|
// Process the event according to the workset ID
|
|
//
|
|
switch(pEvent16->worksetID)
|
|
{
|
|
//
|
|
// Page Control Workset
|
|
//
|
|
case PAGE_CONTROL_WORKSET:
|
|
ERROR_OUT(("Illegal object update on page control workset - ignored"));
|
|
|
|
//
|
|
// Updates on the Page Control Object are not allowed - do not
|
|
// confirm it.
|
|
//
|
|
break;
|
|
|
|
//
|
|
// Lock Workset
|
|
//
|
|
case SYNC_CONTROL_WORKSET:
|
|
ERROR_OUT(("Illegal object update on sync control workset"));
|
|
|
|
//
|
|
// Updates to the Sync Control Object itself are not allowed - do not
|
|
// confirm it.
|
|
//
|
|
break;
|
|
|
|
//
|
|
// User Information Workset
|
|
//
|
|
case USER_INFORMATION_WORKSET:
|
|
wbOnUserObjectUpdateInd(pObj);
|
|
break;
|
|
|
|
//
|
|
// Other (should be a Page Workset)
|
|
//
|
|
default:
|
|
wbOnGraphicObjectUpdateInd(pEvent16->worksetID, pObj);
|
|
break;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnObjectUpdateInd, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnUserObjectUpdateInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_UPDATE_IND is
|
|
// received for an object in the User Information Workset.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnUserObjectUpdateInd(POM_OBJECT pObj)
|
|
{
|
|
DebugEntry(wbOnUserObjectUpdateInd);
|
|
|
|
//
|
|
// if the updated user object is not the local user's, and we have
|
|
// already added the local user's object, then check the color hasn't
|
|
// changed to clash with the local user's color.
|
|
//
|
|
if ( (m_pObjLocal != pObj)
|
|
&& (m_pObjLocal != NULL))
|
|
{
|
|
TRACE_OUT(("Check color of updated user object"));
|
|
wbCheckPersonColor(pObj);
|
|
}
|
|
|
|
//
|
|
// Don't inform the front end if we aren't fully registered
|
|
//
|
|
if (m_state != STATE_IDLE)
|
|
{
|
|
TRACE_OUT(("User object updated before registration - confirming"));
|
|
|
|
//
|
|
// Confirm the update immediately
|
|
//
|
|
OM_ObjectUpdateConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pObj);
|
|
|
|
//
|
|
// Nothing more to be done
|
|
//
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Tell the client that a user has been updated
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_PERSON_UPDATE_IND"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_PERSON_UPDATE, // Event type
|
|
0, // No short parameter
|
|
(UINT_PTR) pObj); // User object handle
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnUserObjectUpdateInd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnUserObjectReplaceInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_REPLACE_IND is
|
|
// received for an object in the User Information Workset.
|
|
//
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnUserObjectReplaceInd(POM_OBJECT pObj)
|
|
{
|
|
DebugEntry(wbOnUserObjectReplaceInd);
|
|
|
|
//
|
|
// if the updated user object is not the local user's, and we have
|
|
// already added the local user's object, then check the color hasn't
|
|
// changed to clash with the local user's color.
|
|
//
|
|
if ( (m_pObjLocal != pObj)
|
|
&& (m_pObjLocal != NULL))
|
|
{
|
|
TRACE_OUT(("Check color of updated user object"));
|
|
wbCheckPersonColor(pObj);
|
|
}
|
|
|
|
//
|
|
// Don't inform the front end if we aren't fully registered
|
|
//
|
|
if (m_state != STATE_IDLE)
|
|
{
|
|
TRACE_OUT(("User object replaced before registration - confirming"));
|
|
|
|
//
|
|
// Confirm the replace immediately
|
|
//
|
|
OM_ObjectReplaceConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pObj);
|
|
|
|
//
|
|
// Nothing more to be done
|
|
//
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Tell the client that a user has been updated
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_PERSON_UPDATE_IND"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_PERSON_REPLACE, // Event type
|
|
0, // No short parameter
|
|
(UINT_PTR) pObj); // User object handle
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnUserObjectReplaceInd);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnGraphicObjectUpdateInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_UPDATE_IND is
|
|
// received for an object in a page workset.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnGraphicObjectUpdateInd
|
|
(
|
|
OM_WORKSET_ID worksetID,
|
|
POM_OBJECT pObj
|
|
)
|
|
{
|
|
WB_PAGE_HANDLE hPage = (WB_PAGE_HANDLE)worksetID;
|
|
BOOL bConfirm = FALSE;
|
|
|
|
DebugEntry(wbOnGraphicObjectUpdateInd);
|
|
|
|
//
|
|
// Record that the contents have changed
|
|
//
|
|
m_changed = TRUE;
|
|
TRACE_OUT(("Changed flag now TRUE"));
|
|
|
|
//
|
|
// These events are handled within the core until the client is ready.
|
|
//
|
|
if (m_state != STATE_IDLE)
|
|
{
|
|
TRACE_OUT(("Update of graphic object before registration"));
|
|
bConfirm = TRUE;
|
|
}
|
|
|
|
//
|
|
// Check that this page is actually in use
|
|
//
|
|
if (GetPageState(hPage)->state != PAGE_IN_USE)
|
|
{
|
|
TRACE_OUT(("Update for page that is not in use"));
|
|
bConfirm = TRUE;
|
|
}
|
|
|
|
//
|
|
// Check whether we are to confirm the update now or ask the client
|
|
//
|
|
if (bConfirm)
|
|
{
|
|
//
|
|
// Confirm the update immediately
|
|
//
|
|
TRACE_OUT(("Confirming update immediately"));
|
|
OM_ObjectUpdateConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
pObj);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Inform the client of the object being added
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_GRAPHIC_UPDATE_IND"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_GRAPHIC_UPDATE_IND, // Event type
|
|
hPage, // Page handle
|
|
(UINT_PTR)pObj); // Object handle
|
|
}
|
|
|
|
DebugExitVOID(wbOnGraphicObjectUpdateInd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnObjectReplaceInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_REPLACE_IND is
|
|
// received.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnObjectReplaceInd
|
|
(
|
|
UINT_PTR param1,
|
|
POM_OBJECT pObj
|
|
)
|
|
{
|
|
POM_EVENT_DATA16 pEvent = (POM_EVENT_DATA16) ¶m1;
|
|
BOOL processed = FALSE;
|
|
|
|
DebugEntry(wbOnObjectReplaceInd);
|
|
|
|
//
|
|
// Check that the workset group is ours
|
|
//
|
|
if (pEvent->hWSGroup != m_hWSGroup)
|
|
{
|
|
ERROR_OUT(("Event for unknown workset group = %d", pEvent->hWSGroup));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We will process the event
|
|
//
|
|
processed = TRUE;
|
|
|
|
//
|
|
// Process the event according to the workset ID
|
|
//
|
|
switch (pEvent->worksetID)
|
|
{
|
|
//
|
|
// Page Control Workset
|
|
//
|
|
case PAGE_CONTROL_WORKSET:
|
|
wbOnPageObjectReplaceInd(pObj);
|
|
break;
|
|
|
|
//
|
|
// Lock Workset
|
|
//
|
|
case SYNC_CONTROL_WORKSET:
|
|
wbOnSyncObjectReplaceInd(pObj);
|
|
break;
|
|
|
|
//
|
|
// User Information Workset
|
|
//
|
|
case USER_INFORMATION_WORKSET:
|
|
wbOnUserObjectReplaceInd(pObj);
|
|
break;
|
|
|
|
//
|
|
// Other (should be a Page Workset)
|
|
//
|
|
default:
|
|
wbOnGraphicObjectReplaceInd(pEvent->worksetID, pObj);
|
|
break;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnObjectReplaceInd, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnPageObjectReplaceInd
|
|
//
|
|
// Purpose: This routine is called whenever the Page Control object is
|
|
// replaced.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnPageObjectReplaceInd(POM_OBJECT pObj)
|
|
{
|
|
UINT objectType;
|
|
|
|
DebugEntry(wbOnPageObjectReplaceInd);
|
|
|
|
//
|
|
// Confirm the change to ObMan (cannot fail)
|
|
//
|
|
OM_ObjectReplaceConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
pObj);
|
|
|
|
//
|
|
// Read the object to get its type
|
|
//
|
|
if (wbGetPageObjectType(pObj, &objectType) != 0)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Act according to the type of object added
|
|
//
|
|
switch (objectType)
|
|
{
|
|
case TYPE_CONTROL_LOCK:
|
|
wbReadLock();
|
|
break;
|
|
|
|
case TYPE_CONTROL_PAGE_ORDER:
|
|
wbOnPageControlObjectReplaceInd();
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Unknown object type added to Page Control Workset"));
|
|
break;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnPageObjectReplaceInd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnPageControlObjectReplaceInd
|
|
//
|
|
// Purpose: This routine is called whenever the Page Control object is
|
|
// replaced.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnPageControlObjectReplaceInd(void)
|
|
{
|
|
DebugEntry(wbOnPageControlObjectReplaceInd);
|
|
|
|
//
|
|
// Process according to the current state
|
|
//
|
|
switch (m_state)
|
|
{
|
|
case STATE_REGISTERING:
|
|
//
|
|
// During registration we do nothing - the Page Order is updated
|
|
// explicitly as one of the last registration actions.
|
|
//
|
|
break;
|
|
|
|
case STATE_IDLE:
|
|
//
|
|
// When we are fully registered we must send events to the front-end
|
|
// indicating what changes have been made to the page list.
|
|
//
|
|
wbProcessPageControlChanges();
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad client major state"));
|
|
break;
|
|
}
|
|
|
|
DebugExitVOID(wbOnPageControlObjectReplaceInd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbProcessPageControlChanges
|
|
//
|
|
// Purpose: This routine is called whenever the Page Control object is
|
|
// replaced in idle state. It reads the new Page Control data
|
|
// and starts the process of informing the client of any changes.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbProcessPageControlChanges(void)
|
|
{
|
|
BYTE toBeMarked[WB_MAX_PAGES];
|
|
UINT indexExternal;
|
|
UINT indexInternal;
|
|
UINT lLengthExternal;
|
|
BOOL addOutstanding = TRUE;
|
|
PWB_PAGE_ORDER pPageOrderExternal;
|
|
PWB_PAGE_ORDER pPageOrderInternal = &(m_pageOrder);
|
|
PWB_PAGE_STATE pPageState;
|
|
POM_WORKSET_ID pPageExternal;
|
|
UINT countPagesExternal;
|
|
POM_OBJECTDATA pData = NULL;
|
|
|
|
DebugEntry(wbProcessPageControlChanges);
|
|
|
|
//
|
|
// Read the new Page Control Object
|
|
//
|
|
if (OM_ObjectRead(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
m_pObjPageControl,
|
|
&pData) != 0)
|
|
{
|
|
ERROR_OUT(("Error reading Page Control Object"));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Extract details from the external page order
|
|
//
|
|
lLengthExternal = pData->length;
|
|
pPageOrderExternal = (PWB_PAGE_ORDER) pData->data;
|
|
pPageExternal = pPageOrderExternal->pages;
|
|
countPagesExternal = pPageOrderExternal->countPages;
|
|
|
|
//
|
|
// Process existing and newly added pages
|
|
//
|
|
for (indexExternal = 0; indexExternal < countPagesExternal; indexExternal++)
|
|
{
|
|
//
|
|
// Convert the index into the Page Control Object to an index into the
|
|
// internal Page List.
|
|
//
|
|
indexInternal = PAGE_WORKSET_ID_TO_INDEX(pPageExternal[indexExternal]);
|
|
|
|
//
|
|
// Test and update the internal page state as necessary
|
|
//
|
|
pPageState = &((m_pageStates)[indexInternal]);
|
|
|
|
//
|
|
// If the page is in use locally then we do not need to do anything
|
|
// (the external and internal page lists agree already).
|
|
//
|
|
if (pPageState->state != PAGE_IN_USE)
|
|
{
|
|
switch (pPageState->subState)
|
|
{
|
|
case PAGE_STATE_EMPTY:
|
|
//
|
|
// The page does not yet have a workset open for it - open one
|
|
// now. (But only open one per call to this routine to prevent
|
|
// swamping the message queue. The other outstanding opens will
|
|
// be done when this routine is next called).
|
|
//
|
|
wbPageWorksetOpen(PAGE_INDEX_TO_HANDLE(indexInternal),
|
|
OPEN_EXTERNAL);
|
|
|
|
//
|
|
// Leave now - this routine will be called again when the open
|
|
// confirm is received for the workset just opened.
|
|
//
|
|
DC_QUIT;
|
|
break;
|
|
|
|
case PAGE_STATE_LOCAL_OPEN_CONFIRM:
|
|
case PAGE_STATE_EXTERNAL_OPEN_CONFIRM:
|
|
case PAGE_STATE_EXTERNAL_ADD:
|
|
//
|
|
// Do nothing - the page is already in the add process
|
|
//
|
|
TRACE_OUT(("Page %d is already pending local add",
|
|
PAGE_INDEX_TO_HANDLE(indexInternal)));
|
|
break;
|
|
|
|
case PAGE_STATE_READY:
|
|
//
|
|
// The page workset has been opened previously - we can just mark
|
|
// the page as being in use immediately.
|
|
//
|
|
pPageState->state = PAGE_IN_USE;
|
|
pPageState->subState = PAGE_STATE_EMPTY;
|
|
TRACE_OUT(("Moved page %d state to PAGE_IN_USE",
|
|
(UINT) PAGE_INDEX_TO_HANDLE(indexInternal) ));
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad page substate %d", pPageState->subState));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Mark any pages that no longer appear in the Page Control Object as
|
|
// "delete pending" (unless they are already marked).
|
|
//
|
|
|
|
FillMemory(toBeMarked, sizeof(toBeMarked), TRUE);
|
|
|
|
//
|
|
// Flag which pages should be marked
|
|
//
|
|
for (indexExternal = 0; indexExternal < countPagesExternal; indexExternal++)
|
|
{
|
|
toBeMarked[PAGE_WORKSET_ID_TO_INDEX(pPageExternal[indexExternal])] = 0;
|
|
}
|
|
|
|
//
|
|
// Mark them
|
|
//
|
|
for (indexInternal = 0; indexInternal < WB_MAX_PAGES; indexInternal++)
|
|
{
|
|
pPageState = &((m_pageStates)[indexInternal]);
|
|
|
|
if ( (toBeMarked[indexInternal] == 1)
|
|
&& (pPageState->state == PAGE_IN_USE))
|
|
{
|
|
switch (pPageState->subState)
|
|
{
|
|
case PAGE_STATE_EMPTY:
|
|
//
|
|
// Ask the client for confirmation of the delete
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_PAGE_DELETE_IND"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_PAGE_DELETE_IND, // Page being deleted
|
|
PAGE_INDEX_TO_HANDLE(indexInternal), // Page handle
|
|
0);
|
|
|
|
//
|
|
// Update the page state
|
|
//
|
|
pPageState->subState = PAGE_STATE_EXTERNAL_DELETE_CONFIRM;
|
|
TRACE_OUT(("Moved page %d substate to PAGE_STATE_EXTERNAL_DELETE_CONFIRM",
|
|
(UINT) PAGE_INDEX_TO_HANDLE(indexInternal) ));
|
|
|
|
//
|
|
// Leave now - this routine will be called again when the delete
|
|
// confirm is received for this workset.
|
|
//
|
|
DC_QUIT;
|
|
break;
|
|
|
|
case PAGE_STATE_LOCAL_DELETE:
|
|
//
|
|
// Ask the client for confirmation of the delete
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_PAGE_DELETE_IND"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_PAGE_DELETE_IND, // Page being deleted
|
|
PAGE_INDEX_TO_HANDLE(indexInternal), // Page handle
|
|
0);
|
|
|
|
//
|
|
// Update the page state
|
|
//
|
|
pPageState->subState = PAGE_STATE_LOCAL_DELETE_CONFIRM;
|
|
TRACE_OUT(("Moved page %d substate to PAGE_STATE_LOCAL_DELETE_CONFIRM",
|
|
(UINT) PAGE_INDEX_TO_HANDLE(indexInternal) ));
|
|
|
|
//
|
|
// Leave now - this routine will be called again when the delete
|
|
// confirm is received for this workset.
|
|
//
|
|
DC_QUIT;
|
|
break;
|
|
|
|
case PAGE_STATE_EXTERNAL_DELETE:
|
|
case PAGE_STATE_EXTERNAL_DELETE_CONFIRM:
|
|
case PAGE_STATE_LOCAL_DELETE_CONFIRM:
|
|
//
|
|
// We are already expecting a delete for this page
|
|
//
|
|
TRACE_OUT(("Page %d is already pending local delete",
|
|
PAGE_INDEX_TO_HANDLE(indexInternal)));
|
|
DC_QUIT;
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad page substate %d", pPageState->subState));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// There are no deletes or adds outstanding now
|
|
//
|
|
|
|
//
|
|
// Copy the new page order to the internal page list
|
|
//
|
|
memcpy(pPageOrderInternal, pPageOrderExternal, lLengthExternal);
|
|
|
|
//
|
|
// Inform the client of the change
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_PAGE_ORDER_UPDATED"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_PAGE_ORDER_UPDATED, // Event number
|
|
0, // No parameters
|
|
0);
|
|
|
|
//
|
|
// Check the number of pages ready in the cache
|
|
//
|
|
wbCheckReadyPages();
|
|
|
|
DC_EXIT_POINT:
|
|
//
|
|
// Release the Page Control Object
|
|
//
|
|
if (pData != NULL)
|
|
{
|
|
OM_ObjectRelease(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
m_pObjPageControl,
|
|
&pData);
|
|
}
|
|
|
|
DebugExitVOID(wbProcessPageControlChanges);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnSyncObjectReplaceInd
|
|
//
|
|
// Purpose: This routine is called whenever the Sync Control object is
|
|
// replaced.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnSyncObjectReplaceInd(POM_OBJECT pObj)
|
|
{
|
|
POM_OBJECTDATA pSyncObject;
|
|
PWB_SYNC_CONTROL pSyncControl;
|
|
OM_OBJECT_ID syncPersonID;
|
|
|
|
DebugEntry(wbOnSyncControlReplaced);
|
|
|
|
//
|
|
// Confirm the replace of the object
|
|
//
|
|
OM_ObjectReplaceConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
SYNC_CONTROL_WORKSET,
|
|
pObj);
|
|
|
|
//
|
|
// Read the object and determine whether it was written by this client or
|
|
// another.
|
|
//
|
|
if (OM_ObjectRead(m_pomClient,
|
|
m_hWSGroup,
|
|
SYNC_CONTROL_WORKSET,
|
|
m_pObjSyncControl,
|
|
&pSyncObject) != 0)
|
|
{
|
|
ERROR_OUT(("Error reading Sync Control Object"));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
pSyncControl = (PWB_SYNC_CONTROL) pSyncObject->data;
|
|
|
|
//
|
|
// Get the user ID from the object
|
|
//
|
|
syncPersonID = pSyncControl->personID;
|
|
|
|
//
|
|
// Release the Sync Control Object
|
|
//
|
|
OM_ObjectRelease(m_pomClient,
|
|
m_hWSGroup,
|
|
SYNC_CONTROL_WORKSET,
|
|
m_pObjSyncControl,
|
|
&pSyncObject);
|
|
pSyncControl = NULL;
|
|
|
|
//
|
|
// If the user ID in the object is not the ID of the current client, we
|
|
// must post a message to the front-end.
|
|
//
|
|
if (memcmp(&syncPersonID,
|
|
&(m_personID),
|
|
sizeof(syncPersonID)) != 0)
|
|
{
|
|
//
|
|
// Post a "sync position updated" event to the front-end
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_SYNC_POSITION_UPDATED"));
|
|
WBP_PostEvent(
|
|
0,
|
|
WBP_EVENT_SYNC_POSITION_UPDATED,
|
|
0,
|
|
0);
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbOnSyncControlReplaced);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnGraphicObjectReplaceInd
|
|
//
|
|
// Purpose: This routine is called whenever an OM_OBJECT_REPLACE_IND is
|
|
// received for an object in a page workset.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbOnGraphicObjectReplaceInd
|
|
(
|
|
OM_WORKSET_ID worksetID,
|
|
POM_OBJECT pObj
|
|
)
|
|
{
|
|
WB_PAGE_HANDLE hPage = (WB_PAGE_HANDLE)worksetID;
|
|
BOOL bConfirm = FALSE;
|
|
|
|
DebugEntry(wbOnGraphicObjectReplaceInd);
|
|
|
|
//
|
|
// Record that the contents have changed
|
|
//
|
|
m_changed = TRUE;
|
|
TRACE_OUT(("Changed flag now TRUE"));
|
|
|
|
//
|
|
// These events are handled within the core until the client is ready.
|
|
//
|
|
if (m_state != STATE_IDLE)
|
|
{
|
|
TRACE_OUT(("Replace of graphic object before registration"));
|
|
bConfirm = TRUE;
|
|
}
|
|
|
|
//
|
|
// Check that this page is actually in use
|
|
//
|
|
if (GetPageState(hPage)->state != PAGE_IN_USE)
|
|
{
|
|
TRACE_OUT(("Replace in page that is not in use"));
|
|
bConfirm = TRUE;
|
|
}
|
|
|
|
//
|
|
// Check whether we are to pass the replace on to the client
|
|
//
|
|
if (bConfirm)
|
|
{
|
|
//
|
|
// Confirm the change to ObMan (cannot fail)
|
|
//
|
|
TRACE_OUT(("Confirming replace immediately"));
|
|
OM_ObjectReplaceConfirm(m_pomClient,
|
|
m_hWSGroup,
|
|
worksetID,
|
|
pObj);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Inform the client of the object being added
|
|
//
|
|
TRACE_OUT(("Posting WBP_EVENT_GRAPHIC_REPLACE_IND"));
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_GRAPHIC_REPLACE_IND, // Event type
|
|
hPage, // Page handle
|
|
(UINT_PTR)pObj); // Object handle
|
|
}
|
|
|
|
|
|
DebugExitVOID(wbOnGraphicObjectReplaceInd);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbWritePageControl
|
|
//
|
|
// Purpose: Write the page control information to the Page Control Workset
|
|
// from the copy held in client data. We write only those pages
|
|
// which are marked as being in use (and are not pending delete).
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbWritePageControl(BOOL create)
|
|
{
|
|
UINT result = 0;
|
|
UINT rc;
|
|
UINT index;
|
|
UINT length;
|
|
PWB_PAGE_ORDER pPageOrderInternal = &(m_pageOrder);
|
|
PWB_PAGE_ORDER pPageOrderExternal;
|
|
WB_PAGE_HANDLE hPage;
|
|
PWB_PAGE_STATE pPageState;
|
|
POM_OBJECT pObj;
|
|
POM_OBJECTDATA pData = NULL;
|
|
UINT generation;
|
|
|
|
DebugEntry(wbWritePageControl);
|
|
|
|
//
|
|
// Allocate memory for the object.
|
|
//
|
|
length = sizeof(WB_PAGE_ORDER)
|
|
- ( (WB_MAX_PAGES - pPageOrderInternal->countPages)
|
|
* sizeof(OM_WORKSET_ID));
|
|
|
|
if (OM_ObjectAlloc(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
length,
|
|
&pData) != 0)
|
|
{
|
|
ERROR_OUT(("Error allocating object"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
pData->length = length;
|
|
|
|
//
|
|
// Get a pointer to the page control object itself
|
|
//
|
|
pPageOrderExternal = (PWB_PAGE_ORDER) pData->data;
|
|
|
|
//
|
|
// Set the object type
|
|
//
|
|
pPageOrderExternal->objectType = TYPE_CONTROL_PAGE_ORDER;
|
|
|
|
//
|
|
// Increment the page list generation number indicating that we have
|
|
// written a new version of the page list.
|
|
//
|
|
generation = MAKELONG(pPageOrderInternal->generationLo,
|
|
pPageOrderInternal->generationHi);
|
|
generation++;
|
|
pPageOrderInternal->generationLo = LOWORD(generation);
|
|
pPageOrderInternal->generationHi = HIWORD(generation);
|
|
|
|
//
|
|
// Copy the page control data
|
|
//
|
|
pPageOrderExternal->objectType = TYPE_CONTROL_PAGE_ORDER;
|
|
pPageOrderExternal->generationLo = pPageOrderInternal->generationLo;
|
|
pPageOrderExternal->generationHi = pPageOrderInternal->generationHi;
|
|
pPageOrderExternal->countPages = 0;
|
|
|
|
//
|
|
// Loop through the internal page order finding the pages that are in
|
|
// use.
|
|
//
|
|
for (index = 0; index < pPageOrderInternal->countPages; index++)
|
|
{
|
|
//
|
|
// Get the handle of the next page
|
|
//
|
|
hPage = (pPageOrderInternal->pages)[index];
|
|
|
|
//
|
|
// Check the page state
|
|
//
|
|
pPageState = GetPageState(hPage);
|
|
if ( (pPageState->state == PAGE_IN_USE)
|
|
&& (pPageState->subState == PAGE_STATE_EMPTY))
|
|
{
|
|
//
|
|
// Add the page to the external list
|
|
//
|
|
(pPageOrderExternal->pages)[pPageOrderExternal->countPages] = hPage;
|
|
pPageOrderExternal->countPages++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We expect always to copy at least one page
|
|
//
|
|
ASSERT((pPageOrderExternal->countPages >= 1));
|
|
|
|
//
|
|
// Check whether we are creating or replacing the object
|
|
//
|
|
if (create)
|
|
{
|
|
//
|
|
// Add the object to the workset (we never update these objects, so the
|
|
// update length is set to 0).
|
|
//
|
|
rc = OM_ObjectAdd(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
&pData,
|
|
0,
|
|
&pObj,
|
|
LAST);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Replace the existing object
|
|
//
|
|
TRACE_OUT(("Replacing Page Control Object"));
|
|
rc = OM_ObjectReplace(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
m_pObjPageControl,
|
|
&pData);
|
|
}
|
|
|
|
if (rc != 0)
|
|
{
|
|
//
|
|
// Discard the object - it was not used to replace the existing one
|
|
//
|
|
TRACE_OUT(("Adding Page Control Object"));
|
|
OM_ObjectDiscard(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
&pData);
|
|
|
|
ERROR_OUT(("Error adding/replacing page control object"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbWritePageControl, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbCreateSyncControl
|
|
//
|
|
// Purpose: Create the sync control object
|
|
//
|
|
// Returns: None
|
|
//
|
|
//
|
|
UINT WbClient::wbCreateSyncControl(void)
|
|
{
|
|
UINT result;
|
|
WB_SYNC sync;
|
|
|
|
DebugEntry(wbCreateSyncControl);
|
|
|
|
//
|
|
// Set the sync information to no page, empty rectangle
|
|
//
|
|
ZeroMemory(&sync, sizeof(WB_SYNC));
|
|
sync.length = WB_SYNC_SIZE;
|
|
sync.currentPage = WB_PAGE_HANDLE_NULL;
|
|
|
|
//
|
|
// Write the object
|
|
//
|
|
result = wbWriteSyncControl(&sync, TRUE);
|
|
|
|
DebugExitDWORD(wbCreateSyncControl, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbWriteSyncControl
|
|
//
|
|
// Purpose: Write the Sync Control object to the Page Control Workset
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbWriteSyncControl
|
|
(
|
|
PWB_SYNC pSync,
|
|
BOOL create
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
UINT rc;
|
|
POM_OBJECT pObj;
|
|
POM_OBJECTDATA pData = NULL;
|
|
PWB_SYNC_CONTROL pSyncControl;
|
|
|
|
DebugEntry(wbWriteSyncControl);
|
|
|
|
//
|
|
// Allocate memory for the object.
|
|
//
|
|
rc = OM_ObjectAlloc(m_pomClient,
|
|
m_hWSGroup,
|
|
SYNC_CONTROL_WORKSET,
|
|
WB_SYNC_CONTROL_SIZE,
|
|
&pData);
|
|
if (rc != 0)
|
|
{
|
|
ERROR_OUT(("Error allocating object"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
pData->length = WB_SYNC_CONTROL_SIZE;
|
|
|
|
//
|
|
// Copy the sync control data from the client information
|
|
//
|
|
pSyncControl = (PWB_SYNC_CONTROL) pData->data;
|
|
pSyncControl->personID = m_personID;
|
|
memcpy(&(pSyncControl->sync), pSync, WB_SYNC_SIZE);
|
|
|
|
//
|
|
// Check whether we are creating or replacing the object
|
|
//
|
|
if (create)
|
|
{
|
|
//
|
|
// Add the object to the workset
|
|
//
|
|
rc = OM_ObjectAdd(m_pomClient,
|
|
m_hWSGroup,
|
|
SYNC_CONTROL_WORKSET,
|
|
&pData,
|
|
WB_SYNC_CONTROL_SIZE,
|
|
&pObj,
|
|
LAST);
|
|
|
|
//
|
|
// If successful
|
|
//
|
|
if (rc == 0)
|
|
{
|
|
//
|
|
// Save the handle of the sync control object
|
|
//
|
|
m_pObjSyncControl = pObj;
|
|
|
|
//
|
|
// Make sure we do not discard the object below
|
|
//
|
|
pData = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Replace the existing object
|
|
//
|
|
rc = OM_ObjectReplace(m_pomClient,
|
|
m_hWSGroup,
|
|
SYNC_CONTROL_WORKSET,
|
|
m_pObjSyncControl,
|
|
&pData);
|
|
|
|
//
|
|
// Make sure we do not discard the object below
|
|
//
|
|
pData = NULL;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
//
|
|
// If we still have the Sync Control object - discard it
|
|
//
|
|
if (pData != NULL)
|
|
{
|
|
//
|
|
// Discard the object - it was not used to replace the existing one
|
|
//
|
|
OM_ObjectDiscard(m_pomClient,
|
|
m_hWSGroup,
|
|
SYNC_CONTROL_WORKSET,
|
|
&pData);
|
|
}
|
|
|
|
//
|
|
// If an error occurred during processing - report it
|
|
//
|
|
if (rc != 0)
|
|
{
|
|
ERROR_OUT(("Error adding/replacing sync control object"));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
DebugExitDWORD(wbWriteSyncControl, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbSelectPersonColor
|
|
//
|
|
// Purpose: Select a color identifier for the local user
|
|
//
|
|
// Returns: Selected color
|
|
//
|
|
//
|
|
UINT WbClient::wbSelectPersonColor(void)
|
|
{
|
|
UINT count = 0;
|
|
UINT result;
|
|
POM_OBJECT pObjUser;
|
|
|
|
DebugEntry(wbSelectPersonColor);
|
|
|
|
//
|
|
// Select the color according to the order in the workset. See comments
|
|
// in wbCheckPersonColor for further details.
|
|
//
|
|
|
|
//
|
|
// start at the first object, search for the position of the local user's
|
|
// user object.
|
|
//
|
|
result = OM_ObjectH(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
0,
|
|
&pObjUser,
|
|
FIRST);
|
|
while ((result == 0) && (pObjUser != m_pObjLocal))
|
|
{
|
|
count++;
|
|
result = OM_ObjectH(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pObjUser,
|
|
&pObjUser,
|
|
AFTER);
|
|
|
|
}
|
|
|
|
if ((result != 0) && (result != OM_RC_NO_SUCH_OBJECT))
|
|
{
|
|
ERROR_OUT(("Unexpected return code from ObMan"));
|
|
}
|
|
|
|
DebugExitDWORD(wbSelectPersonColor, count);
|
|
return (count);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbCheckPersonColor
|
|
//
|
|
// Purpose: Check whether a new user has usurped our color. If so we must
|
|
// update our own color.
|
|
//
|
|
// Returns: None
|
|
//
|
|
//
|
|
void WbClient::wbCheckPersonColor
|
|
(
|
|
POM_OBJECT hCheckObject
|
|
)
|
|
{
|
|
POM_OBJECTDATA pCheckObject = NULL;
|
|
PWB_PERSON pUser;
|
|
WB_PERSON user;
|
|
|
|
DebugEntry(wbCheckPersonColor);
|
|
|
|
//
|
|
// Read the new user information
|
|
//
|
|
if (OM_ObjectRead(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
hCheckObject,
|
|
&pCheckObject) != 0)
|
|
{
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
pUser = (PWB_PERSON) pCheckObject->data;
|
|
|
|
//
|
|
// Compare the color identifier in the new user with that of the local
|
|
// user, if they are different there is nothing to do.
|
|
//
|
|
if (pUser->colorId == m_colorId)
|
|
{
|
|
TRACE_OUT(("New user has same color as local user = %d", pUser->colorId));
|
|
|
|
//
|
|
// The user color is determined by the order in the workset group of
|
|
// the user objects. The first user has color 0, the second color 1
|
|
// etc.
|
|
//
|
|
// When a user leaves the workset, however, the colors do not change.
|
|
//
|
|
// When a new user joins, it sets its color to its new position, and
|
|
// the others will then be forced to change accordingly. Whenever an
|
|
// object add or update is received where the new remote user color
|
|
// clashes with the local one, it is always the local user's job to
|
|
// change color, since the remote user has selected his new color
|
|
// according to his current position in the workset. The local user
|
|
// can't have the same position (since two users have two distinct user
|
|
// objects, so therefore must have the wrong color.
|
|
//
|
|
|
|
//
|
|
// Get the user object for the local user
|
|
//
|
|
if (wbPersonGet(m_pObjLocal, &user) != 0)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Update the color
|
|
//
|
|
TRACE_OUT(("Old color ID for local user is %d", user.colorId));
|
|
user.colorId = (TSHR_UINT16)wbSelectPersonColor();
|
|
TRACE_OUT(("New color ID for local user is %d", user.colorId));
|
|
|
|
//
|
|
// Copy the person's color into the client's data
|
|
//
|
|
m_colorId = user.colorId;
|
|
|
|
//
|
|
// Write the new user information back
|
|
//
|
|
if (wbPersonUpdate(&user) != 0)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
|
|
//
|
|
// If an object has been read, release it now
|
|
//
|
|
if (pCheckObject != NULL)
|
|
{
|
|
OM_ObjectRelease(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
hCheckObject,
|
|
&pCheckObject);
|
|
}
|
|
|
|
DebugExitVOID(wbCheckPersonColor);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbWriteLock
|
|
//
|
|
// Purpose: Add a lock object to the Page Control Workset
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbWriteLock(void)
|
|
{
|
|
UINT result;
|
|
POM_OBJECTDATA pData;
|
|
PWB_LOCK pLock;
|
|
POM_OBJECT pObj;
|
|
|
|
DebugEntry(wbWriteLock);
|
|
|
|
//
|
|
// Create a lock object
|
|
//
|
|
result = OM_ObjectAlloc(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
sizeof(WB_LOCK),
|
|
&pData);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("Unable to allocate lock object = %d", result));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
pData->length = sizeof(WB_LOCK);
|
|
|
|
//
|
|
// Set the lock object fields
|
|
//
|
|
pLock = (PWB_LOCK) pData->data;
|
|
pLock->objectType = TYPE_CONTROL_LOCK;
|
|
pLock->personID = m_personID;
|
|
pLock->lockType = m_lockRequestType;
|
|
|
|
//
|
|
// If we already have the lock, then we can just replace the object
|
|
//
|
|
if (m_pObjLock == NULL)
|
|
{
|
|
//
|
|
// Add the lock object to the Workset. The Add indication received
|
|
// by the remote users signals the presence of the lock to them.
|
|
//
|
|
result = OM_ObjectAdd(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
&pData,
|
|
sizeof(WB_LOCK),
|
|
&pObj,
|
|
LAST);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Replace the existing object
|
|
//
|
|
result = OM_ObjectReplace(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
m_pObjLock,
|
|
&pData);
|
|
}
|
|
|
|
if (result != 0)
|
|
{
|
|
//
|
|
// The add or replace failed, we must discard the object
|
|
//
|
|
OM_ObjectDiscard(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
&pData);
|
|
|
|
ERROR_OUT(("Error adding user object"));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Save the handle of the lock object
|
|
//
|
|
TRACE_OUT(("Lock handle was %x, now %x", m_pObjLock, pObj));
|
|
m_pObjLock = pObj;
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbWriteLock, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbReadLock
|
|
//
|
|
// Purpose: Update the lock information stored in the client data after a
|
|
// change in the Lock Object.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbReadLock(void)
|
|
{
|
|
UINT count = 0;
|
|
|
|
DebugEntry(wbReadLock);
|
|
|
|
//
|
|
// Before we read the lock information we need to ensure that the
|
|
// PAGE_CONTROL_WORKSET and the USER_INFORMATION_WORKSET both contain
|
|
// the objects we need. If either of the objects are missing, quit and
|
|
// wait until we are called again - this function will be called
|
|
// whenever new objects are added to these worksets.
|
|
//
|
|
OM_WorksetCountObjects(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
&count);
|
|
TRACE_OUT(("%d objects in USER_INFORMATION_WORKSET", count));
|
|
if (count == 0)
|
|
{
|
|
TRACE_OUT(("Need to wait for USER_INFO object"));
|
|
DC_QUIT;
|
|
}
|
|
OM_WorksetCountObjects(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
&count);
|
|
TRACE_OUT(("%d objects in PAGE_CONTROL_WORKSET", count));
|
|
if (count == 0)
|
|
{
|
|
TRACE_OUT(("Need to wait for PAGE_CONTROL object"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
TRACE_OUT(("Process lock"));
|
|
wbProcessLockNotification();
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbReadLock);
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbProcessLockNotification
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbProcessLockNotification(void)
|
|
{
|
|
UINT rc = 0;
|
|
POM_OBJECTDATA pData;
|
|
PWB_LOCK pLock;
|
|
WB_LOCK_TYPE lockType;
|
|
POM_OBJECT pObjPersonLock;
|
|
POM_OBJECT pObj;
|
|
POM_OBJECT pObjLock;
|
|
UINT objectType = 0;
|
|
|
|
DebugEntry(wbProcessLockNotification);
|
|
|
|
//
|
|
// Get the handle of the lock object. We use the last object in the
|
|
// workset to protect against lock objects being left lying around.
|
|
//
|
|
rc = OM_ObjectH(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
0,
|
|
&pObj,
|
|
LAST);
|
|
if (rc != 0)
|
|
{
|
|
ERROR_OUT(("Error getting lock object handle = %d", rc));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Check that this is the CONTROL_LOCK object. Quit if it isnt - we
|
|
// will be called again later when the object arrices.
|
|
//
|
|
rc = wbGetPageObjectType(pObj, &objectType);
|
|
if (rc != 0)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
if (objectType != TYPE_CONTROL_LOCK)
|
|
{
|
|
TRACE_OUT(("not LOCK control object - quit"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Save the handle of the lock object
|
|
//
|
|
pObjLock = pObj;
|
|
|
|
//
|
|
// Read the object
|
|
//
|
|
rc = OM_ObjectRead(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
pObj,
|
|
&pData);
|
|
if (rc != 0)
|
|
{
|
|
ERROR_OUT(("Error reading lock object %d", rc));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
pLock = (PWB_LOCK) &(pData->data);
|
|
|
|
//
|
|
// Save the lock details
|
|
//
|
|
lockType = (WB_LOCK_TYPE)pLock->lockType;
|
|
TRACE_OUT(("Lock type %d", lockType));
|
|
|
|
//
|
|
// Convert the object ID held in the PAGE_CONTROL workset to an object
|
|
// handle.
|
|
//
|
|
rc = OM_ObjectIDToPtr(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pLock->personID,
|
|
&pObjPersonLock);
|
|
|
|
//
|
|
// The return code is checked after the object release to ensure that
|
|
// the object is not held and read again.
|
|
//
|
|
|
|
//
|
|
// Release the lock object
|
|
//
|
|
OM_ObjectRelease(m_pomClient,
|
|
m_hWSGroup,
|
|
PAGE_CONTROL_WORKSET,
|
|
pObj,
|
|
&pData);
|
|
|
|
//
|
|
// Check the return code from the ID to Handle call
|
|
//
|
|
if (rc == OM_RC_BAD_OBJECT_ID)
|
|
{
|
|
WARNING_OUT(("Unknown ID - wait for next add of user object"));
|
|
DC_QUIT;
|
|
}
|
|
else if (rc != 0)
|
|
{
|
|
ERROR_OUT(("Error (%d) converting lock user ID to handle", rc));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Validate the lock state and details
|
|
//
|
|
switch (m_lockState)
|
|
{
|
|
//
|
|
// In this state we do not actually have the lock, but are waiting
|
|
// for confirmation of an earlier workset-lock request. In this
|
|
// case, we let the front end know that the lock request has failed
|
|
// before sending indication of the lock by the other user.
|
|
//
|
|
case LOCK_STATE_PENDING_LOCK:
|
|
ASSERT((pObjPersonLock != m_pObjLocal));
|
|
|
|
m_lockState = LOCK_STATE_LOCKED_OUT;
|
|
TRACE_OUT(("Moved lock state to LOCK_STATE_LOCKED_OUT"));
|
|
|
|
WBP_PostEvent(
|
|
0, // No delay
|
|
WBP_EVENT_LOCK_FAILED, // Lock request failed
|
|
0, // No parameters
|
|
0);
|
|
break;
|
|
|
|
//
|
|
// In these states we do not have a lock - this must be a new lock
|
|
// from remote user or an update to an old lock.
|
|
//
|
|
case LOCK_STATE_EMPTY:
|
|
case LOCK_STATE_LOCKED_OUT:
|
|
ASSERT((pObjPersonLock != m_pObjLocal));
|
|
|
|
//
|
|
// Update the lock state to show that we are now locked out
|
|
//
|
|
m_lockState = LOCK_STATE_LOCKED_OUT;
|
|
TRACE_OUT(("Moved lock state to LOCK_STATE_LOCKED_OUT"));
|
|
break;
|
|
|
|
//
|
|
// In these states we have the lock (or are expecting to get it)
|
|
//
|
|
case LOCK_STATE_GOT_LOCK:
|
|
case LOCK_STATE_PENDING_ADD:
|
|
ASSERT((pObjPersonLock == m_pObjLocal));
|
|
|
|
//
|
|
// Update the lock state to show that we are now locked out
|
|
//
|
|
m_lockState = LOCK_STATE_GOT_LOCK;
|
|
TRACE_OUT(("Moved lock state to LOCK_STATE_GOT_LOCK"));
|
|
break;
|
|
|
|
//
|
|
// The lock request has been cancelled - unlock the WS.
|
|
//
|
|
case LOCK_STATE_CANCEL_LOCK:
|
|
break;
|
|
|
|
//
|
|
// In any other state we are not expecting any lock
|
|
//
|
|
default:
|
|
ERROR_OUT(("Not expecting lock object add"));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Save the lock details
|
|
//
|
|
TRACE_OUT(("Lock handle was %x, now %x",
|
|
m_pObjLock, pObjLock));
|
|
m_pObjLock = pObjLock;
|
|
m_lockType = lockType;
|
|
m_pObjPersonLock = pObjPersonLock;
|
|
|
|
//
|
|
// If the lock has subsequently been cancelled, unlock the WS.
|
|
//
|
|
if (m_lockState == LOCK_STATE_CANCEL_LOCK)
|
|
{
|
|
TRACE_OUT(("Cancel lock"));
|
|
m_lockState = LOCK_STATE_GOT_LOCK;
|
|
wbUnlock();
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Inform the client of the lock. The notification will be trapped
|
|
// by the core if the client is not fully registered.
|
|
//
|
|
wbSendLockNotification();
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbProcessLockNotification);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbSendLockNotification
|
|
//
|
|
// Purpose: Post a lock notification to the client. The lock information
|
|
// held in the client memory must be up to date when this function
|
|
// is called.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
void WbClient::wbSendLockNotification(void)
|
|
{
|
|
UINT result = 0;
|
|
UINT lockEvent;
|
|
|
|
DebugEntry(wbSendLockNotification);
|
|
|
|
//
|
|
// Check that we are in a valid state for sending a lock notification
|
|
//
|
|
if ( (m_lockState == LOCK_STATE_GOT_LOCK)
|
|
|| (m_lockState == LOCK_STATE_LOCKED_OUT)
|
|
|| (m_lockState == LOCK_STATE_EMPTY))
|
|
{
|
|
//
|
|
// Verify the lock type
|
|
//
|
|
switch (m_lockType)
|
|
{
|
|
case WB_LOCK_TYPE_CONTENTS:
|
|
TRACE_OUT(("Posting WBP_EVENT_CONTENTS_LOCKED"));
|
|
lockEvent = WBP_EVENT_CONTENTS_LOCKED;
|
|
break;
|
|
|
|
case WB_LOCK_TYPE_PAGE_ORDER:
|
|
TRACE_OUT(("Posting WBP_EVENT_PAGE_ORDER_LOCKED"));
|
|
lockEvent = WBP_EVENT_PAGE_ORDER_LOCKED;
|
|
break;
|
|
|
|
case WB_LOCK_TYPE_NONE:
|
|
TRACE_OUT(("Posting WBP_EVENT_UNLOCKED"));
|
|
lockEvent = WBP_EVENT_UNLOCKED;
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad lock type %d", (UINT) m_lockType));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Tell the client that the lock has been acquired or released
|
|
//
|
|
WBP_PostEvent(
|
|
0,
|
|
lockEvent,
|
|
0,
|
|
(UINT_PTR)m_pObjPersonLock);
|
|
|
|
TRACE_OUT(("Sent lock notification"));
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitVOID(wbSendLockNotification);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWBPLock
|
|
//
|
|
// Purpose: Process a successful lock acquisitoin
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWBPLock(void)
|
|
{
|
|
BOOL processed = TRUE;
|
|
|
|
DebugEntry(wbOnWBPLock);
|
|
|
|
//
|
|
// If we are registering and have just acquired the lock - we can now
|
|
// continue the registration process.
|
|
//
|
|
|
|
//
|
|
// Test the current state
|
|
//
|
|
switch (m_state)
|
|
{
|
|
//
|
|
// We are waiting for registration to continue
|
|
//
|
|
case STATE_REGISTERING:
|
|
//
|
|
// Act on the registration substate
|
|
//
|
|
if (m_subState == STATE_REG_PENDING_LOCK)
|
|
{
|
|
//
|
|
// Check that it is us who now has the lock
|
|
//
|
|
if (m_lockState != LOCK_STATE_GOT_LOCK)
|
|
{
|
|
TRACE_OUT(("It is not us who has the lock"));
|
|
|
|
//
|
|
// Another client has acquired the lock - we must wait for them
|
|
// to add the Page Control Object.
|
|
//
|
|
m_subState = STATE_REG_PENDING_PAGE_CONTROL;
|
|
TRACE_OUT(("Moved to substate STATE_REG_PENDING_PAGE_CONTROL"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We now have the Page Control Workset locked - check for the
|
|
// existence of the Page Control and Sync Control objects. (We
|
|
// have to do this because another client could have locked the
|
|
// workset, added the objects and unlocked the workset just before
|
|
// we requested the lock. The Page Control Object may not have
|
|
// reached us before we requested the lock. Now that we have the
|
|
// lock we are guaranteed to have all objects in the workset so the
|
|
// object add events may have arrived just before the lock
|
|
// confirmation.
|
|
//
|
|
if ( (m_pObjPageControl != 0)
|
|
&& (m_pObjSyncControl != 0))
|
|
{
|
|
//
|
|
// Unlock the workset
|
|
//
|
|
wbUnlock();
|
|
|
|
//
|
|
// Wait for the unlock to complete
|
|
//
|
|
m_subState = STATE_REG_PENDING_UNLOCK;
|
|
TRACE_OUT(("Moved to substate STATE_REG_PENDING_UNLOCK"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We are the first in the call - we must add the Page Control
|
|
// Object. (It is possible that another client added the Page
|
|
// Control object and then failed. To cover this we check
|
|
// separately for the Page Control and Sync objects.)
|
|
//
|
|
if (m_pObjPageControl == 0)
|
|
{
|
|
//
|
|
// Add a single page to the page control object using the first
|
|
// page workset (which we always open).
|
|
//
|
|
wbPagesPageAdd(0, FIRST_PAGE_WORKSET,
|
|
PAGE_FIRST);
|
|
|
|
//
|
|
// Write the Page Control information
|
|
//
|
|
if (wbWritePageControl(TRUE) != 0)
|
|
{
|
|
ERROR_OUT(("Error adding Page Control Object"));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Update the state to "waiting for Page Control"
|
|
//
|
|
m_subState = STATE_REG_PENDING_PAGE_CONTROL;
|
|
TRACE_OUT(("Moved to substate STATE_REG_PENDING_PAGE_CONTROL"));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// The Page Control object is there, so the Sync Control object
|
|
// must not be (we checked above for both being there and would
|
|
// have exited by now if they were).
|
|
//
|
|
ASSERT((m_pObjSyncControl == 0));
|
|
|
|
//
|
|
// Create the Sync Control Object.
|
|
//
|
|
if (wbCreateSyncControl() != 0)
|
|
{
|
|
ERROR_OUT(("Error adding Sync Control Object"));
|
|
wbError();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Wait for the Sync Control object to be added
|
|
//
|
|
m_subState = STATE_REG_PENDING_SYNC_CONTROL;
|
|
TRACE_OUT(("Moved substate to STATE_REG_PENDING_SYNC_CONTROL"));
|
|
DC_QUIT;
|
|
}
|
|
break;
|
|
|
|
case STATE_IDLE:
|
|
//
|
|
// We are fully registered. The event must be passed on to the
|
|
// front-end
|
|
//
|
|
processed = FALSE;
|
|
break;
|
|
|
|
//
|
|
// We are in an unknown state
|
|
//
|
|
default:
|
|
ERROR_OUT(("Bad client major state"));
|
|
break;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnWBPLock, processed);
|
|
return(processed);
|
|
}
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWBPLockFailed
|
|
//
|
|
// Purpose: Process a failed lock acquisition
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWBPLockFailed(void)
|
|
{
|
|
BOOL processed = TRUE;
|
|
|
|
DebugEntry(wbOnWBPLockFailed);
|
|
|
|
//
|
|
// Check the current state
|
|
//
|
|
switch (m_state)
|
|
{
|
|
case STATE_REGISTERING:
|
|
//
|
|
// If we are registering and have just failed to acquire the lock -
|
|
// this is because another user has the lock. If both the page and
|
|
// sync objects have been added, finish registration, otherwise wait
|
|
// for them to be added.
|
|
//
|
|
if ( (m_pObjPageControl != 0) &&
|
|
(m_pObjSyncControl != 0))
|
|
{
|
|
TRACE_OUT(("Page Control and Sync Control objects both there."));
|
|
TRACE_OUT(("Registration can be completed"));
|
|
wbOnControlWorksetsReady();
|
|
DC_QUIT;
|
|
}
|
|
|
|
if (m_pObjPageControl == 0)
|
|
{
|
|
TRACE_OUT(("Waiting for page control"));
|
|
m_subState = STATE_REG_PENDING_PAGE_CONTROL;
|
|
DC_QUIT;
|
|
}
|
|
|
|
if (m_pObjSyncControl == 0)
|
|
{
|
|
TRACE_OUT(("Waiting for sync control"));
|
|
m_subState = STATE_REG_PENDING_SYNC_CONTROL;
|
|
DC_QUIT;
|
|
}
|
|
break;
|
|
|
|
case STATE_IDLE:
|
|
//
|
|
// We are fully registered. The event must be passed on to the
|
|
// front-end
|
|
//
|
|
processed = FALSE;
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad main state"));
|
|
break;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnWBPLockFailed, processed);
|
|
return(processed);
|
|
}
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWBPUnlocked
|
|
//
|
|
// Purpose: Process an unlock notification
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWBPUnlocked(void)
|
|
{
|
|
BOOL processed = TRUE;
|
|
|
|
DebugEntry(wbOnWBPUnlocked);
|
|
|
|
//
|
|
// If we are registering and waiting to unlock the Page Control Workset
|
|
// we must complete registration here.
|
|
//
|
|
|
|
//
|
|
// Check the current state
|
|
//
|
|
switch (m_state)
|
|
{
|
|
case STATE_REGISTERING:
|
|
//
|
|
// Check whether we are expecting his event
|
|
//
|
|
if(m_subState == STATE_REG_PENDING_UNLOCK)
|
|
{
|
|
//
|
|
// Continue the registration process
|
|
//
|
|
wbOnControlWorksetsReady();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We were not expecting the unlock event
|
|
//
|
|
WARNING_OUT(("Unexpected unlock event"));
|
|
break;
|
|
|
|
case STATE_IDLE:
|
|
//
|
|
// We are fully registered. The event must be passed on to the
|
|
// front-end
|
|
//
|
|
processed = FALSE;
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Bad main state"));
|
|
break;
|
|
} // Switch on client state
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnWBPUnlocked, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbOnWBPPageOrderUpdated
|
|
//
|
|
// Purpose: Process a page order updated notification
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
BOOL WbClient::wbOnWBPPageOrderUpdated(void)
|
|
{
|
|
BOOL processed = FALSE;
|
|
|
|
DebugEntry(wbOnWBPPageOrderUpdated);
|
|
|
|
//
|
|
// If we are registering and waiting for the Page Order to be brought
|
|
// up-to-date we can now continue registration.
|
|
//
|
|
if (m_state == STATE_REGISTERING)
|
|
{
|
|
//
|
|
// Show that we have processed the event (we do not want to pass it on
|
|
// to the client, they are not yet fully registered and will not be
|
|
// expecting it).
|
|
//
|
|
processed = TRUE;
|
|
|
|
//
|
|
// If we have enough pages ready in the cache, we have completed
|
|
// registration. (Otherwise the call to CheckReadyPages will open
|
|
// another page and will complete registration later.)
|
|
//
|
|
if (wbCheckReadyPages())
|
|
{
|
|
wbCompleteRegistration();
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// We must wait for sufficiently many pages to be ready
|
|
//
|
|
m_subState = STATE_REG_PENDING_READY_PAGES;
|
|
TRACE_OUT(("Moved substate to STATE_REG_PENDING_READY_PAGES"));
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitBOOL(wbOnWBPPageOrderUpdated, processed);
|
|
return(processed);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPersonGet
|
|
//
|
|
// Purpose: Get user details
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbPersonGet
|
|
(
|
|
POM_OBJECT pObjUser,
|
|
PWB_PERSON pUser
|
|
)
|
|
{
|
|
UINT result = 0;
|
|
POM_OBJECTDATA pUserObject;
|
|
|
|
DebugEntry(wbPersonGet);
|
|
|
|
if (pObjUser == m_pObjLocal)
|
|
{
|
|
TRACE_OUT(("Call is for local user details"));
|
|
}
|
|
|
|
//
|
|
// Read the object.
|
|
//
|
|
result = OM_ObjectRead(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pObjUser,
|
|
&pUserObject);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectRead = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Copy the read user object into the buffer passed
|
|
//
|
|
memcpy(pUser, pUserObject->data, sizeof(WB_PERSON));
|
|
TRACE_OUT(("CMG personID %u", pUser->cmgPersonID));
|
|
|
|
//
|
|
// Release the object
|
|
//
|
|
OM_ObjectRelease(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
pObjUser,
|
|
&pUserObject);
|
|
|
|
//
|
|
// If the call is for the local user, update the color field to ensure it
|
|
// doesn't get overwritten in a race condition with the front-end (i.e.
|
|
// the front end tries to update the user before the color-change event
|
|
// has been received). The core "knows better" than ObMan what the local
|
|
// user's color is. This is safe because the color field is only ever
|
|
// changed locally.
|
|
//
|
|
if (pObjUser == m_pObjLocal)
|
|
{
|
|
pUser->colorId = (TSHR_UINT16)m_colorId;
|
|
}
|
|
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbPersonGet, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbPersonUpdate
|
|
//
|
|
// Purpose: Update the local user object - this is only used by the CORE -
|
|
// the front-end calls WBP_SetPersonData, which does a _replace_.
|
|
//
|
|
// Returns: Error code
|
|
//
|
|
//
|
|
UINT WbClient::wbPersonUpdate(PWB_PERSON pUser)
|
|
{
|
|
UINT result = 0;
|
|
POM_OBJECTDATA pUserObject;
|
|
|
|
DebugEntry(wbPersonUpdate);
|
|
|
|
//
|
|
// Allocate a user object
|
|
//
|
|
result = OM_ObjectAlloc(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
sizeof(WB_PERSON),
|
|
&pUserObject);
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectAlloc = %d", result));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Set the length of the object
|
|
//
|
|
pUserObject->length = WB_PERSON_OBJECT_UPDATE_SIZE,
|
|
|
|
//
|
|
// Copy the user information into the ObMan object
|
|
//
|
|
memcpy(pUserObject->data, pUser, sizeof(WB_PERSON));
|
|
|
|
//
|
|
// Update the object
|
|
//
|
|
result = OM_ObjectUpdate(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
m_pObjLocal,
|
|
&pUserObject);
|
|
|
|
if (result != 0)
|
|
{
|
|
ERROR_OUT(("OM_ObjectUpdate = %d", result));
|
|
|
|
//
|
|
// Discard the object
|
|
//
|
|
OM_ObjectDiscard(m_pomClient,
|
|
m_hWSGroup,
|
|
USER_INFORMATION_WORKSET,
|
|
&pUserObject);
|
|
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Note that the object has not yet been updated. An
|
|
// OM_OBJECT_UPDATE_IND event will be generated.
|
|
//
|
|
|
|
DC_EXIT_POINT:
|
|
DebugExitDWORD(wbPersonUpdate, result);
|
|
return(result);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//
|
|
// Name: wbGetNetUserID().
|
|
//
|
|
// Purpose: Get the network user ID for this client
|
|
//
|
|
// Returns:
|
|
//
|
|
//
|
|
BOOL WbClient::wbGetNetUserID(void)
|
|
{
|
|
BOOL result = TRUE;
|
|
UINT rc = 0;
|
|
|
|
DebugEntry(wbGetNetUserID);
|
|
|
|
rc = OM_GetNetworkUserID(m_pomClient,
|
|
m_hWSGroup,
|
|
&m_clientNetID);
|
|
if (rc != 0)
|
|
{
|
|
if (rc == OM_RC_LOCAL_WSGROUP)
|
|
{
|
|
m_clientNetID = 0;
|
|
}
|
|
else
|
|
{
|
|
result = FALSE;
|
|
}
|
|
}
|
|
|
|
DebugExitBOOL(wbGetNetUserID, result);
|
|
return(result);
|
|
}
|