windows-server-2003/enduser/netmeeting/ui/wb/wrkspobj.cpp

//
// 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();
		}
	}
}