able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/netmeeting/ui/wb/mcshelp.cpp

1431 lines
31 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "precomp.h"
#include "gcchelp.h"
#include "coder.hpp"
#include "drawobj.hpp"
#include "NMWbObj.h"
extern Coder * g_pCoder;
UINT AllocateFakeGCCHandle(void)
{
return g_localGCCHandle++;
}
void SetFakeGCCHandle(UINT fakeGCCHandle)
{
g_localGCCHandle = fakeGCCHandle;
}
//
// Add drawings/bitmaps etc... to workspace
//
BOOL AddT126ObjectToWorkspace(T126Obj *pObj)
{
WorkspaceObj * pWorkspace = GetWorkspace(pObj->GetWorkspaceHandle());
if(pWorkspace)
{
pWorkspace->AddTail(pObj);
g_numberOfObjects++;
return TRUE;
}
else
{
WARNING_OUT(("Object sent to invalid workspace %d, will be deleted now!!!", GetWorkspace(pObj->GetWorkspaceHandle())));
delete pObj;
return FALSE;
}
}
//
// Cleanup for all pdus we send
//
void SIPDUCleanUp(SIPDU *sipdu)
{
switch(sipdu->choice)
{
//
// Simple cleanup
//
case bitmapDeletePDU_chosen:
case drawingDeletePDU_chosen:
case workspaceDeletePDU_chosen:
case workspaceRefreshStatusPDU_chosen:
break;
//
// Bitmap Create cleanup
//
case bitmapCreatePDU_chosen:
{
if(sipdu->u.bitmapCreatePDU.nonStandardParameters)
{
delete sipdu->u.bitmapCreatePDU.nonStandardParameters;
}
PBitmapCreatePDU_attributes pAttrib;
PBitmapCreatePDU_attributes pNextAttrib;
pAttrib = sipdu->u.bitmapCreatePDU.attributes;
while(pAttrib)
{
pNextAttrib = pAttrib->next;
delete pAttrib;
pAttrib = pNextAttrib;
}
}
break;
case bitmapEditPDU_chosen:
{
BitmapEditPDU_attributeEdits * pAttrib;
BitmapEditPDU_attributeEdits * pNextAttrib;
pAttrib = sipdu->u.bitmapEditPDU.attributeEdits;
while(pAttrib)
{
pNextAttrib = pAttrib->next;
delete pAttrib;
pAttrib = pNextAttrib;
}
}
break;
//
// Bitmap Continue cleanup
//
case bitmapCreateContinuePDU_chosen:
{
if(sipdu->u.bitmapCreateContinuePDU.nonStandardParameters)
{
delete sipdu->u.bitmapCreateContinuePDU.nonStandardParameters;
}
}
break;
//
// Drawing Edit Cleanup
//
case drawingEditPDU_chosen:
{
if(sipdu->u.drawingEditPDU.bit_mask & DrawingEditPDU_attributeEdits_present)
{
PDrawingEditPDU_attributeEdits pAttrib;
PDrawingEditPDU_attributeEdits pNextAttrib;
pAttrib = sipdu->u.drawingEditPDU.attributeEdits;
while(pAttrib)
{
pNextAttrib = pAttrib->next;
delete pAttrib;
pAttrib = pNextAttrib;
}
}
if(sipdu->u.drawingEditPDU.pointListEdits.value[0].subsequentPointEdits.u.pointsDiff16)
{
PPointList_pointsDiff16 drawingPoint = sipdu->u.drawingEditPDU.pointListEdits.value[0].subsequentPointEdits.u.pointsDiff16;
PPointList_pointsDiff16 drawingPointNext = drawingPoint;
while(drawingPointNext)
{
drawingPointNext = drawingPoint->next;
delete drawingPoint;
drawingPoint = drawingPointNext;
}
}
}
break;
//
// Drawing Edit cleanup
//
case drawingCreatePDU_chosen:
{
PDrawingCreatePDU_attributes pNextAttrib;
PDrawingCreatePDU_attributes pAttrib;
pAttrib = sipdu->u.drawingCreatePDU.attributes;
while(pAttrib)
{
pNextAttrib = pAttrib->next;
delete pAttrib;
pAttrib = pNextAttrib;
}
PPointList_pointsDiff16 pNextPoint;
PPointList_pointsDiff16 pPoint;
pPoint = sipdu->u.drawingCreatePDU.pointList.u.pointsDiff16;
while(pPoint)
{
pNextPoint = pPoint->next;
delete pPoint;
pPoint = pNextPoint;
}
}
break;
//
// Non Standard cleanup
//
case siNonStandardPDU_chosen:
if(sipdu->u.siNonStandardPDU.nonStandardTransaction.data.value)
{
delete sipdu->u.siNonStandardPDU.nonStandardTransaction.data.value;
}
break;
//
// Workspace Edit cleanup
//
case workspaceEditPDU_chosen:
{
if(sipdu->u.workspaceEditPDU.bit_mask & viewEdits_present)
{
PWorkspaceEditPDU_viewEdits_Set_action_editView pEditView = sipdu->u.workspaceEditPDU.viewEdits->value.action.u.editView;
PWorkspaceEditPDU_viewEdits_Set_action_editView pNextEditView = pEditView;
while(pNextEditView)
{
pNextEditView = pEditView->next;
delete pEditView;
pEditView = pNextEditView;
}
delete sipdu->u.workspaceEditPDU.viewEdits;
}
}
break;
//
// Workspace Create cleanup
//
case workspaceCreatePDU_chosen:
{
if(sipdu->u.workspaceCreatePDU.viewParameters)
{
if(sipdu->u.workspaceCreatePDU.viewParameters->value.viewAttributes)
{
delete sipdu->u.workspaceCreatePDU.viewParameters->value.viewAttributes;
}
delete sipdu->u.workspaceCreatePDU.viewParameters;
}
if(sipdu->u.workspaceCreatePDU.planeParameters)
{
PWorkspaceCreatePDU_planeParameters_Seq_usage pNextUsage;
PWorkspaceCreatePDU_planeParameters_Seq_usage pUsage = sipdu->u.workspaceCreatePDU.planeParameters->value.usage;
while(pUsage)
{
pNextUsage = pUsage->next;
delete pUsage;
pUsage = pNextUsage;
}
delete sipdu->u.workspaceCreatePDU.planeParameters->value.planeAttributes;
PWorkspaceCreatePDU_planeParameters pNextPlaneParameters;
PWorkspaceCreatePDU_planeParameters pPlaneParameters = sipdu->u.workspaceCreatePDU.planeParameters;
while(pPlaneParameters)
{
pNextPlaneParameters = pPlaneParameters->next;
delete pPlaneParameters;
pPlaneParameters = pNextPlaneParameters;
}
}
}
break;
default:
ERROR_OUT(("UNKNOWN PDU TYPE = %d we may leak memory", sipdu->choice));
break;
}
delete sipdu;
}
//
// Cleans the retry list, when we close down or disconnect
//
void DeleteAllRetryPDUS(void)
{
SIPDU * sipdu;
while((sipdu = (SIPDU *)g_pRetrySendList->RemoveTail()) != NULL)
{
SIPDUCleanUp(sipdu);
}
}
//
// Retry sending buffered pdus and send the new pdu
//
T120Error SendT126PDU(SIPDU * pPDU)
{
MLZ_EntryOut(ZONE_FUNCTION, "SendT126PDU");
//
// First send buffered pdus
//
RetrySend();
//
// Now send the current pdu
//
T120Error rc = SendPDU(pPDU, FALSE);
return rc;
}
//
// Retry sending pdus that couldn't be sent before
//
void RetrySend(void)
{
MLZ_EntryOut(ZONE_FUNCTION, "RetrySend");
if(g_fWaitingForBufferAvailable)
{
return;
}
TRACE_MSG(("RetrySend"));
SIPDU * sipdu;
while((sipdu = (SIPDU *)g_pRetrySendList->RemoveTail()) != NULL)
{
TRACE_DEBUG(("RetrySend sipdu->choice = %d", sipdu->choice));
T120Error rc = SendPDU(sipdu, TRUE);
if(rc == T120_NO_ERROR)
{
TRACE_DEBUG(("RetrySend OK!!!"));
SIPDUCleanUp(sipdu);
}
else
{
TRACE_DEBUG(("RetrySend Failed"));
break;
}
}
}
//
// Send T126 pdus down to the conference
//
T120Error SendPDU(SIPDU * pPDU, BOOL bRetry)
{
MLZ_EntryOut(ZONE_FUNCTION, "SendPDU");
T120Error rc = T120_NO_ERROR;
//
// If we are in a conference
//
if(g_pNMWBOBJ->IsInConference() || g_bSavingFile)
{
ASN1_BUF encodedPDU;
g_pCoder->Encode(pPDU, &encodedPDU);
if(g_bSavingFile)
{
g_pMain->ObjectSave(TYPE_T126_ASN_OBJECT, encodedPDU.value, encodedPDU.length);
}
else
{
if(!g_fWaitingForBufferAvailable)
{
T120Priority ePriority = APPLET_LOW_PRIORITY;
if(pPDU->choice == workspaceCreatePDU_chosen ||
pPDU->choice == workspaceEditPDU_chosen ||
pPDU->choice == workspaceDeletePDU_chosen)
{
//
// Do what the standard says send the pdus in 3 different priorities
//
TRACE_MSG(("SendPDU sending PDU length = %d in APPLET_HIGH_PRIORITY", encodedPDU.length));
rc = g_pNMWBOBJ->SendData(APPLET_HIGH_PRIORITY,
encodedPDU.length,
encodedPDU.value);
TRACE_MSG(("SendPDU sending PDU length = %d in APPLET_MEDIUM_PRIORITY", encodedPDU.length));
if(rc == T120_NO_ERROR)
{
rc = g_pNMWBOBJ->SendData(APPLET_MEDIUM_PRIORITY,
encodedPDU.length,
encodedPDU.value);
}
}
TRACE_MSG(("SendPDU sending PDU length = %d in APPLET_LOW_PRIORITY", encodedPDU.length));
if(rc == T120_NO_ERROR)
{
rc = g_pNMWBOBJ->SendData(ePriority,
encodedPDU.length,
encodedPDU.value);
}
if(rc == MCS_TRANSMIT_BUFFER_FULL)
{
g_fWaitingForBufferAvailable = TRUE;
//
// We need to add it back to the correct position
//
if(bRetry)
{
g_pRetrySendList->AddTail(pPDU);
}
else
{
g_pRetrySendList->AddHead(pPDU);
}
}
}
else
{
rc = MCS_TRANSMIT_BUFFER_FULL;
g_pRetrySendList->AddHead(pPDU);
}
}
// Free the encoder memory
g_pCoder->Free(encodedPDU);
}
return rc;
}
BOOL T126_MCSSendDataIndication(ULONG uSize, LPBYTE pb, ULONG memberID, BOOL bResend)
{
BOOL bRet = TRUE;
SIPDU * pDecodedPDU;
ASN1_BUF InputBuffer;
InputBuffer.length = uSize;
InputBuffer.value = pb;
//
// Decode incoming PDU
if(ASN1_SUCCEEDED(g_pCoder->Decode(&InputBuffer, &pDecodedPDU)))
{
switch(pDecodedPDU->choice)
{
// case (archiveAcknowledgePDU_chosen):
// {
// TRACE_DEBUG((">>> Received a archiveAcknowledgePDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (archiveClosePDU_chosen):
// {
// TRACE_DEBUG((">>> Received a archiveClosePDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (archiveErrorPDU_chosen):
// {
// TRACE_DEBUG((">>> Received a archiveErrorPDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (archiveOpenPDU_chosen):
// {
// TRACE_DEBUG((">>> Received a archiveOpenPDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
case (bitmapAbortPDU_chosen):
{
TRACE_DEBUG((">>> Received a bitmapAbortPDU"));
OnBitmapAbortPDU(&pDecodedPDU->u.bitmapAbortPDU, memberID);
break;
}
case (bitmapCheckpointPDU_chosen):
{
TRACE_DEBUG((">>> Received a bitmapCheckpointPDU"));
OnBitmapCheckpointPDU(&pDecodedPDU->u.bitmapCheckpointPDU, memberID);
break;
}
case (bitmapCreatePDU_chosen):
{
TRACE_DEBUG((">>> Received a bitmapCreatePDU"));
OnBitmapCreatePDU(&pDecodedPDU->u.bitmapCreatePDU, memberID, bResend);
break;
}
case (bitmapCreateContinuePDU_chosen):
{
TRACE_DEBUG((">>> Received a bitmapCreateContinuePDU"));
OnBitmapCreateContinuePDU(&pDecodedPDU->u.bitmapCreateContinuePDU, memberID, bResend);
break;
}
case (bitmapDeletePDU_chosen):
{
TRACE_DEBUG((">>> Received a bitmapDeletePDU"));
OnBitmapDeletePDU(&pDecodedPDU->u.bitmapDeletePDU, memberID);
break;
}
case (bitmapEditPDU_chosen):
{
TRACE_DEBUG((">>> Received a bitmapEditPDU"));
OnBitmapEditPDU(&pDecodedPDU->u.bitmapEditPDU, memberID);
break;
}
case (conductorPrivilegeGrantPDU_chosen):
{
TRACE_DEBUG((">>> Received a conductorPrivilegeGrantPDU"));
TRACE_DEBUG(("No action taken"));
break;
}
case (conductorPrivilegeRequestPDU_chosen):
{
TRACE_DEBUG((">>> Received a conductorPrivilegeRequestPDU"));
TRACE_DEBUG(("No action taken"));
break;
}
case (drawingCreatePDU_chosen):
{
TRACE_DEBUG((">>> Received a drawingCreatePDU"));
OnDrawingCreatePDU(&pDecodedPDU->u.drawingCreatePDU, memberID, bResend);
break;
}
case (drawingDeletePDU_chosen):
{
TRACE_DEBUG((">>> Received a drawingDeletePDU"));
OnDrawingDeletePDU(&pDecodedPDU->u.drawingDeletePDU, memberID);
break;
}
case (drawingEditPDU_chosen):
{
TRACE_DEBUG((">>> Received a drawingEditPDU"));
OnDrawingEditPDU(&pDecodedPDU->u.drawingEditPDU, memberID, bResend);
break;
}
// case (remoteEventPermissionGrantPDU_chosen):
// {
// TRACE_DEBUG((">>> Received a remoteEventPermissionGrantPDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (remoteEventPermissionRequestPDU_chosen):
// {
// TRACE_DEBUG((">>> Received a remoteEventPermissionRequestPDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (remoteKeyboardEventPDU_chosen):
// {
// TRACE_DEBUG((">>> Received a remoteKeyboardEventPDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (remotePointingDeviceEventPDU_chosen):
// {
// TRACE_DEBUG((">>> Received a remotePointingDeviceEventPDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (remotePrintPDU_chosen):
// {
// TRACE_DEBUG((">>> Received a remotePrintPDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
case (siNonStandardPDU_chosen):
{
if(pDecodedPDU->u.siNonStandardPDU.nonStandardTransaction.nonStandardIdentifier.choice == h221nonStandard_chosen)
{
PT126_VENDORINFO pVendorInfo = (PT126_VENDORINFO)pDecodedPDU->u.siNonStandardPDU.nonStandardTransaction.nonStandardIdentifier.u.h221nonStandard.value;
if (!lstrcmp((LPSTR)&pVendorInfo->nonstandardString, NonStandardTextID))
{
TEXTPDU_HEADER *pHeader = (TEXTPDU_HEADER*) pDecodedPDU->u.siNonStandardPDU.nonStandardTransaction.data.value;
switch(pHeader->nonStandardPDU)
{
case textCreatePDU_chosen:
TRACE_DEBUG((">>> Received a textCreatePDU_chosen"));
OnTextCreatePDU((MSTextPDU*)pHeader, memberID, bResend);
break;
case textEditPDU_chosen:
TRACE_DEBUG((">>> Received a textEditPDU_chosen"));
OnTextEditPDU((MSTextPDU*)pHeader, memberID);
break;
case textDeletePDU_chosen:
TRACE_DEBUG((">>> Received a textDeletePDU_chosen"));
OnTextDeletePDU(pHeader, memberID);
break;
default:
TRACE_DEBUG(("Invalid text pdu"));
break;
}
}
}
break;
}
case (workspaceCreatePDU_chosen):
{
TRACE_DEBUG((">>> Received a workspaceCreatePDU"));
OnWorkspaceCreatePDU(&pDecodedPDU->u.workspaceCreatePDU, memberID, bResend);
break;
}
case (workspaceCreateAcknowledgePDU_chosen):
{
TRACE_DEBUG((">>> Received a workspaceCreateAcknowledgePDU"));
OnWorkspaceCreateAcknowledgePDU(&pDecodedPDU->u.workspaceCreateAcknowledgePDU, memberID);
break;
}
case (workspaceDeletePDU_chosen):
{
TRACE_DEBUG((">>> Received a workspaceDeletePDU"));
OnWorkspaceDeletePDU(&pDecodedPDU->u.workspaceDeletePDU, memberID);
break;
}
case (workspaceEditPDU_chosen):
{
TRACE_DEBUG((">>> Received a workspaceEditPDU"));
OnWorkspaceEditPDU(&pDecodedPDU->u.workspaceEditPDU, memberID);
break;
}
case (workspacePlaneCopyPDU_chosen):
{
TRACE_DEBUG((">>> Received a workspacePlaneCopyPDU"));
OnWorkspacePlaneCopyPDU(&pDecodedPDU->u.workspacePlaneCopyPDU, memberID);
break;
}
case (workspaceReadyPDU_chosen):
{
TRACE_DEBUG((">>> Received a workspaceReadyPDU"));
OnWorkspaceReadyPDU(&pDecodedPDU->u.workspaceReadyPDU, memberID);
break;
}
case (workspaceRefreshStatusPDU_chosen):
{
TRACE_DEBUG((">>> Received a workspaceRefreshStatusPDU"));
OnWorkspaceRefreshStatusPDU(&pDecodedPDU->u.workspaceRefreshStatusPDU, memberID);
break;
}
// case (fontPDU_chosen):
// {
// TRACE_DEBUG((">>> Received a fontPDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (textCreatePDU_chosen):
// {
// TRACE_DEBUG((">>> Received a textCreatePDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (textDeletePDU_chosen):
// {
// TRACE_DEBUG((">>> Received a textDeletePDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (textEditPDU_chosen):
// {
// TRACE_DEBUG((">>> Received a textEditPDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (videoWindowCreatePDU_chosen):
// {
// TRACE_DEBUG((">>> Received a videoWindowCreatePDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (videoWindowDeleatePDU_chosen):
// {
// TRACE_DEBUG((">>> Received a videoWindowDeleatePDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
// case (videoWindowEditPDU_chosen):
// {
// TRACE_DEBUG((">>> Received a videoWindowEditPDU"));
// TRACE_DEBUG(("No action taken"));
// break;
// }
default:
bRet = FALSE;
TRACE_DEBUG(("Receive an Unhandled PDU choice = %d", pDecodedPDU->choice));
break;
}
}
//
// Free the decoded pdu
// JOSEF: for performance in the future we could pass
// the decoded buffer to the ui, avoiding more memory allocation.
// But it will be hard to read the code, since the T126 structures
// are a bit confusing.
//
g_pCoder->Free(pDecodedPDU);
return bRet;
}
//
// Delete All Workspaces sent and received
//
void DeleteAllWorkspaces(BOOL sendPDU)
{
T126Obj * pObj;
if(g_pDraw && g_pDraw->m_pTextEditor)
{
g_pDraw->m_pTextEditor->AbortEditGently();
}
g_pCurrentWorkspace = NULL;
g_pConferenceWorkspace = NULL;
while ((pObj = (T126Obj *)g_pListOfWorkspaces->RemoveTail()) != NULL)
{
if(sendPDU)
{
pObj->DeletedLocally();
}
else
{
pObj->ClearDeletionFlags();
}
delete pObj;
}
if(g_pMain)
{
g_pMain->EnableToolbar(FALSE);
g_pMain->UpdatePageButtons();
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// TEXT PDUS
/////////////////////////////////////////////////////////////////////////////////////////////
void OnTextCreatePDU(MSTextPDU* pCreatePDU, ULONG memberID, BOOL bForcedResend)
{
WorkspaceObj* pWObj;
WbTextEditor * pText;
//
// Check for resend
//
if(!bForcedResend)
{
pWObj = GetWorkspace(pCreatePDU->header.workspaceHandle);
if(pWObj)
{
pText = (WbTextEditor *)pWObj->FindObjectInWorkspace(pCreatePDU->header.textHandle);
if(pText)
{
TRACE_DEBUG(("drawingHandle already used = %d", pCreatePDU->header.textHandle ));
return;
}
}
}
//
// New Drawing object
//
DBG_SAVE_FILE_LINE
pText = new WbTextEditor();
pText->SetWorkspaceHandle(pCreatePDU->header.workspaceHandle);
pText->SetThisObjectHandle(pCreatePDU->header.textHandle);
if(!bForcedResend)
{
//
// Some one sent us this drawing, it is not created locally
//
pText->ClearCreationFlags();
//
// Add a this drawing to the correct workspace
//
if(!AddT126ObjectToWorkspace(pText))
{
return;
}
}
else
{
//
// Add this object and send Create PDU
//
pText->SetAllAttribs();
pText->SetWorkspaceHandle(g_pCurrentWorkspace == NULL ? 0 : g_pCurrentWorkspace->GetWorkspaceHandle());
pText->ClearSelectionFlags();
pText->GetTextAttrib(&pCreatePDU->attrib);
pText->AddToWorkspace();
pText->Draw();
return;
}
pText->TextEditObj(&pCreatePDU->attrib);
pText->Draw();
pText->ResetAttrib();
}
void OnTextDeletePDU(TEXTPDU_HEADER *pHeader, ULONG memberID)
{
T126Obj* pText;
WorkspaceObj* pWorkspace;
// We should find this drawing object
if(FindObjectAndWorkspace(pHeader->textHandle, (T126Obj**)&pText, (WorkspaceObj**)&pWorkspace))
{
pText->SetOwnerID(memberID);
pWorkspace->RemoveT126Object(pText);
}
}
void OnTextEditPDU(MSTextPDU *pEditPDU, ULONG memberID)
{
TextObj* pText;
WorkspaceObj* pWorkspace;
// We should find this drawing object
if(FindObjectAndWorkspace(pEditPDU->header.textHandle, (T126Obj **)&pText, (WorkspaceObj**)&pWorkspace))
{
pText->SetOwnerID(memberID);
pText->TextEditObj(&pEditPDU->attrib);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// DRAWING PDUS
/////////////////////////////////////////////////////////////////////////////////////////////
void OnDrawingCreatePDU(DrawingCreatePDU * pdrawingCreatePDU, ULONG memberID, BOOL bForcedResend)
{
WorkspaceObj* pWObj;
DrawObj * pDraw;
UINT workspace;
UINT planeID;
//
// If we don't have a drawing handle dont take it
//
if(!(pdrawingCreatePDU->bit_mask & drawingHandle_present))
{
TRACE_DEBUG(("Got a DrawingCreatePDU but no drawingHandle" ));
return;
}
GetDrawingDestinationAddress(&pdrawingCreatePDU->destinationAddress, &workspace, &planeID);
//
// Check for resend
//
if(!bForcedResend)
{
pWObj = GetWorkspace(workspace);
if(pWObj)
{
pDraw = (DrawObj *)pWObj->FindObjectInWorkspace(pdrawingCreatePDU->drawingHandle);
if(pDraw)
{
TRACE_DEBUG(("drawingHandle already used = %d", pdrawingCreatePDU->drawingHandle ));
return;
}
}
}
//
// New Drawing object
//
DBG_SAVE_FILE_LINE
pDraw = new DrawObj(pdrawingCreatePDU);
pDraw->SetOwnerID(memberID);
if(!bForcedResend)
{
//
// Some one sent us this drawing, it is not created locally
//
pDraw->ClearCreationFlags();
//
// Add a this drawing to the correct workspace
//
if(!AddT126ObjectToWorkspace(pDraw))
{
return;
}
}
else
{
//
// Add this object and send Create PDU
//
pDraw->SetAllAttribs();
pDraw->SetWorkspaceHandle(g_pCurrentWorkspace == NULL ? 0 : g_pCurrentWorkspace->GetWorkspaceHandle());
pDraw->ClearSelectionFlags();
pDraw->AddToWorkspace();
pDraw->Draw();
return;
}
//
// Draw it
//
if(pDraw->GetPenThickness())
{
pDraw->Draw();
pDraw->ResetAttrib();
}
}
void OnDrawingDeletePDU(DrawingDeletePDU * pdrawingDeletePDU, ULONG memberID)
{
DrawObj* pDraw;
WorkspaceObj* pWorkspace;
// We should find this drawing object
if(FindObjectAndWorkspace(pdrawingDeletePDU->drawingHandle, (T126Obj **)&pDraw, (WorkspaceObj**)&pWorkspace))
{
pDraw->SetOwnerID(memberID);
pWorkspace->RemoveT126Object((T126Obj*)pDraw);
}
}
void OnDrawingEditPDU(DrawingEditPDU * pdrawingEditPDU, ULONG memberID, BOOL bResend)
{
DrawObj* pDraw;
WorkspaceObj* pWorkspace;
// We should find this drawing object
if(FindObjectAndWorkspace(pdrawingEditPDU->drawingHandle, (T126Obj **)&pDraw, (WorkspaceObj**)&pWorkspace))
{
pDraw->SetOwnerID(memberID);
pDraw->DrawEditObj(pdrawingEditPDU);
}
else
{
//
// We are reading this pdu from disk add the rest of the line to the previous freehand drawing
//
if(bResend)
{
T126Obj * pObj;
pObj = g_pCurrentWorkspace->GetTail();
if(pObj && pObj->GetType() == drawingCreatePDU_chosen &&
(pObj->GraphicTool() == TOOLTYPE_PEN || pObj->GraphicTool() == TOOLTYPE_HIGHLIGHT))
{
pdrawingEditPDU->drawingHandle = pObj->GetThisObjectHandle();
pObj->SetOwnerID(memberID);
((DrawObj*)pObj)->DrawEditObj(pdrawingEditPDU);
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// WORKSPACE PDUS
/////////////////////////////////////////////////////////////////////////////////////////////
BOOL FindObjectAndWorkspace(UINT objectHandle, T126Obj** pObj, WorkspaceObj**pWorkspace)
{
WorkspaceObj * pWrkspc;
T126Obj * pT126Obj;
WBPOSITION pos;
pos = g_pListOfWorkspaces->GetHeadPosition();
while (pos != NULL)
{
pWrkspc = (WorkspaceObj *) g_pListOfWorkspaces->GetNext(pos);
if(pWrkspc)
{
pT126Obj = pWrkspc->FindObjectInWorkspace(objectHandle);
if(pT126Obj)
{
*pObj = pT126Obj;
*pWorkspace = pWrkspc;
return TRUE;
}
}
}
return FALSE;
}
//
// Retrieves workspace from the list of workspaces
//
WorkspaceObj * GetWorkspace(UINT activeWorkspace)
{
WorkspaceObj * pWorkspaceObj;
WBPOSITION pos;
pos = g_pListOfWorkspaces->GetHeadPosition();
while (pos != NULL)
{
pWorkspaceObj = (WorkspaceObj *) g_pListOfWorkspaces->GetNext(pos);
if(pWorkspaceObj->GetWorkspaceHandle() == activeWorkspace)
{
return pWorkspaceObj;
}
}
return NULL;
}
//
// The remote sent us a new workspace
//
void OnWorkspaceCreatePDU(WorkspaceCreatePDU * pWorkspaceCreatePDU, ULONG memberID, BOOL bForcedResend)
{
TRACE_DEBUG(("OnWorkspaceCreatePDU WorkspaceIdentifier = %d", pWorkspaceCreatePDU->workspaceIdentifier.u.activeWorkspace));
WorkspaceObj * pWorkspaceObj;
//
// Check for resend
//
if(!bForcedResend)
{
pWorkspaceObj = GetWorkspace(WorkspaceObj::GetWorkspaceIdentifier(&pWorkspaceCreatePDU->workspaceIdentifier));
if(pWorkspaceObj)
{
return;
}
DBG_SAVE_FILE_LINE
pWorkspaceObj = new WorkspaceObj(pWorkspaceCreatePDU, bForcedResend);
pWorkspaceObj->SetOwnerID(memberID);
}
else
{
DBG_SAVE_FILE_LINE
pWorkspaceObj = new WorkspaceObj(pWorkspaceCreatePDU, bForcedResend);
pWorkspaceObj->SetOwnerID(memberID);
}
}
//
// If we created an unsynchronized workspace the remote has to sen us
// a WorkspaceCreateAcknowledgePDU. Why???
//
void OnWorkspaceCreateAcknowledgePDU(WorkspaceCreateAcknowledgePDU * pWorkspaceCreateAcknowledgePDU, ULONG memberID)
{
TRACE_DEBUG(("OnWorkspaceCreateAcknowledgePDU WorkspaceIdentifier = %d", pWorkspaceCreateAcknowledgePDU->workspaceIdentifier));
}
//
// The remote is deleting the workspace
//
void OnWorkspaceDeletePDU(WorkspaceDeletePDU * pWorkspaceDeletePDU, ULONG memberID)
{
TRACE_DEBUG(("OnWorkspaceDeletePDU WorkspaceIdentifier = %d", pWorkspaceDeletePDU->workspaceIdentifier.u.activeWorkspace));
//
// Find the workspace
//
WorkspaceObj * pWorkspaceObj;
pWorkspaceObj = GetWorkspace(WorkspaceObj::GetWorkspaceIdentifier(&pWorkspaceDeletePDU->workspaceIdentifier));
if(!pWorkspaceObj)
{
return;
}
pWorkspaceObj->SetOwnerID(memberID);
pWorkspaceObj->ClearDeletionFlags();
//
// Reason for deleting
//
TRACE_DEBUG(("OnWorkspaceDeletePDU reason = %d", pWorkspaceDeletePDU->reason.choice));
//
// Remove it from the List Of Workspaces
//
WBPOSITION prevPos;
WBPOSITION pos;
pos = g_pListOfWorkspaces->GetPosition(pWorkspaceObj);
prevPos = g_pListOfWorkspaces->GetHeadPosition();
//
// This is the only workspace we have ?????
//
if(g_pListOfWorkspaces->GetHeadPosition() == g_pListOfWorkspaces->GetTailPosition())
{
RemoveWorkspace(pWorkspaceObj);
g_pCurrentWorkspace = NULL;
if(g_pMain)
{
g_pMain->EnableToolbar(FALSE);
}
}
else
{
//
// If we had a remote pointer
//
BOOL bRemote = FALSE;
if(g_pMain->m_pLocalRemotePointer)
{
bRemote = TRUE;
g_pMain->OnRemotePointer();
}
//
// Remove the workspace and point the current one to the correct one.
//
pWorkspaceObj = RemoveWorkspace(pWorkspaceObj);
g_pConferenceWorkspace = pWorkspaceObj;
if(g_pDraw->IsSynced())
{
g_pMain->GoPage(pWorkspaceObj,FALSE);
}
//
// If we had a remote pointer
//
if(bRemote)
{
g_pMain->OnRemotePointer();
}
}
}
//
// The remote is changing the workspace
//
void OnWorkspaceEditPDU(WorkspaceEditPDU * pWorkspaceEditPDU, ULONG memberID)
{
TRACE_DEBUG(("OnWorkspaceEditPDU WorkspaceIdentifier = %d",pWorkspaceEditPDU->workspaceIdentifier.u.activeWorkspace));
//
// Find the workspace
//
WorkspaceObj * pWorkspaceObj;
pWorkspaceObj = GetWorkspace(WorkspaceObj::GetWorkspaceIdentifier(&pWorkspaceEditPDU->workspaceIdentifier));
if(!pWorkspaceObj)
{
return;
}
pWorkspaceObj->SetOwnerID(memberID);
pWorkspaceObj->WorkspaceEditObj(pWorkspaceEditPDU);
}
void OnWorkspacePlaneCopyPDU(WorkspacePlaneCopyPDU * pWorkspacePlaneCopyPDU, ULONG memberID)
{
TRACE_DEBUG(("OnWorkspacePlaneCopyPDU WorkspaceIdentifier = %d",pWorkspacePlaneCopyPDU->sourceWorkspaceIdentifier));
}
void OnWorkspaceReadyPDU(WorkspaceReadyPDU * pWorkspaceReadyPDU, ULONG memberID)
{
TRACE_DEBUG(("OnWorkspaceReadyPDU WorkspaceIdentifier = %d",pWorkspaceReadyPDU->workspaceIdentifier));
//
// Find the workspace
//
WorkspaceObj * pWorkspaceObj;
pWorkspaceObj = GetWorkspace(WorkspaceObj::GetWorkspaceIdentifier(&pWorkspaceReadyPDU->workspaceIdentifier));
if(!pWorkspaceObj)
{
return;
}
pWorkspaceObj->SetOwnerID(memberID);
//
// This workspace is ready
//
pWorkspaceObj->m_bWorkspaceReady = TRUE;
}
//
// If we got a refreshStatus == TRUE, we have to refresh late joiners
//
void OnWorkspaceRefreshStatusPDU(WorkspaceRefreshStatusPDU * pWorkspaceRefreshStatusPDU, ULONG memberID)
{
if (pWorkspaceRefreshStatusPDU->refreshStatus == TRUE)
{
g_RefresherID = memberID;
}
else
{
//
// The token is out there, try to grab it
//
g_pNMWBOBJ->GrabRefresherToken();
}
}
/////////////////////////////////////////////////////////////////////////////////////////////
// BITMAP PDUS
/////////////////////////////////////////////////////////////////////////////////////////////
void OnBitmapCreatePDU(BitmapCreatePDU * pBitmapCreatePDU, ULONG memberID, BOOL bForcedResend)
{
TRACE_DEBUG(("drawingHandle = %d", pBitmapCreatePDU->bitmapHandle ));
//
// If we find this object, it is because T120 is broadcasting the drawing
// we just sent to T126
//
UINT workspace;
UINT planeID;
GetBitmapDestinationAddress(&pBitmapCreatePDU->destinationAddress, &workspace, &planeID);
//
// Check for resend
//
WorkspaceObj* pWObj;
BitmapObj * pBitmap;
if(!bForcedResend)
{
pWObj = GetWorkspace(workspace);
if(pWObj)
{
pBitmap = (BitmapObj*)pWObj->FindObjectInWorkspace(pBitmapCreatePDU->bitmapHandle);
if(pBitmap)
return;
}
}
//
// New Drawing object
//
DBG_SAVE_FILE_LINE
pBitmap = new BitmapObj(pBitmapCreatePDU);
pBitmap->SetOwnerID(memberID);
if(!bForcedResend)
{
//
// Someone else sent us this bitmap, it was not created locally
//
pBitmap->ClearCreationFlags();
//
// Add a this drawing to the correct workspace
//
if(!AddT126ObjectToWorkspace(pBitmap))
{
return;
}
}
else
{
//
// If we are reading from disk, this has to be added in the current workspace
// and we have to wait until we have the whole bitmap to send it
//
if(pBitmap->m_fMoreToFollow)
{
pBitmap->SetWorkspaceHandle(g_pCurrentWorkspace == NULL ? 0 : g_pCurrentWorkspace->GetWorkspaceHandle());
AddT126ObjectToWorkspace(pBitmap);
}
else
{
//
// Add this object and send Create PDU
//
pBitmap->SetAllAttribs();
pBitmap->AddToWorkspace();
}
}
//
// PASS IT TO UI
//
if(!pBitmap->m_fMoreToFollow)
{
pBitmap->Draw();
}
}
void OnBitmapCreateContinuePDU(BitmapCreateContinuePDU * pBitmapCreateContinuePDU, ULONG memberID, BOOL bForcedResend)
{
WorkspaceObj* pWorkspace;
BitmapObj* pBitmap = NULL;
// We should find this drawing object
//
// If we are loading from file it is in the current workspace
//
if(bForcedResend)
{
ASSERT(g_pCurrentWorkspace);
if(g_pCurrentWorkspace)
{
pBitmap = (BitmapObj*)g_pCurrentWorkspace->FindObjectInWorkspace(pBitmapCreateContinuePDU->bitmapHandle);
}
}
else
{
FindObjectAndWorkspace(pBitmapCreateContinuePDU->bitmapHandle, (T126Obj **)&pBitmap, (WorkspaceObj**)&pWorkspace);
}
if(pBitmap)
{
pBitmap->SetOwnerID(memberID);
//
// Found the previous bitmap, concatenate the data
//
pBitmap->Continue(pBitmapCreateContinuePDU);
//
// PASS IT TO UI
//
if(!pBitmap->m_fMoreToFollow)
{
pBitmap->Draw();
if(bForcedResend)
{
pBitmap->SetAllAttribs();
pBitmap->AddToWorkspace();
}
}
}
}
void OnBitmapCheckpointPDU(BitmapCheckpointPDU * pBitmapCheckPointPDU, ULONG memberID)
{
}
void OnBitmapAbortPDU(BitmapAbortPDU * pBitmapAbortPDU, ULONG memberID)
{
BitmapDeletePDU bitmapDeletePDU;
bitmapDeletePDU.bitmapHandle = pBitmapAbortPDU->bitmapHandle;
bitmapDeletePDU.bit_mask = 0;
//
// Pass it to bitmapDeletePDU
//
OnBitmapDeletePDU(&bitmapDeletePDU, memberID);
}
void OnBitmapEditPDU(BitmapEditPDU * pBitmapEditPDU, ULONG memberID)
{
BitmapObj* pObj;
WorkspaceObj* pWorkspace;
// We should find this drawing object
if(FindObjectAndWorkspace(pBitmapEditPDU->bitmapHandle, (T126Obj **)&pObj, (WorkspaceObj**)&pWorkspace))
{
pObj->SetOwnerID(memberID);
pObj->BitmapEditObj(pBitmapEditPDU);
}
}
void OnBitmapDeletePDU(BitmapDeletePDU * pBitmapDeletePDU, ULONG memberID)
{
BitmapObj* pObj;
WorkspaceObj* pWorkspace;
// We should find this drawing object
if(FindObjectAndWorkspace(pBitmapDeletePDU->bitmapHandle, (T126Obj **)&pObj, (WorkspaceObj**)&pWorkspace))
{
pObj->SetOwnerID(memberID);
pWorkspace->RemoveT126Object((T126Obj*)pObj);
}
}
Reference in a new issue Copy permalink