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.
1435 lines
34 KiB
1435 lines
34 KiB
//
|
|
// DRAWOBJ.CPP
|
|
// Drawing objects: point, openpolyline, closepolyline, ellipse
|
|
//
|
|
// Copyright Microsoft 1998-
|
|
//
|
|
#include "precomp.h"
|
|
#include "NMWbObj.h"
|
|
|
|
WorkspaceObj* g_pCurrentWorkspace;
|
|
WorkspaceObj* g_pConferenceWorkspace;
|
|
|
|
//
|
|
// Created from UI
|
|
//
|
|
WorkspaceObj::WorkspaceObj ( void )
|
|
{
|
|
|
|
ResetAttrib();
|
|
|
|
SetOwnerID(g_MyMemberID);
|
|
|
|
SetType(workspaceCreatePDU_chosen);
|
|
|
|
//
|
|
// Workspace Identifier
|
|
//
|
|
SetWorkspaceHandle(0);
|
|
|
|
//
|
|
// Application Roster Instance
|
|
//
|
|
m_appRosterInstance = g_pNMWBOBJ->m_instanceNumber;
|
|
|
|
//
|
|
// Is Wokspace synchronized
|
|
//
|
|
m_bsynchronized = TRUE;
|
|
|
|
//
|
|
// Does workspace accept keyboard events
|
|
//
|
|
m_acceptKeyboardEvents = FALSE;
|
|
|
|
//
|
|
// Does workspace accept mouse events
|
|
//
|
|
m_acceptPointingDeviceEvents = FALSE;
|
|
|
|
SetViewState(focus_chosen);
|
|
|
|
SetUpdatesEnabled(!g_pDraw->IsLocked());
|
|
|
|
//
|
|
// Workspace max width and height
|
|
//
|
|
m_workspaceSize.x = DRAW_WIDTH; // Max width
|
|
m_workspaceSize.y = DRAW_HEIGHT; // Max height in Draw.hpp
|
|
|
|
RECT rect;
|
|
rect.top = 0;
|
|
rect.left = 0;
|
|
rect.right = m_workspaceSize.x;
|
|
rect.bottom = m_workspaceSize.y;
|
|
SetRect(&rect);
|
|
}
|
|
|
|
|
|
//
|
|
// Created from Remote
|
|
//
|
|
WorkspaceObj::WorkspaceObj (WorkspaceCreatePDU * pWorkspaceCreatePDU, BOOL bForcedResend)
|
|
{
|
|
|
|
ResetAttrib();
|
|
SetType(workspaceCreatePDU_chosen);
|
|
|
|
SetUpdatesEnabled(TRUE);
|
|
|
|
//
|
|
// Workspace Identifier
|
|
//
|
|
SetWorkspaceHandle(GetWorkspaceIdentifier(&pWorkspaceCreatePDU->workspaceIdentifier));
|
|
SetThisObjectHandle(GetWorkspaceHandle());
|
|
|
|
#ifdef _DEBUG
|
|
|
|
//
|
|
// Application Roster Instance
|
|
//
|
|
m_appRosterInstance = pWorkspaceCreatePDU->appRosterInstance;
|
|
TRACE_DEBUG(("m_appRosterInstance = %d", m_appRosterInstance));
|
|
|
|
//
|
|
// Is Wokspace synchronized
|
|
//
|
|
m_bsynchronized = pWorkspaceCreatePDU->synchronized;
|
|
TRACE_DEBUG(("m_bsynchronized = %d", m_bsynchronized));
|
|
|
|
//
|
|
// Does workspace accept keyboard events
|
|
//
|
|
m_acceptKeyboardEvents = pWorkspaceCreatePDU->acceptKeyboardEvents;
|
|
TRACE_DEBUG(("m_acceptKeyboardEvents = %d", m_acceptKeyboardEvents));
|
|
|
|
//
|
|
// Does workspace accept mouse events
|
|
//
|
|
m_acceptPointingDeviceEvents = pWorkspaceCreatePDU->acceptPointingDeviceEvents;
|
|
TRACE_DEBUG(("m_acceptPointingDeviceEvents = %d", m_acceptPointingDeviceEvents));
|
|
|
|
//
|
|
// List of nodes that can access workspace
|
|
//
|
|
if(pWorkspaceCreatePDU->bit_mask & protectedPlaneAccessList_present)
|
|
{
|
|
WorkspaceCreatePDU_protectedPlaneAccessList_Element *pNode;
|
|
pNode = pWorkspaceCreatePDU->protectedPlaneAccessList;
|
|
do
|
|
{
|
|
BYTE * pByte;
|
|
DBG_SAVE_FILE_LINE
|
|
pByte = new BYTE[1];
|
|
*pByte = (UCHAR)pNode->value;
|
|
m_protectedPlaneAccessList.AddTail(pByte);
|
|
pNode = pNode->next;
|
|
}while (pNode);
|
|
|
|
}
|
|
|
|
//
|
|
// Workspace max width and height
|
|
//
|
|
m_workspaceSize.x = pWorkspaceCreatePDU->workspaceSize.width;
|
|
m_workspaceSize.y = pWorkspaceCreatePDU->workspaceSize.height;
|
|
TRACE_DEBUG(("m_workspaceSize(x,y) = (%d, %d)", m_workspaceSize.x, m_workspaceSize.y));
|
|
|
|
RECT rect;
|
|
rect.top = 0;
|
|
rect.left = 0;
|
|
rect.right = m_workspaceSize.x;
|
|
rect.bottom = m_workspaceSize.y;
|
|
SetRect(&rect);
|
|
|
|
//
|
|
// Workspace attributes
|
|
//
|
|
if(pWorkspaceCreatePDU->bit_mask & workspaceAttributes_present)
|
|
{
|
|
GetWorkSpaceAttrib(pWorkspaceCreatePDU->workspaceAttributes);
|
|
}
|
|
|
|
//
|
|
// Workspace plane parameters
|
|
//
|
|
GetWorkSpacePlaneParam(pWorkspaceCreatePDU->planeParameters);
|
|
|
|
|
|
//
|
|
// Workspace view parameters
|
|
//
|
|
if(pWorkspaceCreatePDU->bit_mask & viewParameters_present)
|
|
{
|
|
m_viewHandle = pWorkspaceCreatePDU->viewParameters->value.viewHandle;
|
|
TRACE_DEBUG(("View Handle = %d", m_viewHandle));
|
|
|
|
if(pWorkspaceCreatePDU->viewParameters->value.bit_mask & viewAttributes_present)
|
|
{
|
|
GetWorkSpaceViewParam(pWorkspaceCreatePDU->viewParameters->value.viewAttributes);
|
|
}
|
|
}
|
|
|
|
#endif // 0
|
|
|
|
//
|
|
// Add it to the list of workspaces
|
|
//
|
|
AddNewWorkspace(this, bForcedResend);
|
|
|
|
}
|
|
|
|
|
|
|
|
WorkspaceObj::~WorkspaceObj( void )
|
|
{
|
|
RemoveObjectFromResendList(this);
|
|
RemoveObjectFromRequestHandleList(this);
|
|
|
|
//
|
|
// Tell other nodes that we are gone
|
|
//
|
|
if(WasDeletedLocally())
|
|
{
|
|
OnObjectDelete();
|
|
}
|
|
|
|
//
|
|
// Delete all the objects in this workspace
|
|
//
|
|
T126Obj * pObj;
|
|
while ((pObj = (T126Obj *)m_T126ObjectsInWorkspace.RemoveTail()) != NULL)
|
|
{
|
|
pObj->SetMyWorkspace(NULL);
|
|
delete pObj;
|
|
g_numberOfObjects--;
|
|
}
|
|
|
|
g_numberOfWorkspaces--;
|
|
}
|
|
|
|
|
|
void WorkspaceObj::WorkspaceEditObj ( WorkspaceEditPDU * pWorkspaceEditPDU )
|
|
{
|
|
|
|
//
|
|
// Workspace view parameters
|
|
//
|
|
if(pWorkspaceEditPDU->bit_mask & viewEdits_present)
|
|
{
|
|
GetWorkSpaceViewEditParam(pWorkspaceEditPDU->viewEdits);
|
|
}
|
|
|
|
if(HasUpatesEnabledStateChanged())
|
|
{
|
|
if(GetUpdatesEnabled())
|
|
{
|
|
g_pMain->UnlockDrawingArea();
|
|
}
|
|
else
|
|
{
|
|
g_pMain->LockDrawingArea();
|
|
}
|
|
|
|
g_pMain->UpdatePageButtons();
|
|
}
|
|
|
|
if(HasViewStateChanged() &&
|
|
pWorkspaceEditPDU->viewEdits &&
|
|
pWorkspaceEditPDU->viewEdits->value.action.choice == editView_chosen)
|
|
{
|
|
if(g_pDraw->IsSynced())
|
|
{
|
|
g_pMain->GotoPage(this, FALSE);
|
|
}
|
|
|
|
g_pConferenceWorkspace = this;
|
|
}
|
|
|
|
ResetAttrib();
|
|
|
|
#ifdef _DEBUG
|
|
//
|
|
// Workspace attributes
|
|
//
|
|
if(pWorkspaceEditPDU->bit_mask & WorkspaceEditPDU_attributeEdits_present)
|
|
{
|
|
GetWorkSpaceAttrib((WorkspaceCreatePDU_workspaceAttributes *)pWorkspaceEditPDU->attributeEdits);
|
|
}
|
|
|
|
//
|
|
// Workspace plane parameters
|
|
//
|
|
if(pWorkspaceEditPDU->bit_mask & planeEdits_present)
|
|
{
|
|
GetWorkSpacePlaneParam((WorkspaceCreatePDU_planeParameters *)pWorkspaceEditPDU->planeEdits);
|
|
}
|
|
|
|
#endif // 0
|
|
}
|
|
|
|
UINT WorkspaceObj::GetWorkspaceIdentifier(WorkspaceIdentifier *workspaceIdentifier)
|
|
{
|
|
|
|
TRACE_DEBUG(("GetWorkspaceIdentifier choice = %d", workspaceIdentifier->choice));
|
|
switch(workspaceIdentifier->choice)
|
|
{
|
|
case(activeWorkspace_chosen):
|
|
{
|
|
TRACE_MSG(("activeWorkspace = %d", workspaceIdentifier->u.activeWorkspace));
|
|
return(workspaceIdentifier->u.activeWorkspace);
|
|
break;
|
|
}
|
|
// case(archiveWorkspace_chosen):
|
|
// {
|
|
// break;
|
|
// }
|
|
default:
|
|
{
|
|
ERROR_OUT(("Invalid workspaceIdentifier choice"));
|
|
break;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void WorkspaceObj::CreateWorkspaceCreatePDU(WorkspaceCreatePDU * pWorkspaceCreatePDU)
|
|
{
|
|
|
|
pWorkspaceCreatePDU->bit_mask = 0;
|
|
//
|
|
// Workspace Identifier, we have to ask GCC for an active unique workspace handle
|
|
//
|
|
pWorkspaceCreatePDU->workspaceIdentifier.choice = activeWorkspace_chosen;
|
|
pWorkspaceCreatePDU->workspaceIdentifier.u.activeWorkspace = GetWorkspaceHandle();
|
|
|
|
//
|
|
// Application Roster Instance
|
|
//
|
|
pWorkspaceCreatePDU->appRosterInstance = (ASN1uint16_t)g_pNMWBOBJ->m_instanceNumber;
|
|
|
|
//
|
|
// Is Wokspace synchronized
|
|
//
|
|
pWorkspaceCreatePDU->synchronized = (ASN1bool_t)m_bsynchronized;
|
|
|
|
//
|
|
// Does workspace accept keyboard events
|
|
//
|
|
pWorkspaceCreatePDU->acceptKeyboardEvents = (ASN1bool_t)m_acceptKeyboardEvents;
|
|
|
|
//
|
|
// Does workspace accept mouse events
|
|
//
|
|
pWorkspaceCreatePDU->acceptPointingDeviceEvents = (ASN1bool_t)m_acceptPointingDeviceEvents;
|
|
|
|
//
|
|
// Workspace max width and height
|
|
//
|
|
pWorkspaceCreatePDU->workspaceSize.width = (USHORT)m_workspaceSize.x;
|
|
pWorkspaceCreatePDU->workspaceSize.height = (USHORT)m_workspaceSize.y;
|
|
|
|
|
|
//
|
|
// Workspace plane parameters
|
|
//
|
|
PWorkspaceCreatePDU_planeParameters planeParameters;
|
|
PWorkspaceCreatePDU_planeParameters_Seq_usage usage;
|
|
PWorkspaceCreatePDU_planeParameters_Seq_usage pFirstUsage;
|
|
|
|
//
|
|
// Do the plane parameters
|
|
//
|
|
DBG_SAVE_FILE_LINE
|
|
planeParameters = (PWorkspaceCreatePDU_planeParameters)new BYTE[sizeof(WorkspaceCreatePDU_planeParameters)];
|
|
pWorkspaceCreatePDU->planeParameters = planeParameters;
|
|
planeParameters->value.bit_mask = planeAttributes_present;
|
|
planeParameters->value.editable = TRUE;
|
|
planeParameters->next = NULL;
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
PWorkspaceCreatePDU_planeParameters_Seq_planeAttributes pPlaneAttrib;
|
|
pPlaneAttrib = (PWorkspaceCreatePDU_planeParameters_Seq_planeAttributes) new BYTE[sizeof(WorkspaceCreatePDU_planeParameters_Seq_planeAttributes)];
|
|
pPlaneAttrib->value.choice = protection_chosen;
|
|
pPlaneAttrib->value.u.protection.protectedplane = FALSE;
|
|
pPlaneAttrib->next = NULL;
|
|
|
|
planeParameters->value.planeAttributes = pPlaneAttrib;
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
usage = (PWorkspaceCreatePDU_planeParameters_Seq_usage) new BYTE[sizeof(WorkspaceCreatePDU_planeParameters_Seq_usage)];
|
|
pFirstUsage = usage;
|
|
planeParameters->value.usage = usage;
|
|
usage->value.choice = image_chosen;
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
usage = (PWorkspaceCreatePDU_planeParameters_Seq_usage) new BYTE[sizeof(WorkspaceCreatePDU_planeParameters_Seq_usage)];
|
|
planeParameters->value.usage->next = usage;
|
|
usage->value.choice = annotation_chosen;
|
|
usage->next = NULL;
|
|
|
|
//
|
|
// Do the plane parameters 2nd time
|
|
//
|
|
DBG_SAVE_FILE_LINE
|
|
planeParameters->next = (PWorkspaceCreatePDU_planeParameters)new BYTE[sizeof(WorkspaceCreatePDU_planeParameters)];
|
|
planeParameters = planeParameters->next;
|
|
planeParameters->value.bit_mask = planeAttributes_present;
|
|
planeParameters->value.editable = TRUE;
|
|
planeParameters->value.usage = pFirstUsage;
|
|
planeParameters->next = NULL;
|
|
planeParameters->value.planeAttributes = pPlaneAttrib;
|
|
|
|
//
|
|
// Do it hte 3rd time
|
|
//
|
|
planeParameters->next = (PWorkspaceCreatePDU_planeParameters)new BYTE[sizeof(WorkspaceCreatePDU_planeParameters)];
|
|
planeParameters = planeParameters->next;
|
|
planeParameters->value.bit_mask = planeAttributes_present;
|
|
planeParameters->value.editable = TRUE;
|
|
planeParameters->value.usage = pFirstUsage;
|
|
planeParameters->next = NULL;
|
|
planeParameters->value.planeAttributes = pPlaneAttrib;
|
|
|
|
|
|
pWorkspaceCreatePDU->viewParameters = NULL;
|
|
}
|
|
|
|
void WorkspaceObj::CreateWorkspaceDeletePDU(WorkspaceDeletePDU *pWorkspaceDeletePDU)
|
|
{
|
|
pWorkspaceDeletePDU->bit_mask = 0;
|
|
pWorkspaceDeletePDU->workspaceIdentifier.choice = activeWorkspace_chosen;
|
|
pWorkspaceDeletePDU->workspaceIdentifier.u.activeWorkspace = GetWorkspaceHandle();
|
|
pWorkspaceDeletePDU->reason.choice = userInitiated_chosen;
|
|
}
|
|
|
|
void WorkspaceObj::CreateWorkspaceEditPDU(WorkspaceEditPDU *pWorkspaceEditPDU)
|
|
{
|
|
pWorkspaceEditPDU->bit_mask = 0;
|
|
pWorkspaceEditPDU->workspaceIdentifier.choice = activeWorkspace_chosen;
|
|
pWorkspaceEditPDU->workspaceIdentifier.u.activeWorkspace = GetWorkspaceHandle();
|
|
|
|
PWorkspaceEditPDU_viewEdits_Set_action_editView pEditView = NULL;
|
|
pWorkspaceEditPDU->viewEdits = NULL;
|
|
|
|
if(HasUpatesEnabledStateChanged() || HasViewStateChanged())
|
|
{
|
|
pWorkspaceEditPDU->bit_mask |= viewEdits_present;
|
|
DBG_SAVE_FILE_LINE
|
|
pWorkspaceEditPDU->viewEdits = (PWorkspaceEditPDU_viewEdits)new BYTE[sizeof(WorkspaceEditPDU_viewEdits)];
|
|
pWorkspaceEditPDU->viewEdits->next = NULL;
|
|
pWorkspaceEditPDU->viewEdits->value.viewHandle = m_viewHandle;
|
|
pWorkspaceEditPDU->viewEdits->value.action.choice = (ASN1choice_t)m_viewActionChoice;
|
|
pWorkspaceEditPDU->viewEdits->value.action.u.editView = NULL;
|
|
}
|
|
|
|
if(HasUpatesEnabledStateChanged())
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
pEditView = (PWorkspaceEditPDU_viewEdits_Set_action_editView) new BYTE[sizeof (WorkspaceEditPDU_viewEdits_Set_action_editView)];
|
|
pEditView->next = NULL;
|
|
pEditView->value.choice = updatesEnabled_chosen;
|
|
pEditView->value.u.updatesEnabled = (ASN1bool_t)GetUpdatesEnabled();
|
|
pWorkspaceEditPDU->viewEdits->value.action.u.editView = pEditView;
|
|
}
|
|
|
|
|
|
if(HasViewStateChanged())
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
pEditView = (PWorkspaceEditPDU_viewEdits_Set_action_editView) new BYTE[sizeof (WorkspaceEditPDU_viewEdits_Set_action_editView)];
|
|
pEditView->next = pWorkspaceEditPDU->viewEdits->value.action.u.editView;
|
|
pEditView->value.choice = WorkspaceViewAttribute_viewState_chosen;
|
|
pEditView->value.u.viewState.choice = (ASN1choice_t)GetViewState();
|
|
pWorkspaceEditPDU->viewEdits->value.action.u.editView = pEditView;
|
|
}
|
|
}
|
|
|
|
|
|
void WorkspaceObj::RemoveT126Object(T126Obj *pObj)
|
|
{
|
|
|
|
//
|
|
// The contents of the wb just changed
|
|
//
|
|
g_bContentsChanged = TRUE;
|
|
|
|
//
|
|
// Remove it from the List Of objcets in the workspace
|
|
//
|
|
WBPOSITION pos = m_T126ObjectsInWorkspace.GetPosition(pObj);
|
|
|
|
m_T126ObjectsInWorkspace.RemoveAt(pos);
|
|
|
|
//
|
|
// Erase the drawing
|
|
//
|
|
pObj->DrawRect();
|
|
pObj->UnselectDrawingObject();
|
|
|
|
pObj->UnDraw();
|
|
|
|
//
|
|
// Put the object in the trash, don't delete it locally
|
|
// but tell the other nodes to delete it
|
|
//
|
|
g_numberOfObjects--;
|
|
|
|
g_pDraw->DeleteSelection();
|
|
|
|
if(pObj != g_pMain->m_pLocalRemotePointer && pObj->WasDeletedLocally())
|
|
{
|
|
pObj->SetMyPosition(NULL);
|
|
g_pTrash->AddTail( pObj );
|
|
pObj->OnObjectDelete();
|
|
}
|
|
else
|
|
{
|
|
delete pObj;
|
|
}
|
|
}
|
|
|
|
|
|
T126Obj* WorkspaceObj::FindObjectInWorkspace(UINT objectHandle)
|
|
{
|
|
T126Obj* pObj;
|
|
|
|
WBPOSITION pos;
|
|
pos = m_T126ObjectsInWorkspace.GetTailPosition();
|
|
while (pos != NULL)
|
|
{
|
|
pObj = (T126Obj*)m_T126ObjectsInWorkspace.GetPrevious(pos);
|
|
|
|
if(pObj && pObj->GetThisObjectHandle() == objectHandle)
|
|
{
|
|
return pObj;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
BOOL WorkspaceObj::IsObjectInWorkspace(T126Obj* pObjToFind)
|
|
{
|
|
T126Obj* pObj;
|
|
|
|
WBPOSITION pos;
|
|
pos = m_T126ObjectsInWorkspace.GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
pObj = (T126Obj*)m_T126ObjectsInWorkspace.GetNext(pos);
|
|
if(pObj == pObjToFind)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL IsWorkspaceListed(T126Obj * pWorkspaceObj)
|
|
{
|
|
T126Obj * pObj;
|
|
|
|
WBPOSITION pos;
|
|
pos = g_pListOfWorkspaces->GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
pObj =(T126Obj *) g_pListOfWorkspaces->GetNext(pos);
|
|
|
|
if(pObj == pWorkspaceObj)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Add new workspace
|
|
//
|
|
void AddNewWorkspace(WorkspaceObj * pWorkspaceObj, BOOL bForcedResend)
|
|
{
|
|
g_bContentsChanged = TRUE;
|
|
|
|
//
|
|
// Add it to the list of workspace objects
|
|
//
|
|
if(g_pConferenceWorkspace)
|
|
{
|
|
WBPOSITION pos = g_pConferenceWorkspace->GetMyPosition();
|
|
pWorkspaceObj->SetMyPosition(g_pListOfWorkspaces->AddAt(pWorkspaceObj, pos));
|
|
}
|
|
else
|
|
{
|
|
pWorkspaceObj->SetMyPosition(g_pListOfWorkspaces->AddTail(pWorkspaceObj));
|
|
|
|
g_pConferenceWorkspace = pWorkspaceObj;
|
|
g_pCurrentWorkspace = pWorkspaceObj;
|
|
if(!g_pDraw->IsSynced())
|
|
{
|
|
g_pMain->OnSync();
|
|
}
|
|
}
|
|
|
|
g_numberOfWorkspaces++;
|
|
|
|
if(g_pDraw->IsSynced())
|
|
{
|
|
g_pMain->GotoPage(pWorkspaceObj, bForcedResend);
|
|
}
|
|
//
|
|
// We are not synced but update the page butons anyway
|
|
//
|
|
else
|
|
{
|
|
g_pConferenceWorkspace = pWorkspaceObj;
|
|
g_pMain->UpdatePageButtons();
|
|
}
|
|
}
|
|
|
|
BitmapObj * WorkspaceObj::RectHitRemotePointer(LPRECT hitRect, int penThickness , WBPOSITION pos)
|
|
{
|
|
if(pos == NULL)
|
|
{
|
|
pos = m_T126ObjectsInWorkspace.GetTailPosition();
|
|
}
|
|
else
|
|
{
|
|
m_T126ObjectsInWorkspace.GetPrevious(pos);
|
|
}
|
|
|
|
T126Obj* pPointer = (T126Obj*)m_T126ObjectsInWorkspace.GetFromPosition(pos);
|
|
|
|
RECT pointerRect;
|
|
RECT intersectRect;
|
|
|
|
while(pos && pPointer && pPointer->GraphicTool() == TOOLTYPE_REMOTEPOINTER)
|
|
{
|
|
pPointer->GetRect(&pointerRect);
|
|
::InflateRect(&pointerRect, penThickness , penThickness);
|
|
NormalizeRect(&pointerRect);
|
|
NormalizeRect(hitRect);
|
|
if(IntersectRect(&intersectRect, &pointerRect, hitRect))
|
|
{
|
|
return (BitmapObj *)pPointer;
|
|
}
|
|
pPointer = (T126Obj*) m_T126ObjectsInWorkspace.GetPrevious(pos);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void WorkspaceObj::AddTail(T126Obj * pObj)
|
|
{
|
|
//
|
|
// The contents of the wb just changed
|
|
//
|
|
g_bContentsChanged = TRUE;
|
|
|
|
pObj->SetMyWorkspace(this);
|
|
T126Obj* pPointer = (T126Obj*)m_T126ObjectsInWorkspace.GetTail();
|
|
|
|
//
|
|
// Add the local remote pointer in the tail position
|
|
// and other type of objects before all the remote pointers
|
|
//
|
|
if(!(pObj->GraphicTool() == TOOLTYPE_REMOTEPOINTER && pObj->IAmTheOwner()) &&
|
|
pPointer && pPointer->GraphicTool() == TOOLTYPE_REMOTEPOINTER)
|
|
{
|
|
WBPOSITION pos = m_T126ObjectsInWorkspace.GetTailPosition();
|
|
WBPOSITION insertPos = NULL;
|
|
|
|
//
|
|
// Find the first object that is not a remote pointer
|
|
//
|
|
while(pPointer->GraphicTool() == TOOLTYPE_REMOTEPOINTER)
|
|
{
|
|
insertPos = pos;
|
|
if(pos == NULL)
|
|
{
|
|
break;
|
|
}
|
|
pPointer = (T126Obj*) m_T126ObjectsInWorkspace.GetPrevious(pos);
|
|
}
|
|
|
|
if(insertPos)
|
|
{
|
|
pObj->SetMyPosition(m_T126ObjectsInWorkspace.AddAt(pObj, insertPos));
|
|
}
|
|
else
|
|
{
|
|
pObj->SetMyPosition(m_T126ObjectsInWorkspace.AddHead(pObj));
|
|
}
|
|
|
|
//
|
|
// Make sure we repaint the area, if there was a handle it could be under it
|
|
//
|
|
if(pObj->GraphicTool() == TOOLTYPE_REMOTEPOINTER)
|
|
{
|
|
((BitmapObj*)pObj)->CreateSaveBitmap();
|
|
}
|
|
|
|
RECT rect;
|
|
pObj->GetBoundsRect(&rect);
|
|
g_pDraw->InvalidateSurfaceRect(&rect,TRUE);
|
|
|
|
}
|
|
else
|
|
{
|
|
pObj->SetMyPosition(m_T126ObjectsInWorkspace.AddTail(pObj));
|
|
}
|
|
}
|
|
|
|
|
|
WorkspaceObj* RemoveWorkspace(WorkspaceObj * pWorkspaceObj)
|
|
{
|
|
WorkspaceObj * pWrkspc;
|
|
|
|
g_bContentsChanged = TRUE;
|
|
|
|
WBPOSITION pos = pWorkspaceObj->GetMyPosition();
|
|
WBPOSITION prevPos = pos;
|
|
|
|
g_pListOfWorkspaces->GetPrevious(prevPos);
|
|
|
|
g_pListOfWorkspaces->RemoveAt(pos);
|
|
|
|
//
|
|
// We just removed the first page
|
|
//
|
|
if(prevPos == NULL)
|
|
{
|
|
pWrkspc = (WorkspaceObj *)g_pListOfWorkspaces->GetHead();
|
|
}
|
|
else
|
|
{
|
|
pWrkspc = (WorkspaceObj *)g_pListOfWorkspaces->GetPrevious(prevPos);
|
|
}
|
|
|
|
//
|
|
// The current workspace is pointing to the deleted object
|
|
//
|
|
if(g_pCurrentWorkspace == pWorkspaceObj)
|
|
{
|
|
::InvalidateRect(g_pDraw->m_hwnd, NULL, TRUE);
|
|
|
|
|
|
//
|
|
// If we were drawing/selecting or dragging something, finish now
|
|
//
|
|
g_pDraw->OnLButtonUp(0,0,0);
|
|
|
|
//
|
|
// If we are deleting the current workspace and we have the text editor active
|
|
//
|
|
if (g_pDraw->TextEditActive())
|
|
{
|
|
//
|
|
// Finish the text
|
|
//
|
|
g_pDraw->EndTextEntry(FALSE);
|
|
}
|
|
|
|
g_pCurrentWorkspace = NULL;
|
|
}
|
|
|
|
if(g_pConferenceWorkspace == pWorkspaceObj)
|
|
{
|
|
g_pConferenceWorkspace = NULL;
|
|
|
|
}
|
|
|
|
delete pWorkspaceObj;
|
|
|
|
return pWrkspc;
|
|
}
|
|
|
|
UINT WorkspaceObj::EnumerateObjectsInWorkspace(void)
|
|
{
|
|
UINT objects = 0;
|
|
WBPOSITION pos;
|
|
T126Obj* pObj;
|
|
|
|
pos = GetHeadPosition();
|
|
while(pos)
|
|
{
|
|
pObj = GetNextObject(pos);
|
|
if(pObj && pObj->GraphicTool() != TOOLTYPE_REMOTEPOINTER)
|
|
{
|
|
objects++;
|
|
}
|
|
}
|
|
return objects;
|
|
}
|
|
|
|
|
|
void ResendAllObjects(void)
|
|
{
|
|
//
|
|
// Resend all objects
|
|
//
|
|
WBPOSITION pos;
|
|
WBPOSITION posObj;
|
|
WorkspaceObj* pWorkspace;
|
|
WorkspaceObj* pCurrentWorkspace;
|
|
|
|
pCurrentWorkspace = g_pCurrentWorkspace;
|
|
|
|
T126Obj* pObj;
|
|
pos = g_pListOfWorkspaces->GetHeadPosition();
|
|
while(pos)
|
|
{
|
|
pWorkspace = (WorkspaceObj*)g_pListOfWorkspaces->GetNext(pos);
|
|
if(pWorkspace)
|
|
{
|
|
pWorkspace->SetAllAttribs();
|
|
pWorkspace->SendNewObjectToT126Apps();
|
|
posObj = pWorkspace->GetHeadPosition();
|
|
while(posObj)
|
|
{
|
|
pObj = pWorkspace->GetNextObject(posObj);
|
|
if(pObj)
|
|
{
|
|
pObj->ClearSelectionFlags();
|
|
pObj->SetAllAttribs();
|
|
pObj->SendNewObjectToT126Apps();
|
|
|
|
//
|
|
// Lines need to be saved in various pdus with 256 points in each pdu
|
|
//
|
|
if(pObj->GraphicTool() == TOOLTYPE_PEN || pObj->GraphicTool() == TOOLTYPE_HIGHLIGHT)
|
|
{
|
|
int nPoints = ((DrawObj*)pObj)->m_points->GetSize();
|
|
int size = MAX_POINT_LIST_VALUES + 1;
|
|
if(nPoints > (MAX_POINT_LIST_VALUES + 1))
|
|
{
|
|
while(size != nPoints)
|
|
{
|
|
if(nPoints > (size + MAX_POINT_LIST_VALUES + 1))
|
|
{
|
|
size += MAX_POINT_LIST_VALUES + 1;
|
|
}
|
|
else
|
|
{
|
|
size = nPoints;
|
|
}
|
|
|
|
//
|
|
// Move to the next 256 points
|
|
//
|
|
|
|
((DrawObj*)pObj)->m_points->SetSize(size - 1);
|
|
|
|
//
|
|
// Send the next 256 points
|
|
//
|
|
pObj->ResetAttrib();
|
|
((DrawObj*)pObj)->ChangedPointList();
|
|
pObj->OnObjectEdit();
|
|
}
|
|
((DrawObj*)pObj)->m_points->SetSize(size);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Syncronize page
|
|
//
|
|
if(g_pCurrentWorkspace)
|
|
{
|
|
g_pMain->GotoPage(g_pCurrentWorkspace);
|
|
g_pCurrentWorkspace->SetViewState(focus_chosen);
|
|
g_pCurrentWorkspace->SetViewActionChoice(editView_chosen);
|
|
g_pCurrentWorkspace->OnObjectEdit();
|
|
}
|
|
}
|
|
|
|
void RemoveObjectFromRequestHandleList(T126Obj * pObjRequest)
|
|
{
|
|
T126Obj* pObj;
|
|
WBPOSITION pos;
|
|
WBPOSITION prevPos;
|
|
pos = g_pListOfObjectsThatRequestedHandles->GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
prevPos = pos;
|
|
pObj = (T126Obj*)g_pListOfObjectsThatRequestedHandles->GetNext(pos);
|
|
if(pObj == pObjRequest)
|
|
{
|
|
g_pListOfObjectsThatRequestedHandles->RemoveAt(prevPos);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
UINT GetSIPDUObjectHandle(SIPDU * sipdu)
|
|
{
|
|
UINT ObjectHandle = 0;
|
|
|
|
switch(sipdu->choice)
|
|
{
|
|
case bitmapAbortPDU_chosen:
|
|
ObjectHandle = sipdu->u.bitmapAbortPDU.bitmapHandle;
|
|
break;
|
|
|
|
case bitmapCheckpointPDU_chosen:
|
|
ObjectHandle = sipdu->u.bitmapCheckpointPDU.bitmapHandle;
|
|
break;
|
|
|
|
case bitmapCreatePDU_chosen:
|
|
ObjectHandle = sipdu->u.bitmapCreatePDU.bitmapHandle;
|
|
break;
|
|
|
|
case bitmapCreateContinuePDU_chosen:
|
|
ObjectHandle = sipdu->u.bitmapCreateContinuePDU.bitmapHandle;
|
|
break;
|
|
|
|
case bitmapDeletePDU_chosen:
|
|
ObjectHandle = sipdu->u.bitmapDeletePDU.bitmapHandle;
|
|
break;
|
|
|
|
case bitmapEditPDU_chosen:
|
|
ObjectHandle = sipdu->u.bitmapEditPDU.bitmapHandle;
|
|
break;
|
|
|
|
case drawingCreatePDU_chosen:
|
|
ObjectHandle = sipdu->u.drawingCreatePDU.drawingHandle;
|
|
break;
|
|
|
|
case drawingDeletePDU_chosen:
|
|
ObjectHandle = sipdu->u.drawingDeletePDU.drawingHandle;
|
|
break;
|
|
|
|
case drawingEditPDU_chosen:
|
|
ObjectHandle = sipdu->u.drawingEditPDU.drawingHandle;
|
|
break;
|
|
|
|
case siNonStandardPDU_chosen:
|
|
ObjectHandle = ((TEXTPDU_HEADER*) sipdu->u.siNonStandardPDU.nonStandardTransaction.data.value)->textHandle;
|
|
break;
|
|
|
|
case workspaceCreatePDU_chosen:
|
|
ObjectHandle = WorkspaceObj::GetWorkspaceIdentifier(&sipdu->u.workspaceCreatePDU.workspaceIdentifier);
|
|
break;
|
|
|
|
case workspaceCreateAcknowledgePDU_chosen:
|
|
ObjectHandle = WorkspaceObj::GetWorkspaceIdentifier(&sipdu->u.workspaceCreateAcknowledgePDU.workspaceIdentifier);
|
|
break;
|
|
|
|
case workspaceDeletePDU_chosen:
|
|
ObjectHandle = WorkspaceObj::GetWorkspaceIdentifier(&sipdu->u.workspaceDeletePDU.workspaceIdentifier);
|
|
break;
|
|
|
|
case workspaceEditPDU_chosen:
|
|
ObjectHandle = WorkspaceObj::GetWorkspaceIdentifier(&sipdu->u.workspaceEditPDU.workspaceIdentifier);
|
|
break;
|
|
|
|
case workspacePlaneCopyPDU_chosen:
|
|
ObjectHandle = WorkspaceObj::GetWorkspaceIdentifier(&sipdu->u.workspacePlaneCopyPDU.sourceWorkspaceIdentifier);
|
|
break;
|
|
|
|
case workspaceReadyPDU_chosen:
|
|
ObjectHandle = WorkspaceObj::GetWorkspaceIdentifier(&sipdu->u.workspaceReadyPDU.workspaceIdentifier);
|
|
break;
|
|
|
|
}
|
|
|
|
return ObjectHandle;
|
|
|
|
|
|
}
|
|
|
|
|
|
BOOL RemoveObjectFromResendList(T126Obj * pObjRequest)
|
|
{
|
|
BOOL bRemoved = FALSE;
|
|
SIPDU* pPDU;
|
|
WBPOSITION pos;
|
|
WBPOSITION prevPos;
|
|
|
|
UINT objectHandle = pObjRequest->GetThisObjectHandle();
|
|
pos = g_pRetrySendList->GetHeadPosition();
|
|
while (pos != NULL)
|
|
{
|
|
prevPos = pos;
|
|
pPDU = (SIPDU*)g_pRetrySendList->GetNext(pos);
|
|
if(GetSIPDUObjectHandle(pPDU) == objectHandle)
|
|
{
|
|
g_pRetrySendList->RemoveAt(prevPos);
|
|
SIPDUCleanUp(pPDU);
|
|
bRemoved = TRUE;
|
|
}
|
|
}
|
|
|
|
return bRemoved;
|
|
}
|
|
|
|
|
|
|
|
|
|
void RemoveRemotePointer(MEMBER_ID nMemberID)
|
|
{
|
|
//
|
|
// Resend all objects
|
|
//
|
|
WBPOSITION pos;
|
|
WBPOSITION posObj;
|
|
WorkspaceObj* pWorkspace;
|
|
ULONG ownerID;
|
|
T126Obj* pObj;
|
|
pos = g_pListOfWorkspaces->GetHeadPosition();
|
|
while(pos)
|
|
{
|
|
pWorkspace = (WorkspaceObj*)g_pListOfWorkspaces->GetNext(pos);
|
|
if(pWorkspace)
|
|
{
|
|
posObj = pWorkspace->GetHeadPosition();
|
|
while(posObj)
|
|
{
|
|
pObj = pWorkspace->GetNextObject(posObj);
|
|
if(pObj && pObj->GraphicTool() == TOOLTYPE_REMOTEPOINTER)
|
|
{
|
|
ownerID = GET_NODE_ID_FROM_MEMBER_ID(pObj->GetOwnerID());
|
|
|
|
TRACE_DEBUG(("RemoveRemotePointer ownerID=%x member that left =%x " , ownerID, nMemberID));
|
|
|
|
|
|
if(ownerID != g_MyMemberID)
|
|
{
|
|
if(nMemberID)
|
|
{
|
|
if(nMemberID == ownerID)
|
|
{
|
|
pWorkspace->RemoveT126Object(pObj);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pWorkspace->RemoveT126Object(pObj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Syncronize page
|
|
//
|
|
if(g_pCurrentWorkspace)
|
|
{
|
|
g_pCurrentWorkspace->SetViewActionChoice(editView_chosen);
|
|
g_pCurrentWorkspace->OnObjectEdit();
|
|
}
|
|
}
|
|
|
|
|
|
BOOL IsThereAnythingInAnyWorkspace(void)
|
|
{
|
|
WBPOSITION pos;
|
|
WBPOSITION posObj;
|
|
WorkspaceObj* pWorkspace;
|
|
T126Obj* pObj;
|
|
pos = g_pListOfWorkspaces->GetHeadPosition();
|
|
while(pos)
|
|
{
|
|
pWorkspace = (WorkspaceObj*)g_pListOfWorkspaces->GetNext(pos);
|
|
if(pWorkspace)
|
|
{
|
|
posObj = pWorkspace->GetHeadPosition();
|
|
while(posObj)
|
|
{
|
|
pObj = pWorkspace->GetNextObject(posObj);
|
|
if(pObj)
|
|
{
|
|
if(pObj->GraphicTool() != TOOLTYPE_REMOTEPOINTER)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// UI Edited the Workspace Object
|
|
//
|
|
void WorkspaceObj::OnObjectEdit(void)
|
|
{
|
|
|
|
g_bContentsChanged = TRUE;
|
|
|
|
//
|
|
// If we are not synced don't bug the other nodes
|
|
//
|
|
if(!g_pDraw->IsSynced())
|
|
{
|
|
return;
|
|
}
|
|
|
|
SIPDU *sipdu = NULL;
|
|
DBG_SAVE_FILE_LINE
|
|
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
|
if(!sipdu)
|
|
{
|
|
TRACE_MSG(("Failed to create sipdu"));
|
|
::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
|
|
return;
|
|
}
|
|
|
|
sipdu->choice = workspaceEditPDU_chosen;
|
|
CreateWorkspaceEditPDU(&sipdu->u.workspaceEditPDU);
|
|
T120Error rc = SendT126PDU(sipdu);
|
|
if(rc == T120_NO_ERROR)
|
|
{
|
|
SIPDUCleanUp(sipdu);
|
|
ResetAttrib();
|
|
}
|
|
}
|
|
|
|
//
|
|
// UI Deleted the Workspace Object
|
|
//
|
|
void WorkspaceObj::OnObjectDelete(void)
|
|
{
|
|
SIPDU *sipdu = NULL;
|
|
DBG_SAVE_FILE_LINE
|
|
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
|
if(sipdu)
|
|
{
|
|
sipdu->choice = workspaceDeletePDU_chosen;
|
|
CreateWorkspaceDeletePDU(&sipdu->u.workspaceDeletePDU);
|
|
T120Error rc = SendT126PDU(sipdu);
|
|
if(rc == T120_NO_ERROR)
|
|
{
|
|
SIPDUCleanUp(sipdu);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRACE_MSG(("Failed to create sipdu"));
|
|
::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
|
|
}
|
|
}
|
|
|
|
void WorkspaceObj::GetEncodedCreatePDU(ASN1_BUF *pBuf)
|
|
{
|
|
SIPDU *sipdu = NULL;
|
|
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
|
if(sipdu)
|
|
{
|
|
sipdu->choice = workspaceCreatePDU_chosen;
|
|
CreateWorkspaceCreatePDU(&sipdu->u.workspaceCreatePDU);
|
|
ASN1_BUF encodedPDU;
|
|
g_pCoder->Encode(sipdu, pBuf);
|
|
delete sipdu->u.workspaceCreatePDU.planeParameters->value.usage;
|
|
delete sipdu->u.workspaceCreatePDU.planeParameters;
|
|
delete [] sipdu;
|
|
}
|
|
else
|
|
{
|
|
TRACE_MSG(("Failed to create sipdu"));
|
|
::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void SendWorkspaceRefreshPDU(BOOL bImtheRefresher)
|
|
{
|
|
SIPDU *sipdu = NULL;
|
|
DBG_SAVE_FILE_LINE
|
|
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
|
if(sipdu)
|
|
{
|
|
sipdu->choice = workspaceRefreshStatusPDU_chosen;
|
|
sipdu->u.workspaceRefreshStatusPDU.bit_mask = 0;
|
|
sipdu->u.workspaceRefreshStatusPDU.refreshStatus = (ASN1bool_t)bImtheRefresher;
|
|
T120Error rc = SendT126PDU(sipdu);
|
|
if(rc == T120_NO_ERROR)
|
|
{
|
|
SIPDUCleanUp(sipdu);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRACE_MSG(("Failed to create sipdu"));
|
|
::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// UI Created a new Workspace Object
|
|
//
|
|
void WorkspaceObj::SendNewObjectToT126Apps(void)
|
|
{
|
|
SIPDU *sipdu = NULL;
|
|
DBG_SAVE_FILE_LINE
|
|
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
|
if(sipdu)
|
|
{
|
|
sipdu->choice = workspaceCreatePDU_chosen;
|
|
CreateWorkspaceCreatePDU(&sipdu->u.workspaceCreatePDU);
|
|
TRACE_DEBUG(("Sending Workspace >> Workspace handle = %d", sipdu->u.workspaceCreatePDU.workspaceIdentifier.u.activeWorkspace ));
|
|
T120Error rc = SendT126PDU(sipdu);
|
|
if(rc == T120_NO_ERROR)
|
|
{
|
|
SIPDUCleanUp(sipdu);
|
|
}
|
|
|
|
SetAllAttribs();
|
|
SetViewActionChoice(createNewView_chosen);
|
|
SetViewState(focus_chosen);
|
|
OnObjectEdit();
|
|
}
|
|
else
|
|
{
|
|
TRACE_MSG(("Failed to create sipdu"));
|
|
::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void WorkspaceObj::GetWorkSpaceViewEditParam(PWorkspaceEditPDU_viewEdits pViewEdits)
|
|
{
|
|
m_viewHandle = pViewEdits->value.viewHandle;
|
|
TRACE_DEBUG(("GetWorkSpaceViewEditParam View Handle = %d", m_viewHandle));
|
|
TRACE_DEBUG(("GetWorkSpaceViewEditParam View Choice = %d", pViewEdits->value.action.choice));
|
|
|
|
switch(pViewEdits->value.action.choice)
|
|
{
|
|
case(createNewView_chosen):
|
|
{
|
|
GetWorkSpaceViewParam((PWorkspaceCreatePDU_viewParameters_Set_viewAttributes)pViewEdits->value.action.u.createNewView);
|
|
}
|
|
break;
|
|
|
|
case(editView_chosen):
|
|
{
|
|
GetWorkSpaceViewParam((PWorkspaceCreatePDU_viewParameters_Set_viewAttributes)pViewEdits->value.action.u.editView);
|
|
}
|
|
break;
|
|
|
|
case(deleteView_chosen):
|
|
{
|
|
;
|
|
}
|
|
break;
|
|
|
|
// case(nonStandardAction_chosen):
|
|
// {
|
|
// }
|
|
// break;
|
|
|
|
default:
|
|
WARNING_OUT(("Invalid workspace view attribute"));
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void WorkspaceObj::GetWorkSpaceViewParam(PWorkspaceCreatePDU_viewParameters_Set_viewAttributes pViewAttributes)
|
|
{
|
|
|
|
PWorkspaceCreatePDU_viewParameters_Set_viewAttributes attributes;
|
|
attributes = pViewAttributes;
|
|
while(attributes)
|
|
{
|
|
switch(attributes->value.choice)
|
|
{
|
|
case (viewRegion_chosen):
|
|
{
|
|
|
|
switch(attributes->value.u.viewRegion.choice)
|
|
{
|
|
case(fullWorkspace_chosen):
|
|
{
|
|
m_viewRegion.top = 0;
|
|
m_viewRegion.left = 0;
|
|
m_viewRegion.bottom = m_workspaceSize.x;
|
|
m_viewRegion.right = m_workspaceSize.y;
|
|
TRACE_DEBUG(("fullWorkspace_chosen View Region = (%d, %d)(%d, %d)",
|
|
m_viewRegion.top,
|
|
m_viewRegion.left,
|
|
m_viewRegion.bottom,
|
|
m_viewRegion.right));
|
|
|
|
}
|
|
case(partialWorkspace_chosen):
|
|
{
|
|
m_viewRegion.top = attributes->value.u.viewRegion.u.partialWorkspace.upperLeft.yCoordinate;
|
|
m_viewRegion.left = attributes->value.u.viewRegion.u.partialWorkspace.upperLeft.xCoordinate;
|
|
m_viewRegion.bottom = attributes->value.u.viewRegion.u.partialWorkspace.upperLeft.yCoordinate;
|
|
m_viewRegion.right = attributes->value.u.viewRegion.u.partialWorkspace.upperLeft.xCoordinate;
|
|
TRACE_DEBUG(("partialWorkspace_chosen View Region = (%d, %d)(%d, %d)",
|
|
m_viewRegion.top,
|
|
m_viewRegion.left,
|
|
m_viewRegion.bottom,
|
|
m_viewRegion.right));
|
|
}
|
|
break;
|
|
default:
|
|
ERROR_OUT(("Invalid view region choice"));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case (WorkspaceViewAttribute_viewState_chosen):
|
|
{
|
|
SetViewState(attributes->value.u.viewState.choice);
|
|
TRACE_DEBUG(("View state = %d", attributes->value.u.viewState.choice));
|
|
}
|
|
break;
|
|
|
|
case (updatesEnabled_chosen):
|
|
{
|
|
SetUpdatesEnabled(attributes->value.u.updatesEnabled);
|
|
if(!m_bUpdatesEnabled)
|
|
{
|
|
g_pNMWBOBJ->m_LockerID = GetOwnerID();
|
|
}
|
|
|
|
TRACE_DEBUG(("Updates enabled = %d", m_bUpdatesEnabled));
|
|
}
|
|
break;
|
|
|
|
// case (sourceDisplayIndicator_chosen):
|
|
// {
|
|
// JOSEF what we do with these??????
|
|
// attributes->value.u.sourceDisplayIndicator.displayAspectRatio;
|
|
// attributes->value.u.sourceDisplayIndicator.horizontalSizeRatio;
|
|
// attributes->value.u.sourceDisplayIndicator.horizontalPosition;
|
|
// attributes->value.u.sourceDisplayIndicator.verticalPosition;
|
|
//
|
|
// }
|
|
// break;
|
|
|
|
default:
|
|
WARNING_OUT(("Invalid workspace view attribute"));
|
|
break;
|
|
}
|
|
attributes = attributes->next;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// JOSEF The following is not used but is part of the standard
|
|
// It is removed because we don't need it now
|
|
// We may need to add it for interop in the future
|
|
//
|
|
#ifdef _DEBUG
|
|
|
|
void WorkspaceObj::SetBackGroundColor(COLORREF rgb)
|
|
{
|
|
m_backgroundColor.rgbtRed = GetRValue(rgb);
|
|
m_backgroundColor.rgbtGreen = GetGValue(rgb);
|
|
m_backgroundColor.rgbtBlue = GetBValue(rgb);
|
|
}
|
|
|
|
|
|
|
|
|
|
void WorkspaceObj::GetWorkSpaceAttrib(PWorkspaceCreatePDU_workspaceAttributes pWorkspaceAttributes)
|
|
{
|
|
|
|
PWorkspaceCreatePDU_workspaceAttributes attributes;
|
|
attributes = pWorkspaceAttributes;
|
|
COLORREF rgb;
|
|
while(attributes)
|
|
{
|
|
switch(attributes->value.choice)
|
|
{
|
|
case(backgroundColor_chosen):
|
|
{
|
|
switch(attributes->value.u.backgroundColor.choice)
|
|
{
|
|
// case(workspacePaletteIndex_chosen):
|
|
// {
|
|
// ASN1uint16_t workspacePaletteIndex = ((attributes->value.u.backgroundColor).u).workspacePaletteIndex;
|
|
// break;
|
|
// }
|
|
case(rgbTrueColor_chosen):
|
|
{
|
|
rgb = RGB(attributes->value.u.backgroundColor.u.rgbTrueColor.r,
|
|
attributes->value.u.backgroundColor.u.rgbTrueColor.g,
|
|
attributes->value.u.backgroundColor.u.rgbTrueColor.b);
|
|
SetBackGroundColor(rgb);
|
|
TRACE_DEBUG(("Attribute penColor (r,g,b)=(%d, %d,%d)",
|
|
attributes->value.u.backgroundColor.u.rgbTrueColor.r,
|
|
attributes->value.u.backgroundColor.u.rgbTrueColor.g,
|
|
attributes->value.u.backgroundColor.u.rgbTrueColor.b));
|
|
break;
|
|
}
|
|
case(transparent_chosen):
|
|
{
|
|
SetBackGroundColor(0);
|
|
TRACE_DEBUG(("Backgroundcolor transparent"));
|
|
break;
|
|
}
|
|
default:
|
|
ERROR_OUT(("Invalid backgroundColor choice"));
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case(preserve_chosen):
|
|
{
|
|
m_bPreserve = attributes->value.u.preserve;
|
|
TRACE_DEBUG(("m_bPreserve %d", m_bPreserve));
|
|
}
|
|
break;
|
|
}
|
|
|
|
attributes = attributes->next;
|
|
}
|
|
|
|
}
|
|
|
|
void WorkspaceObj::GetWorkSpacePlaneParam(PWorkspaceCreatePDU_planeParameters pPlaneParameters)
|
|
{
|
|
|
|
TRACE_DEBUG(("GetWorkSpacePlaneParam NYI"));
|
|
|
|
;
|
|
}
|
|
#endif // 0
|
|
|
|
|
|
|
|
void TogleLockInAllWorkspaces(BOOL bLock, BOOL bResend)
|
|
{
|
|
WorkspaceObj * pWorkspace;
|
|
WBPOSITION pos = g_pListOfWorkspaces->GetHeadPosition();
|
|
while (pos)
|
|
{
|
|
pWorkspace = (WorkspaceObj *) g_pListOfWorkspaces->GetNext(pos);
|
|
|
|
pWorkspace->SetUpdatesEnabled(!bLock);
|
|
if(bResend)
|
|
{
|
|
pWorkspace->SetViewActionChoice(editView_chosen);
|
|
pWorkspace->OnObjectEdit();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|