mirror of https://github.com/tongzx/nt5src
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.
1867 lines
41 KiB
1867 lines
41 KiB
//
|
|
// DRAWOBJ.CPP
|
|
// Drawing objects: point, openpolyline, closepolyline, ellipse
|
|
//
|
|
// Copyright Microsoft 1998-
|
|
//
|
|
#include "precomp.h"
|
|
|
|
#define DECIMAL_PRECISION 100
|
|
|
|
|
|
DrawObj::DrawObj(UINT drawingType, UINT toolType):
|
|
m_drawingType(drawingType),
|
|
m_isDrawingCompleted(FALSE)
|
|
{
|
|
SetMyWorkspace(NULL);
|
|
SetOwnerID(g_MyMemberID);
|
|
|
|
m_ToolType = toolType;
|
|
|
|
//
|
|
// Created locally, not selected, not editing or deleting.
|
|
//
|
|
CreatedLocally();
|
|
ClearSelectionFlags();
|
|
ClearEditionFlags();
|
|
ClearDeletionFlags();
|
|
|
|
SetFillColor(0,FALSE);
|
|
|
|
//
|
|
// No attributes changed, they will be set as we change them
|
|
//
|
|
ResetAttrib();
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
m_points = new DCDWordArray();
|
|
SetWorkspaceHandle(g_pCurrentWorkspace == NULL ? 0 : g_pCurrentWorkspace->GetWorkspaceHandle());
|
|
SetType(drawingCreatePDU_chosen);
|
|
SetPenNib(circular_chosen);
|
|
SetROP(R2_NOTXORPEN);
|
|
SetPlaneID(1);
|
|
SetMyPosition(NULL);
|
|
SetMyWorkspace(NULL);
|
|
|
|
|
|
RECT rect;
|
|
::SetRectEmpty(&rect);
|
|
SetBoundsRect(&rect);
|
|
SetRect(&rect);
|
|
|
|
}
|
|
|
|
DrawObj::DrawObj (DrawingCreatePDU * pdrawingCreatePDU)
|
|
{
|
|
SetType(drawingCreatePDU_chosen);
|
|
SetMyWorkspace(NULL);
|
|
|
|
//
|
|
// Created remotely, not selected, not editing or deleting.
|
|
//
|
|
ClearCreationFlags();
|
|
ClearSelectionFlags();
|
|
ClearEditionFlags();
|
|
ClearDeletionFlags();
|
|
|
|
ResetAttrib();
|
|
|
|
//
|
|
// Get the drawing handle
|
|
//
|
|
SetThisObjectHandle(pdrawingCreatePDU->drawingHandle);
|
|
|
|
//
|
|
// Get the destination address
|
|
//
|
|
UINT workspaceHandle;
|
|
UINT planeID;
|
|
GetDrawingDestinationAddress(&pdrawingCreatePDU->destinationAddress, &workspaceHandle, &planeID);
|
|
SetWorkspaceHandle(workspaceHandle);
|
|
SetPlaneID(planeID);
|
|
TRACE_DEBUG(("Destination address, Workspace Handle = %d", workspaceHandle));
|
|
TRACE_DEBUG(("Destination address, Plane ID = %d", planeID));
|
|
|
|
//
|
|
// Get the drawing type, line, circle, etc ...
|
|
//
|
|
SetDrawingType(pdrawingCreatePDU->drawingType.choice);
|
|
|
|
//
|
|
// Set defaults
|
|
//
|
|
// m_T126Drawing.m_sampleRate = INVALID_SAMPLE_RATE;
|
|
|
|
//
|
|
// Default attributes
|
|
//
|
|
// Pen color black
|
|
SetPenColor(0,TRUE);
|
|
// No fill color
|
|
SetFillColor(0,FALSE);
|
|
// 1 Pixels for pen thickness
|
|
SetPenThickness(1);
|
|
// Pen Nib is circular
|
|
SetPenNib(circular_chosen);
|
|
// Solid line
|
|
SetLineStyle(PS_SOLID);
|
|
// No highlight
|
|
SetHighlight(FALSE);
|
|
// Not selected
|
|
SetViewState(unselected_chosen);
|
|
// Top object
|
|
SetZOrder(front);
|
|
|
|
// This is a complete drawing
|
|
SetIsCompleted(TRUE);
|
|
|
|
//
|
|
// Get attributes
|
|
//
|
|
if(pdrawingCreatePDU->bit_mask & DrawingCreatePDU_attributes_present)
|
|
{
|
|
GetDrawingAttrib((PVOID)pdrawingCreatePDU->attributes);
|
|
}
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
m_points = new DCDWordArray();
|
|
|
|
//
|
|
// Get Anchor point
|
|
//
|
|
POINT Point;
|
|
|
|
//
|
|
// For open polylines the first point will be an offset of the anchor point
|
|
//
|
|
if(pdrawingCreatePDU->drawingType.choice == openPolyLine_chosen)
|
|
{
|
|
Point.x = 0;
|
|
Point.y = 0;
|
|
AddPoint(Point);
|
|
}
|
|
|
|
SetAnchorPoint(pdrawingCreatePDU->anchorPoint.xCoordinate, pdrawingCreatePDU->anchorPoint.yCoordinate);
|
|
GetAnchorPoint(&Point);
|
|
RECT rect;
|
|
rect.left = pdrawingCreatePDU->anchorPoint.xCoordinate;
|
|
rect.top = pdrawingCreatePDU->anchorPoint.yCoordinate;
|
|
rect.right = pdrawingCreatePDU->anchorPoint.xCoordinate;
|
|
rect.bottom = pdrawingCreatePDU->anchorPoint.yCoordinate;
|
|
SetRect(&rect);
|
|
SetBoundsRect(&rect);
|
|
AddPointToBounds(pdrawingCreatePDU->anchorPoint.xCoordinate, pdrawingCreatePDU->anchorPoint.yCoordinate);
|
|
|
|
//
|
|
// Since we don't know ahead of time how many points we have, set the type as a polyline
|
|
//
|
|
m_ToolType = TOOLTYPE_PEN;
|
|
|
|
//
|
|
// Get consecutive points
|
|
//
|
|
UINT nPoints;
|
|
nPoints = GetSubsequentPoints(pdrawingCreatePDU->pointList.choice, &Point, &pdrawingCreatePDU->pointList);
|
|
|
|
//
|
|
// Find out what UI tool are we, and set the correct ROP
|
|
//
|
|
SetUIToolType();
|
|
|
|
|
|
if(nPoints == 1)
|
|
{
|
|
POINT *point;
|
|
point = m_points->GetBuffer();
|
|
rect.right = point->x + pdrawingCreatePDU->anchorPoint.xCoordinate;
|
|
rect.bottom = point->y + pdrawingCreatePDU->anchorPoint.yCoordinate;
|
|
SetRect(&rect);
|
|
::InflateRect(&rect, GetPenThickness()/2, GetPenThickness()/2);
|
|
SetBoundsRect(&rect);
|
|
}
|
|
|
|
//
|
|
// Get Non standard stuff
|
|
//
|
|
if(pdrawingCreatePDU->bit_mask & DrawingCreatePDU_nonStandardParameters_present)
|
|
{
|
|
; // NYI
|
|
}
|
|
|
|
|
|
}
|
|
|
|
DrawObj::~DrawObj( void )
|
|
{
|
|
RemoveObjectFromResendList(this);
|
|
RemoveObjectFromRequestHandleList(this);
|
|
|
|
TRACE_DEBUG(("drawingHandle = %d", GetThisObjectHandle() ));
|
|
|
|
//
|
|
// Tell other nodes that we are gone
|
|
//
|
|
if(GetMyWorkspace() != NULL && WasDeletedLocally())
|
|
{
|
|
OnObjectDelete();
|
|
}
|
|
|
|
//
|
|
// Clear the list of points
|
|
//
|
|
delete m_points;
|
|
|
|
}
|
|
|
|
void DrawObj::DrawEditObj ( DrawingEditPDU * pdrawingEditPDU )
|
|
{
|
|
|
|
RECT rect;
|
|
POSITION pos;
|
|
POINT anchorPoint;
|
|
LONG deltaX = 0;
|
|
LONG deltaY = 0;
|
|
|
|
TRACE_DEBUG(("DrawEditObj drawingHandle = %d", pdrawingEditPDU->drawingHandle ));
|
|
|
|
//
|
|
// Was edited remotely
|
|
//
|
|
ClearEditionFlags();
|
|
|
|
//
|
|
// Read attributes
|
|
//
|
|
if(pdrawingEditPDU->bit_mask & DrawingEditPDU_attributeEdits_present)
|
|
{
|
|
GetDrawingAttrib((PVOID)pdrawingEditPDU->attributeEdits);
|
|
}
|
|
|
|
//
|
|
// Change the anchor point
|
|
//
|
|
GetAnchorPoint(&anchorPoint);
|
|
if(pdrawingEditPDU->bit_mask & DrawingEditPDU_anchorPointEdit_present)
|
|
{
|
|
|
|
TRACE_DEBUG(("Old anchor point (%d,%d)", anchorPoint.x, anchorPoint.y));
|
|
TRACE_DEBUG(("New anchor point (%d,%d)",
|
|
pdrawingEditPDU->anchorPointEdit.xCoordinate, pdrawingEditPDU->anchorPointEdit.yCoordinate));
|
|
//
|
|
// Get the delta from previous anchor point
|
|
//
|
|
deltaX = pdrawingEditPDU->anchorPointEdit.xCoordinate - anchorPoint.x;
|
|
deltaY = pdrawingEditPDU->anchorPointEdit.yCoordinate - anchorPoint.y;
|
|
TRACE_DEBUG(("Delta (%d,%d)", deltaX , deltaY));
|
|
|
|
//
|
|
// Was edited remotely
|
|
//
|
|
ClearEditionFlags();
|
|
}
|
|
|
|
//
|
|
// Get Rotation
|
|
//
|
|
// if(pdrawingEditPDU->bit_mask & rotationEdit_present)
|
|
// {
|
|
// m_T126Drawing.m_rotation.m_bIsPresent = TRUE;
|
|
// m_T126Drawing.m_rotation.m_rotation.rotationAngle = pdrawingEditPDU->rotation.rotationAngle;
|
|
// m_T126Drawing.m_rotation.m_rotation.rotationAxis.xCoordinate = pdrawingEditPDU->rotation.rotationAxis.xCoordinate;
|
|
// m_T126Drawing.m_rotation.m_rotation.rotationAxis.yCoordinate = pdrawingEditPDU->rotation.rotationAxis.yCoordinate;
|
|
// }
|
|
// else
|
|
// {
|
|
// m_T126Drawing.m_rotation.m_bIsPresent = FALSE;
|
|
// }
|
|
|
|
|
|
//
|
|
// Get the list of points
|
|
//
|
|
if(pdrawingEditPDU->bit_mask & pointListEdits_present)
|
|
{
|
|
UINT i, initialIndex, xInitial,yInitial,numberOfPoints;
|
|
|
|
PointListEdits_Seq pointList;
|
|
POINT initialPoint;
|
|
|
|
TRACE_DEBUG(("Number of point edit lists %d", pdrawingEditPDU->pointListEdits.count));
|
|
|
|
|
|
for (i = 0; i<pdrawingEditPDU->pointListEdits.count; i++)
|
|
{
|
|
pointList = pdrawingEditPDU->pointListEdits.value[i];
|
|
initialIndex = pointList.initialIndex;
|
|
TRACE_DEBUG(("Points cached = %d", m_points->GetSize()));
|
|
TRACE_DEBUG(("initialIndex = %d", initialIndex));
|
|
initialPoint.x = pointList.initialPointEdit.xCoordinate;
|
|
initialPoint.y = pointList.initialPointEdit.yCoordinate;
|
|
|
|
POINT * pPoint = m_points->GetBuffer();
|
|
|
|
TRACE_DEBUG(("initialPoint=(%d, %d), previousPoint=(%d, %d), anchorPoint=(%d, %d)",
|
|
initialPoint.x, initialPoint.y,
|
|
pPoint[initialIndex-1].x, pPoint[initialIndex-1].y,
|
|
anchorPoint.x , anchorPoint.y
|
|
));
|
|
if(initialIndex > 1)
|
|
{
|
|
for(UINT i = 0; i< initialIndex; i++)
|
|
{
|
|
deltaX += pPoint[i].x;
|
|
deltaY += pPoint[i].y;
|
|
}
|
|
initialPoint.x -= deltaX;
|
|
initialPoint.y -= deltaY;
|
|
}
|
|
m_points->SetSize(initialIndex);
|
|
AddPoint(initialPoint);
|
|
|
|
if(GetDrawingType() == rectangle_chosen || GetDrawingType() == ellipse_chosen)
|
|
{
|
|
|
|
GetRect(&rect);
|
|
rect.right = initialPoint.x + anchorPoint.x;
|
|
rect.bottom = initialPoint.y + anchorPoint.y;
|
|
SetRect(&rect);
|
|
::InflateRect(&rect, GetPenThickness()/2, GetPenThickness()/2);
|
|
SetBoundsRect(&rect);
|
|
}
|
|
|
|
|
|
if(pointList.bit_mask & subsequentPointEdits_present)
|
|
{
|
|
GetSubsequentPoints(pointList.subsequentPointEdits.choice,
|
|
&anchorPoint,
|
|
&pointList.subsequentPointEdits);
|
|
|
|
}
|
|
ChangedPointList();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Just changed the anchor point, the other points have to change as well
|
|
//
|
|
if(pdrawingEditPDU->bit_mask & DrawingEditPDU_anchorPointEdit_present)
|
|
{
|
|
//
|
|
// Set new anchor point
|
|
//
|
|
anchorPoint.x = pdrawingEditPDU->anchorPointEdit.xCoordinate;
|
|
anchorPoint.y = pdrawingEditPDU->anchorPointEdit.yCoordinate;
|
|
SetAnchorPoint(anchorPoint.x, anchorPoint.y);
|
|
|
|
GetRect(&rect);
|
|
::OffsetRect(&rect, deltaX, deltaY);
|
|
SetRect(&rect);
|
|
|
|
GetBoundsRect(&rect);
|
|
::OffsetRect(&rect, deltaX, deltaY);
|
|
SetBoundsRect(&rect);
|
|
|
|
}
|
|
|
|
|
|
if(pdrawingEditPDU->bit_mask & DrawingEditPDU_nonStandardParameters_present)
|
|
{
|
|
; // Do the non Standard Edit PDU NYI
|
|
}
|
|
if(HasAnchorPointChanged() ||
|
|
HasPointListChanged() ||
|
|
HasFillColorChanged() ||
|
|
HasPenColorChanged()||
|
|
HasPenThicknessChanged()||
|
|
HasLineStyleChanged())
|
|
{
|
|
g_pDraw->EraseInitialDrawFinal(0 - deltaX,0 - deltaY, FALSE, (T126Obj*)this);
|
|
::InvalidateRect(g_pDraw->m_hwnd, NULL, TRUE);
|
|
|
|
}
|
|
else if(HasZOrderChanged())
|
|
{
|
|
if(GetZOrder() == front)
|
|
{
|
|
g_pDraw->BringToTopSelection(FALSE, this);
|
|
}
|
|
else
|
|
{
|
|
g_pDraw->SendToBackSelection(FALSE, this);
|
|
}
|
|
}
|
|
//
|
|
// If it just select/unselected it
|
|
//
|
|
else if(HasViewStateChanged())
|
|
{
|
|
; // do nothing
|
|
}
|
|
//
|
|
// If we have a valid pen.
|
|
//
|
|
else if(GetPenThickness())
|
|
{
|
|
Draw();
|
|
}
|
|
|
|
//
|
|
// Reset all the attributes
|
|
//
|
|
ResetAttrib();
|
|
}
|
|
|
|
|
|
void DrawObj::GetDrawingAttrib(PVOID pAttribPDU)
|
|
{
|
|
PDrawingEditPDU_attributeEdits attributes;
|
|
attributes = (PDrawingEditPDU_attributeEdits)pAttribPDU;
|
|
COLORREF rgb;
|
|
while(attributes)
|
|
{
|
|
switch(attributes->value.choice)
|
|
{
|
|
case(penColor_chosen):
|
|
{
|
|
switch(attributes->value.u.penColor.choice)
|
|
{
|
|
// case(workspacePaletteIndex_chosen):
|
|
// {
|
|
// ASN1uint16_t workspacePaletteIndex = ((attributes->value.u.penColor).u).workspacePaletteIndex;
|
|
// break;
|
|
// }
|
|
case(rgbTrueColor_chosen):
|
|
{
|
|
rgb = RGB(attributes->value.u.penColor.u.rgbTrueColor.r,
|
|
attributes->value.u.penColor.u.rgbTrueColor.g,
|
|
attributes->value.u.penColor.u.rgbTrueColor.b);
|
|
SetPenColor(rgb, TRUE);
|
|
TRACE_DEBUG(("Attribute penColor (r,g,b)=(%d, %d,%d)",
|
|
attributes->value.u.penColor.u.rgbTrueColor.r,
|
|
attributes->value.u.penColor.u.rgbTrueColor.g,
|
|
attributes->value.u.penColor.u.rgbTrueColor.b));
|
|
break;
|
|
}
|
|
case(transparent_chosen):
|
|
{
|
|
SetPenColor(0,FALSE);
|
|
break;
|
|
}
|
|
default:
|
|
ERROR_OUT(("Invalid penColor choice"));
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case(fillColor_chosen):
|
|
{
|
|
TRACE_DEBUG(("Attribute fillColor"));
|
|
switch(attributes->value.u.fillColor.choice)
|
|
{
|
|
// case(workspacePaletteIndex_chosen):
|
|
// {
|
|
// ASN1uint16_t workspacePaletteIndex = ((attributes->value.u.fillColor).u).workspacePaletteIndex;
|
|
// break;
|
|
// }
|
|
case(rgbTrueColor_chosen):
|
|
{
|
|
rgb = RGB(attributes->value.u.fillColor.u.rgbTrueColor.r,
|
|
attributes->value.u.fillColor.u.rgbTrueColor.g,
|
|
attributes->value.u.fillColor.u.rgbTrueColor.b);
|
|
SetFillColor(rgb, TRUE);
|
|
TRACE_DEBUG(("Attribute fillColor (r,g,b)=(%d, %d,%d)",
|
|
attributes->value.u.fillColor.u.rgbTrueColor.r,
|
|
attributes->value.u.fillColor.u.rgbTrueColor.g,
|
|
attributes->value.u.fillColor.u.rgbTrueColor.b));
|
|
break;
|
|
}
|
|
case(transparent_chosen):
|
|
{
|
|
SetFillColor(0,FALSE);
|
|
break;
|
|
}
|
|
default:
|
|
ERROR_OUT(("Invalid fillColor choice"));
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case(penThickness_chosen):
|
|
{
|
|
SetPenThickness(attributes->value.u.penThickness);
|
|
TRACE_DEBUG(("Attribute penThickness %d", attributes->value.u.penThickness));
|
|
break;
|
|
}
|
|
|
|
case(penNib_chosen):
|
|
{
|
|
if (attributes->value.u.penNib.choice != nonStandardNib_chosen)
|
|
{
|
|
SetPenNib(attributes->value.u.penNib.choice);
|
|
TRACE_DEBUG(("Attribute penNib %d",attributes->value.u.penNib.choice));
|
|
}
|
|
else
|
|
{
|
|
// Do the non Standard penNib NYI
|
|
;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case(lineStyle_chosen):
|
|
{
|
|
if((attributes->value.u.lineStyle).choice != nonStandardStyle_chosen)
|
|
{
|
|
SetLineStyle(attributes->value.u.lineStyle.choice - 1);
|
|
TRACE_DEBUG(("Attribute lineStyle %d", attributes->value.u.lineStyle.choice));
|
|
}
|
|
else
|
|
{
|
|
// Do the non Standard lineStyle NYI
|
|
;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case(highlight_chosen):
|
|
{
|
|
SetHighlight(attributes->value.u.highlight);
|
|
TRACE_DEBUG(("Attribute highlight %d", attributes->value.u.highlight));
|
|
break;
|
|
}
|
|
|
|
case(DrawingAttribute_viewState_chosen):
|
|
{
|
|
if((attributes->value.u.viewState).choice != nonStandardViewState_chosen)
|
|
{
|
|
SetViewState(attributes->value.u.viewState.choice);
|
|
|
|
//
|
|
// If the other node is selecting the drawing or unselecting
|
|
//
|
|
if(attributes->value.u.viewState.choice == selected_chosen)
|
|
{
|
|
SelectedRemotely();
|
|
}
|
|
else if(attributes->value.u.viewState.choice == unselected_chosen)
|
|
{
|
|
ClearSelectionFlags();
|
|
}
|
|
|
|
TRACE_DEBUG(("Attribute viewState %d", attributes->value.u.viewState.choice));
|
|
}
|
|
else
|
|
{
|
|
// Do the non Standard lineStyle NYI
|
|
;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case(DrawingAttribute_zOrder_chosen):
|
|
{
|
|
SetZOrder(attributes->value.u.zOrder);
|
|
TRACE_DEBUG(("Attribute zOrder %d", attributes->value.u.zOrder));
|
|
break;
|
|
|
|
}
|
|
case(DrawingAttribute_nonStandardAttribute_chosen):
|
|
{
|
|
break; // NYI
|
|
}
|
|
|
|
default:
|
|
ERROR_OUT(("Invalid attributes choice"));
|
|
break;
|
|
}
|
|
|
|
attributes = attributes->next;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
UINT DrawObj::GetSubsequentPoints(UINT choice, POINT * initialPoint, PointList * pointList)
|
|
{
|
|
UINT numberOfPoints = 0;
|
|
INT deltaX, deltaY;
|
|
|
|
POINT point;
|
|
if(choice == pointsDiff16_chosen)
|
|
{
|
|
PPointList_pointsDiff16 drawingPoint = pointList->u.pointsDiff16;
|
|
deltaX = (SHORT)initialPoint->x;
|
|
deltaY = (SHORT)initialPoint->y;
|
|
TRACE_DEBUG(("initialpoint (%d,%d)", deltaX, deltaY));
|
|
|
|
while(drawingPoint)
|
|
{
|
|
numberOfPoints++;
|
|
point.x = drawingPoint->value.xCoordinate;
|
|
point.y = drawingPoint->value.yCoordinate;
|
|
m_points->Add(point);
|
|
deltaX += point.x;
|
|
deltaY += point.y;
|
|
drawingPoint = drawingPoint->next;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRACE_DEBUG(("GetSubsequentPoints got points != pointsDiff16_chosen"));
|
|
}
|
|
|
|
TRACE_DEBUG(("Got %d points", numberOfPoints));
|
|
|
|
return numberOfPoints;
|
|
}
|
|
|
|
|
|
|
|
void DrawObj::CreateDrawingCreatePDU(DrawingCreatePDU *pCreatePDU)
|
|
{
|
|
int nPoints = 1;
|
|
pCreatePDU->bit_mask = 0;
|
|
|
|
//
|
|
// Pass the drawing Handle
|
|
//
|
|
pCreatePDU->bit_mask |=drawingHandle_present;
|
|
pCreatePDU->drawingHandle = GetThisObjectHandle();
|
|
|
|
//
|
|
// Pass the destination adress
|
|
//
|
|
pCreatePDU->destinationAddress.choice = DrawingDestinationAddress_softCopyAnnotationPlane_chosen;
|
|
pCreatePDU->destinationAddress.u.softCopyAnnotationPlane.workspaceHandle = GetWorkspaceHandle();
|
|
pCreatePDU->destinationAddress.u.softCopyAnnotationPlane.plane = (DataPlaneID)GetPlaneID();
|
|
|
|
//
|
|
// Pass the drawing type
|
|
//
|
|
pCreatePDU->drawingType.choice = (ASN1choice_t)GetDrawingType();
|
|
|
|
//
|
|
// Pass the attributes
|
|
//
|
|
SetDrawingAttrib(&pCreatePDU->attributes);
|
|
if(pCreatePDU->attributes != NULL)
|
|
{
|
|
pCreatePDU->bit_mask |=DrawingCreatePDU_attributes_present;
|
|
}
|
|
|
|
|
|
//
|
|
// Pass the anchor point
|
|
//
|
|
POINT point;
|
|
GetAnchorPoint(&point);
|
|
pCreatePDU->anchorPoint.xCoordinate = point.x;
|
|
pCreatePDU->anchorPoint.yCoordinate = point.y;
|
|
|
|
RECT rect;
|
|
GetRect(&rect);
|
|
|
|
|
|
pCreatePDU->pointList.choice = pointsDiff16_chosen;
|
|
DBG_SAVE_FILE_LINE
|
|
pCreatePDU->pointList.u.pointsDiff16 = (PPointList_pointsDiff16)new BYTE[sizeof(PointList_pointsDiff16)];
|
|
PPointList_pointsDiff16 drawingPoint = pCreatePDU->pointList.u.pointsDiff16;
|
|
PPointList_pointsDiff16 drawingPointLast = NULL;
|
|
drawingPoint->next = NULL;
|
|
|
|
switch(GetDrawingType())
|
|
{
|
|
|
|
case point_chosen:
|
|
drawingPoint->value.xCoordinate = 0;
|
|
drawingPoint->value.yCoordinate = 0;
|
|
drawingPoint->next = NULL;
|
|
break;
|
|
|
|
case openPolyLine_chosen:
|
|
case closedPolyLine_chosen:
|
|
case rectangle_chosen:
|
|
case ellipse_chosen:
|
|
{
|
|
UINT nPoints = m_points->GetSize();
|
|
UINT maxPoints = 1;
|
|
POINT * pPoint = m_points->GetBuffer();
|
|
while(nPoints && maxPoints < (MAX_POINT_LIST_VALUES + 1))
|
|
{
|
|
drawingPoint->value.xCoordinate = (SHORT)pPoint->x;
|
|
drawingPoint->value.yCoordinate = (SHORT)pPoint->y;
|
|
drawingPointLast = drawingPoint;
|
|
DBG_SAVE_FILE_LINE
|
|
drawingPoint->next = (PPointList_pointsDiff16)new BYTE[sizeof(PointList_pointsDiff16)];
|
|
drawingPoint = drawingPoint->next;
|
|
nPoints--;
|
|
pPoint++;
|
|
maxPoints++;
|
|
}
|
|
if(drawingPointLast)
|
|
{
|
|
delete drawingPointLast->next;
|
|
drawingPointLast->next = NULL;
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
void DrawObj::CreateDrawingEditPDU(DrawingEditPDU *pEditPDU)
|
|
{
|
|
pEditPDU->bit_mask = (ASN1uint16_t) GetPresentAttribs();
|
|
|
|
//
|
|
// Pass the anchor point
|
|
//
|
|
POINT point;
|
|
GetAnchorPoint(&point);
|
|
|
|
if(HasAnchorPointChanged())
|
|
{
|
|
pEditPDU->anchorPointEdit.xCoordinate = point.x;
|
|
pEditPDU->anchorPointEdit.yCoordinate = point.y;
|
|
}
|
|
|
|
pEditPDU->pointListEdits.value[0].subsequentPointEdits.u.pointsDiff16 = NULL;
|
|
|
|
//
|
|
// Pass point list changes
|
|
//
|
|
if(HasPointListChanged())
|
|
{
|
|
|
|
UINT nPoints = m_points->GetSize();
|
|
POINT * pPoint = m_points->GetBuffer();
|
|
|
|
pPoint = &pPoint[1];
|
|
|
|
//
|
|
// Just send the last 255 points
|
|
//
|
|
if(nPoints > 256)
|
|
{
|
|
pEditPDU->pointListEdits.value[0].initialIndex = nPoints - 256;
|
|
nPoints = 256;
|
|
}
|
|
else
|
|
{
|
|
pEditPDU->pointListEdits.value[0].initialIndex = 0;
|
|
}
|
|
|
|
//
|
|
// Calculate the initial point
|
|
//
|
|
point.x = 0;
|
|
point.y = 0;
|
|
for(UINT i = 0; i < pEditPDU->pointListEdits.value[0].initialIndex; i++)
|
|
{
|
|
point.x += pPoint[i].x;
|
|
point.y += pPoint[i].y;
|
|
}
|
|
|
|
pEditPDU->pointListEdits.count = 1;
|
|
pEditPDU->pointListEdits.value[0].bit_mask = subsequentPointEdits_present;
|
|
pEditPDU->pointListEdits.value[0].subsequentPointEdits.choice = pointsDiff16_chosen;
|
|
pEditPDU->pointListEdits.value[0].initialPointEdit.xCoordinate = (SHORT)point.x;
|
|
pEditPDU->pointListEdits.value[0].initialPointEdit.yCoordinate = (SHORT)point.y;
|
|
|
|
TRACE_DEBUG(("Sending List of points starting at Index = %d point(%d,%d)",
|
|
pEditPDU->pointListEdits.value[0].initialIndex, point.x, point.y));
|
|
|
|
|
|
pPoint = &pPoint[pEditPDU->pointListEdits.value[0].initialIndex];
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
pEditPDU->pointListEdits.value[0].subsequentPointEdits.u.pointsDiff16 = (PPointList_pointsDiff16)new BYTE[sizeof(PointList_pointsDiff16)];
|
|
PPointList_pointsDiff16 drawingPointLast = NULL;
|
|
PPointList_pointsDiff16 drawingPoint = pEditPDU->pointListEdits.value[0].subsequentPointEdits.u.pointsDiff16;
|
|
pEditPDU->pointListEdits.value[0].subsequentPointEdits.u.pointsDiff16->next = NULL;
|
|
pEditPDU->pointListEdits.value[0].subsequentPointEdits.u.pointsDiff16->value.xCoordinate = 0;
|
|
pEditPDU->pointListEdits.value[0].subsequentPointEdits.u.pointsDiff16->value.yCoordinate = 0;
|
|
|
|
|
|
nPoints--;
|
|
while(nPoints)
|
|
{
|
|
drawingPoint->value.xCoordinate = (SHORT)pPoint->x;
|
|
drawingPoint->value.yCoordinate = (SHORT)pPoint->y;
|
|
drawingPointLast = drawingPoint;
|
|
DBG_SAVE_FILE_LINE
|
|
drawingPoint->next = (PPointList_pointsDiff16)new BYTE[sizeof(PointList_pointsDiff16)];
|
|
drawingPoint = drawingPoint->next;
|
|
nPoints--;
|
|
pPoint++;
|
|
}
|
|
if(drawingPointLast)
|
|
{
|
|
delete drawingPointLast->next;
|
|
drawingPointLast->next = NULL;
|
|
}
|
|
}
|
|
|
|
//
|
|
// JOSEF Pass rotation if we ever do it (FEATURE)
|
|
//
|
|
|
|
//
|
|
// Pass all the changed attributes, if any.
|
|
//
|
|
if(pEditPDU->bit_mask & DrawingEditPDU_attributeEdits_present)
|
|
{
|
|
SetDrawingAttrib((PDrawingCreatePDU_attributes *)&pEditPDU->attributeEdits);
|
|
}
|
|
|
|
pEditPDU->drawingHandle = GetThisObjectHandle();
|
|
}
|
|
|
|
void DrawObj::CreateDrawingDeletePDU(DrawingDeletePDU *pDeletePDU)
|
|
{
|
|
pDeletePDU->bit_mask = 0;
|
|
pDeletePDU->drawingHandle = GetThisObjectHandle();
|
|
}
|
|
|
|
void DrawObj::AllocateAttrib(PDrawingCreatePDU_attributes *pAttributes)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
PDrawingCreatePDU_attributes pAttrib = (PDrawingCreatePDU_attributes)new BYTE[sizeof(DrawingCreatePDU_attributes)];
|
|
if(*pAttributes == NULL)
|
|
{
|
|
*pAttributes = pAttrib;
|
|
pAttrib->next = NULL;
|
|
}
|
|
else
|
|
{
|
|
((PDrawingCreatePDU_attributes)pAttrib)->next = *pAttributes;
|
|
*pAttributes = pAttrib;
|
|
}
|
|
}
|
|
|
|
void DrawObj::SetDrawingAttrib(PDrawingCreatePDU_attributes *pattributes)
|
|
{
|
|
|
|
PDrawingCreatePDU_attributes attributes = NULL;
|
|
RGBTRIPLE color;
|
|
|
|
//
|
|
// Do the pen Color
|
|
//
|
|
if(HasPenColorChanged())
|
|
{
|
|
if(GetPenColor(&color))
|
|
{
|
|
AllocateAttrib(&attributes);
|
|
attributes->value.choice = penColor_chosen;
|
|
attributes->value.u.penColor.choice = rgbTrueColor_chosen;
|
|
attributes->value.u.penColor.u.rgbTrueColor.r = color.rgbtRed;
|
|
attributes->value.u.penColor.u.rgbTrueColor.g = color.rgbtGreen;
|
|
attributes->value.u.penColor.u.rgbTrueColor.b = color.rgbtBlue;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Do the fillColor
|
|
//
|
|
if(HasFillColorChanged())
|
|
{
|
|
if(GetFillColor(&color))
|
|
{
|
|
AllocateAttrib(&attributes);
|
|
attributes->value.choice = fillColor_chosen;
|
|
attributes->value.u.fillColor.choice = rgbTrueColor_chosen;
|
|
attributes->value.u.fillColor.u.rgbTrueColor.r = color.rgbtRed;
|
|
attributes->value.u.fillColor.u.rgbTrueColor.g = color.rgbtGreen;
|
|
attributes->value.u.fillColor.u.rgbTrueColor.b = color.rgbtBlue;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Do the penThickness
|
|
//
|
|
if(HasPenThicknessChanged())
|
|
{
|
|
AllocateAttrib(&attributes);
|
|
attributes->value.choice = penThickness_chosen;
|
|
attributes->value.u.penThickness = (PenThickness)GetPenThickness();
|
|
}
|
|
|
|
//
|
|
// Do the penNib
|
|
//
|
|
if(HasPenNibChanged())
|
|
{
|
|
AllocateAttrib(&attributes);
|
|
attributes->value.choice = penNib_chosen;
|
|
attributes->value.u.penNib.choice = (ASN1choice_t)GetPenNib();
|
|
}
|
|
|
|
//
|
|
// Do the lineStyle
|
|
//
|
|
if(HasLineStyleChanged())
|
|
{
|
|
AllocateAttrib(&attributes);
|
|
attributes->value.choice = lineStyle_chosen;
|
|
attributes->value.u.lineStyle.choice = GetLineStyle()+1;
|
|
}
|
|
|
|
//
|
|
// Do the Highlight
|
|
//
|
|
if(HasHighlightChanged())
|
|
{
|
|
AllocateAttrib(&attributes);
|
|
attributes->value.choice = highlight_chosen;
|
|
attributes->value.u.highlight = (ASN1bool_t)GetHighlight();
|
|
}
|
|
|
|
//
|
|
// Do the viewState
|
|
//
|
|
if(HasViewStateChanged())
|
|
{
|
|
AllocateAttrib(&attributes);
|
|
attributes->value.choice = DrawingAttribute_viewState_chosen;
|
|
attributes->value.u.viewState.choice = (ASN1choice_t)GetViewState();
|
|
}
|
|
|
|
//
|
|
// Do the zOrder
|
|
//
|
|
if(HasZOrderChanged())
|
|
{
|
|
AllocateAttrib(&attributes);
|
|
attributes->value.choice = DrawingAttribute_zOrder_chosen;
|
|
attributes->value.u.zOrder = GetZOrder();
|
|
}
|
|
|
|
*pattributes = attributes;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// CircleHit()
|
|
//
|
|
// Checks for overlap between circle at PcxPcy with uRadius and
|
|
// lpHitRect. If overlap TRUE is returned, otherwise FALSE.
|
|
//
|
|
BOOL CircleHit( LONG Pcx, LONG Pcy, UINT uRadius, LPCRECT lpHitRect,
|
|
BOOL bCheckPt )
|
|
{
|
|
RECT hr = *lpHitRect;
|
|
RECT ellipse;
|
|
ellipse.left = Pcx - uRadius;
|
|
ellipse.right= Pcx + uRadius;
|
|
ellipse.bottom = Pcy + uRadius;
|
|
ellipse.top = Pcy - uRadius;
|
|
|
|
|
|
// check the easy thing first (don't use PtInRect)
|
|
if( bCheckPt &&(lpHitRect->left >= ellipse.left)&&(ellipse.right >= lpHitRect->right)&&
|
|
(lpHitRect->top >= ellipse.top)&&(ellipse.bottom >= lpHitRect->bottom))
|
|
{
|
|
return( TRUE );
|
|
}
|
|
|
|
//
|
|
// The circle is just a boring ellipse
|
|
//
|
|
return EllipseHit(&ellipse, bCheckPt, uRadius, lpHitRect );
|
|
}
|
|
|
|
|
|
//
|
|
// EllipseHit()
|
|
//
|
|
// Checks for overlap between ellipse defined by lpEllipseRect and
|
|
// lpHitRect. If overlap TRUE is returned, otherwise FALSE.
|
|
//
|
|
BOOL EllipseHit(LPCRECT lpEllipseRect, BOOL bBorderHit, UINT uPenWidth,
|
|
LPCRECT lpHitRect )
|
|
{
|
|
RECT hr = *lpHitRect;
|
|
RECT er = *lpEllipseRect;
|
|
|
|
// Some code below assumes l<r and t<b
|
|
NormalizeRect(&er);
|
|
lpEllipseRect = &er;
|
|
|
|
// Check easy thing first. If lpEllipseRect is inside lpHitRect
|
|
// then we have a hit (no duh...)
|
|
if( (hr.left <= lpEllipseRect->left)&&(hr.right >= lpEllipseRect->right)&&
|
|
(hr.top <= lpEllipseRect->top)&&(hr.bottom >= lpEllipseRect->bottom) )
|
|
return( TRUE );
|
|
|
|
// Check easy thing first. If lpEllipseRect is disjoint from lpHitRect
|
|
// then we have a miss (no duh...)
|
|
if( (hr.left > lpEllipseRect->right)||(hr.right < lpEllipseRect->left)||
|
|
(hr.top > lpEllipseRect->bottom)||(hr.bottom < lpEllipseRect->top) )
|
|
return( FALSE );
|
|
|
|
// If this is an ellipse....
|
|
//
|
|
// * * ^
|
|
// * | b | Y
|
|
// * | a +-------> X
|
|
// *-------+--------
|
|
// |
|
|
//
|
|
|
|
|
|
//
|
|
// Look for the ellipse hit. (x/a)^2 + (y/b)^2 = 1
|
|
// If it is > 1 than the point is outside the ellipse
|
|
// If it is < 1 it is inside
|
|
//
|
|
LONG a,b,aOuter, bOuter, x, y, xCenter, yCenter;
|
|
BOOL bInsideOuter = FALSE;
|
|
BOOL bOutsideInner = FALSE;
|
|
|
|
//
|
|
// Calculate a and b
|
|
//
|
|
a = (lpEllipseRect->right - lpEllipseRect->left)/2;
|
|
b = (lpEllipseRect->bottom - lpEllipseRect->top)/2;
|
|
|
|
//
|
|
// Get the center of the ellipse
|
|
//
|
|
xCenter = lpEllipseRect->left + a;
|
|
yCenter = lpEllipseRect->top + b;
|
|
|
|
//
|
|
// a and b generates a inner ellipse
|
|
// aOuter and bOuter generates a outer ellipse
|
|
//
|
|
aOuter = a + uPenWidth/2;
|
|
bOuter = b + uPenWidth/2;
|
|
a = a - uPenWidth/2;
|
|
b = b - uPenWidth/2;
|
|
|
|
//
|
|
// Make our coordinates relative to the center of the ellipse
|
|
//
|
|
y = abs(hr.bottom - yCenter);
|
|
x = abs(hr.right - xCenter);
|
|
|
|
|
|
//
|
|
// Be carefull not to divide by 0
|
|
//
|
|
if((a && b && aOuter && bOuter) == 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// We are using LONG instead of double and we need to have some precision
|
|
// that is why we multiply the equation of the ellipse
|
|
// ((x/a)^2 + (y/b)^2 = 1) by DECIMAL_PRECISION
|
|
// Note that the multiplication has to be done before the division, if we didn't do that
|
|
// we will always get 0 or 1 for x/a
|
|
//
|
|
if(x*x*DECIMAL_PRECISION/(aOuter*aOuter) + y*y*DECIMAL_PRECISION/(bOuter*bOuter) <= DECIMAL_PRECISION)
|
|
{
|
|
bInsideOuter = TRUE;
|
|
}
|
|
|
|
if(x*x*DECIMAL_PRECISION/(a*a)+ y*y*DECIMAL_PRECISION/(b*b) >= DECIMAL_PRECISION)
|
|
{
|
|
bOutsideInner = TRUE;
|
|
}
|
|
|
|
//
|
|
// If we are checking for border hit,
|
|
// we need to be inside the outer ellipse and inside the inner
|
|
//
|
|
if( bBorderHit )
|
|
{
|
|
return( bInsideOuter & bOutsideInner );
|
|
}
|
|
// just need to be inside the outer ellipse
|
|
else
|
|
{
|
|
return( bInsideOuter );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// LineHit()
|
|
//
|
|
// Checks for overlap (a "hit") between lpHitRect and the line
|
|
// P1P2 accounting for line width. If bCheckP1End or bCheckP2End is
|
|
// TRUE then a circle of radius 0.5 * uPenWidth is also checked for
|
|
// a hit to account for the rounded ends of wide lines.
|
|
//
|
|
// If a hit is found TRUE is returned, otherwise FALSE.
|
|
//
|
|
BOOL LineHit( LONG P1x, LONG P1y, LONG P2x, LONG P2y, UINT uPenWidth,
|
|
BOOL bCheckP1End, BOOL bCheckP2End,
|
|
LPCRECT lpHitRect )
|
|
{
|
|
|
|
LONG uHalfPenWidth = uPenWidth/2;
|
|
|
|
//
|
|
// It is really hard to hit if the width is only 2
|
|
//
|
|
if(uHalfPenWidth == 1)
|
|
{
|
|
uHalfPenWidth = 2;
|
|
}
|
|
|
|
LONG a,b,x,y;
|
|
|
|
x = lpHitRect->left + (lpHitRect->right - lpHitRect->left)/2;
|
|
y = lpHitRect->bottom + (lpHitRect->top - lpHitRect->bottom)/2;
|
|
|
|
//
|
|
// This code assume the rectangle is normalized
|
|
//
|
|
RECT rect;
|
|
rect.top = P1y;
|
|
rect.left = P1x;
|
|
rect.bottom = P2y;
|
|
rect.right = P2x;
|
|
|
|
NormalizeRect(&rect);
|
|
|
|
if( (P1x == P2x)&&(P1y == P2y) )
|
|
{
|
|
// just check one end point's circle
|
|
return( CircleHit( P1x, P1y, uHalfPenWidth, lpHitRect, TRUE ) );
|
|
}
|
|
|
|
// check rounded end at P1
|
|
if( bCheckP1End && CircleHit( P1x, P1y, uHalfPenWidth, lpHitRect, FALSE ) )
|
|
return( TRUE );
|
|
|
|
// check rounded end at P2
|
|
if( bCheckP2End && CircleHit( P2x, P2y, uHalfPenWidth, lpHitRect, FALSE ) )
|
|
return( TRUE );
|
|
|
|
//
|
|
// The function of a line is Y = a.X + b
|
|
//
|
|
// a = (Y1-Y2)/(X1 -X2)
|
|
// if we found a we get b = y1 -a.X1
|
|
//
|
|
|
|
if(P1x == P2x)
|
|
{
|
|
a=0;
|
|
b = DECIMAL_PRECISION*P1x;
|
|
|
|
}
|
|
else
|
|
{
|
|
a = (P1y - P2y)*DECIMAL_PRECISION/(P1x - P2x);
|
|
b = DECIMAL_PRECISION*P1y - a*P1x;
|
|
}
|
|
|
|
|
|
//
|
|
// Paralel to Y
|
|
//
|
|
if(P1x == P2x && ((x >= P1x - uHalfPenWidth) && x <= P1x + uHalfPenWidth))
|
|
{
|
|
return (P1y <= y && P2y >= y);
|
|
}
|
|
|
|
//
|
|
// Paralel to X
|
|
//
|
|
if(P1y == P2y && ((y >= P1y - uHalfPenWidth) && y <= P1y + uHalfPenWidth))
|
|
{
|
|
return (P1x <= x && P2x >= x);
|
|
}
|
|
|
|
//
|
|
// General line
|
|
//
|
|
|
|
return(( y*DECIMAL_PRECISION <= a*x + b + DECIMAL_PRECISION*uHalfPenWidth) &&
|
|
( y*DECIMAL_PRECISION >= a*x + b - DECIMAL_PRECISION*uHalfPenWidth)&&
|
|
((rect.top <= y && rect.bottom >= y) && (rect.left <= x && rect.right >= x)));
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// Checks object for an actual overlap with pRectHit. This
|
|
// function assumes that the boundingRect has already been
|
|
// compared with pRectHit.
|
|
//
|
|
BOOL DrawObj::PolyLineHit(LPCRECT pRectHit)
|
|
{
|
|
POINT *lpPoints;
|
|
int iCount;
|
|
int i;
|
|
POINT ptLast;
|
|
UINT uRadius;
|
|
RECT rectHit;
|
|
|
|
iCount = m_points->GetSize();
|
|
lpPoints = (POINT *)m_points->GetBuffer();
|
|
|
|
if( iCount == 0 )
|
|
return( FALSE );
|
|
|
|
|
|
// addjust hit rect to lpPoints coord space.
|
|
rectHit = *pRectHit;
|
|
POINT anchorPoint;
|
|
GetAnchorPoint(&anchorPoint);
|
|
|
|
if( (iCount > 0)&&(iCount < 2) )
|
|
{
|
|
// only one point, just hit check it
|
|
uRadius = GetPenThickness() >> 1; // m_uiPenWidth/2
|
|
return(CircleHit( anchorPoint.x + lpPoints->x, anchorPoint.y - lpPoints->y, uRadius, &rectHit, TRUE ));
|
|
}
|
|
|
|
|
|
// look for a hit on each line segment body
|
|
ptLast = anchorPoint;
|
|
for( i=1; i<iCount; i++ )
|
|
{
|
|
RECT rect;
|
|
rect.top = ptLast.y;
|
|
rect.left = ptLast.x;
|
|
rect.bottom = ptLast.y + lpPoints->y;
|
|
rect.right = ptLast.x + lpPoints->x;
|
|
NormalizeRect(&rect);
|
|
|
|
if( LineHit(rect.left, rect.top, rect.right, rect.bottom, GetPenThickness(), TRUE, TRUE, &rectHit))
|
|
{
|
|
return( TRUE ); // got a hit
|
|
}
|
|
|
|
lpPoints++;
|
|
ptLast.x +=lpPoints->x;
|
|
ptLast.y +=lpPoints->y;
|
|
}
|
|
|
|
// now, look for a hit on the line endpoints if m_uiPenWidth > 1
|
|
if( GetPenThickness() > 1 )
|
|
{
|
|
uRadius = GetPenThickness() >> 1; // m_uiPenWidth/2
|
|
lpPoints = (POINT *)m_points->GetBuffer();
|
|
for( i=0; i<iCount; i++, lpPoints++ )
|
|
{
|
|
if( CircleHit( anchorPoint.x + lpPoints->x, anchorPoint.y + lpPoints->y, uRadius, &rectHit, FALSE ))
|
|
{
|
|
return( TRUE ); // got a hit
|
|
}
|
|
}
|
|
}
|
|
|
|
return( FALSE ); // no hits
|
|
}
|
|
|
|
|
|
|
|
|
|
DrawObj::CheckReallyHit(LPCRECT pRectHit)
|
|
{
|
|
RECT rect;
|
|
|
|
switch(GetDrawingType())
|
|
{
|
|
case point_chosen:
|
|
case openPolyLine_chosen:
|
|
{
|
|
UINT nPoints = m_points->GetSize();
|
|
if(nPoints > 2 )
|
|
{
|
|
POINT point;
|
|
RECT rect;
|
|
GetBoundsRect(&rect);
|
|
point.y = pRectHit->top;
|
|
point.x = pRectHit->left;
|
|
return PolyLineHit(pRectHit);
|
|
}
|
|
else
|
|
{
|
|
GetRect(&rect);
|
|
return(LineHit(rect.left, rect.top, rect.right, rect.bottom, GetPenThickness(), TRUE, TRUE, pRectHit));
|
|
}
|
|
}
|
|
break;
|
|
|
|
case rectangle_chosen:
|
|
{
|
|
// Draw the rectangle
|
|
return(RectangleHit(!HasFillColor(), pRectHit));
|
|
}
|
|
break;
|
|
|
|
case ellipse_chosen:
|
|
{
|
|
GetRect(&rect);
|
|
return( EllipseHit( &rect, !HasFillColor(), GetPenThickness(), pRectHit ));
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void DrawObj::UnDraw(void)
|
|
{
|
|
RECT rect;
|
|
UINT penThickness;
|
|
GetBoundsRect(&rect);
|
|
penThickness = GetPenThickness();
|
|
::InflateRect(&rect, penThickness, penThickness);
|
|
g_pDraw->InvalidateSurfaceRect(&rect,TRUE);
|
|
|
|
BitmapObj* remotePointer = NULL;
|
|
WBPOSITION pos = NULL;
|
|
remotePointer = g_pCurrentWorkspace->RectHitRemotePointer(&rect, penThickness, NULL);
|
|
while(remotePointer)
|
|
{
|
|
remotePointer->DeleteSavedBitmap();
|
|
remotePointer = g_pCurrentWorkspace->RectHitRemotePointer(&rect, penThickness, remotePointer->GetMyPosition());
|
|
}
|
|
}
|
|
|
|
|
|
void DrawObj::Draw(HDC hDC, BOOL bForcedDraw, BOOL bPrinting)
|
|
{
|
|
|
|
if(!bPrinting)
|
|
{
|
|
//
|
|
// Don't draw anything if we don't belong in this workspace
|
|
//
|
|
if(!(GraphicTool() == TOOLTYPE_SELECT || GraphicTool() == TOOLTYPE_ERASER) && GetWorkspaceHandle() != g_pCurrentWorkspace->GetThisObjectHandle())
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
HPEN hPen = NULL;
|
|
HPEN hOldPen = NULL;
|
|
HBRUSH hBrush = NULL;
|
|
HBRUSH hOldBrush = NULL;
|
|
BOOL bHasPenColor;
|
|
BOOL bHasFillColor;
|
|
BitmapObj* remotePointer = NULL;
|
|
COLORREF color;
|
|
COLORREF fillColor;
|
|
RECT boundsRect;
|
|
RECT rect;
|
|
UINT penThickness = GetPenThickness();
|
|
|
|
if(hDC == NULL)
|
|
{
|
|
hDC = g_pDraw->m_hDCCached;
|
|
}
|
|
|
|
MLZ_EntryOut(ZONE_FUNCTION, "DrawObj::Draw");
|
|
|
|
// Select the required pen and fill color
|
|
bHasPenColor = GetPenColor(&color);
|
|
bHasFillColor = GetFillColor(&fillColor);
|
|
|
|
if(bHasFillColor)
|
|
{
|
|
hBrush = ::CreateSolidBrush(SET_PALETTERGB(fillColor));
|
|
hOldBrush = SelectBrush(hDC, hBrush);
|
|
}
|
|
else
|
|
{
|
|
hOldBrush = SelectBrush(hDC, ::GetStockObject(NULL_BRUSH));
|
|
}
|
|
|
|
//
|
|
// Get rect
|
|
//
|
|
GetBoundsRect(&boundsRect);
|
|
GetRect(&rect);
|
|
|
|
|
|
hPen = ::CreatePen(GetLineStyle(), penThickness, SET_PALETTERGB(color));
|
|
hOldPen = SelectPen(hDC, hPen);
|
|
|
|
|
|
if (hOldPen != NULL)
|
|
{
|
|
|
|
// Select the raster operation
|
|
int iOldROP = ::SetROP2(hDC, GetROP());
|
|
|
|
switch(GetDrawingType())
|
|
{
|
|
case point_chosen:
|
|
case openPolyLine_chosen:
|
|
{
|
|
UINT nPoints = m_points->GetSize();
|
|
//
|
|
// This is a redraw of a pen or highlight
|
|
// We have to draw all the segments
|
|
//
|
|
if( (bForcedDraw || GetIsCompleted()) && nPoints > 1)
|
|
{
|
|
POINT anchorPoint;
|
|
GetAnchorPoint(&anchorPoint);
|
|
|
|
AddPointToBounds(anchorPoint.x, anchorPoint.y);
|
|
|
|
//
|
|
// Go to the beggining
|
|
//
|
|
::MoveToEx(hDC, anchorPoint.x, anchorPoint.y, NULL);
|
|
|
|
//
|
|
// Get the list of points
|
|
//
|
|
POINT *point = m_points->GetBuffer();
|
|
while(nPoints)
|
|
{
|
|
anchorPoint.x += point->x;
|
|
anchorPoint.y += point->y;
|
|
::LineTo(hDC, anchorPoint.x, anchorPoint.y);
|
|
::MoveToEx(hDC, anchorPoint.x, anchorPoint.y, NULL);
|
|
point++;
|
|
nPoints--;
|
|
|
|
RECT rect;
|
|
MAKE_HIT_RECT(rect, anchorPoint);
|
|
if(remotePointer)
|
|
{
|
|
remotePointer->Draw();
|
|
remotePointer = NULL;
|
|
}
|
|
|
|
AddPointToBounds(anchorPoint.x, anchorPoint.y);
|
|
|
|
::InflateRect(&rect, GetPenThickness()/2, GetPenThickness()/2);
|
|
remotePointer = g_pCurrentWorkspace->RectHitRemotePointer(&rect, GetPenThickness()/2, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
// Draw the line
|
|
::MoveToEx(hDC, rect.left, rect.top, NULL);
|
|
::LineTo(hDC, rect.right, rect.bottom);
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case rectangle_chosen:
|
|
{
|
|
|
|
TRACE_DEBUG(("RECTANGLE %d, %d, %d , %d", rect.left, rect.top, rect.right, rect.bottom ));
|
|
|
|
// Draw the rectangle
|
|
::Rectangle(hDC, rect.left, rect.top, rect.right, rect.bottom);
|
|
}
|
|
break;
|
|
|
|
case ellipse_chosen:
|
|
{
|
|
::Ellipse(hDC, rect.left, rect.top, rect.right, rect.bottom);
|
|
}
|
|
break;
|
|
|
|
case closedPolyLine_chosen:
|
|
default:
|
|
TRACE_DEBUG(("Unsupported DrawingType", GetDrawingType()));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// De-select the brush
|
|
//
|
|
SelectBrush(hDC, hOldBrush);
|
|
|
|
// De-select the pen and ROP
|
|
::SetROP2(hDC, iOldROP);
|
|
SelectPen(hDC, hOldPen);
|
|
}
|
|
|
|
//
|
|
// Do NOT draw focus if clipboard or printing
|
|
//
|
|
if (WasSelectedLocally() && (hDC == g_pDraw->m_hDCCached))
|
|
{
|
|
DrawRect();
|
|
}
|
|
|
|
if (hPen != NULL)
|
|
{
|
|
::DeletePen(hPen);
|
|
}
|
|
|
|
if (hBrush != NULL)
|
|
{
|
|
::DeleteBrush(hBrush);
|
|
}
|
|
|
|
if(remotePointer)
|
|
{
|
|
remotePointer->Draw();
|
|
}
|
|
|
|
//
|
|
// Now for rectangles ellipses and lines, check if we are on top of any remote pointer
|
|
//
|
|
|
|
remotePointer = NULL;
|
|
WBPOSITION pos = NULL;
|
|
::InflateRect(&rect, GetPenThickness()/2, GetPenThickness()/2);
|
|
remotePointer = g_pCurrentWorkspace->RectHitRemotePointer(&rect, GetPenThickness()/2, NULL);
|
|
while(remotePointer)
|
|
{
|
|
remotePointer->DeleteSavedBitmap();
|
|
remotePointer->Draw();
|
|
remotePointer = g_pCurrentWorkspace->RectHitRemotePointer(&rect, GetPenThickness()/2, remotePointer->GetMyPosition());
|
|
}
|
|
}
|
|
|
|
void DrawObj::SetPenColor(COLORREF rgb, BOOL isPresent)
|
|
{
|
|
ChangedPenColor();
|
|
m_bIsPenColorPresent = isPresent;
|
|
if(!isPresent)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_penColor.rgbtRed = GetRValue(rgb);
|
|
m_penColor.rgbtGreen = GetGValue(rgb);
|
|
m_penColor.rgbtBlue = GetBValue(rgb);
|
|
|
|
}
|
|
|
|
BOOL DrawObj::GetPenColor(COLORREF * rgb)
|
|
{
|
|
if(m_bIsPenColorPresent)
|
|
{
|
|
*rgb = RGB(m_penColor.rgbtRed, m_penColor.rgbtGreen, m_penColor.rgbtBlue);
|
|
}
|
|
return m_bIsPenColorPresent;
|
|
}
|
|
|
|
BOOL DrawObj::GetPenColor(RGBTRIPLE* rgb)
|
|
{
|
|
if(m_bIsPenColorPresent)
|
|
{
|
|
*rgb = m_penColor;
|
|
}
|
|
return m_bIsPenColorPresent;
|
|
}
|
|
|
|
|
|
void DrawObj::SetFillColor(COLORREF rgb, BOOL isPresent)
|
|
{
|
|
ChangedFillColor();
|
|
m_bIsFillColorPresent = isPresent;
|
|
if(!isPresent)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_fillColor.rgbtRed = GetRValue(rgb);
|
|
m_fillColor.rgbtGreen = GetGValue(rgb);
|
|
m_fillColor.rgbtBlue = GetBValue(rgb);
|
|
|
|
}
|
|
|
|
BOOL DrawObj::GetFillColor(COLORREF* rgb)
|
|
{
|
|
if(m_bIsFillColorPresent && rgb !=NULL)
|
|
{
|
|
*rgb = RGB(m_fillColor.rgbtRed, m_fillColor.rgbtGreen, m_fillColor.rgbtBlue);
|
|
}
|
|
return m_bIsFillColorPresent;
|
|
}
|
|
|
|
BOOL DrawObj::GetFillColor(RGBTRIPLE* rgb)
|
|
{
|
|
if(m_bIsFillColorPresent && rgb!= NULL)
|
|
{
|
|
*rgb = m_fillColor;
|
|
}
|
|
return m_bIsFillColorPresent;
|
|
}
|
|
|
|
|
|
BOOL DrawObj::AddPoint(POINT point)
|
|
{
|
|
BOOL bSuccess = TRUE;
|
|
|
|
MLZ_EntryOut(ZONE_FUNCTION, "DrawObj::::AddPoint");
|
|
|
|
int nPoints = m_points->GetSize();
|
|
|
|
// if we've reached the maximum number of points then quit with failure
|
|
if (nPoints >= MAX_FREEHAND_POINTS)
|
|
{
|
|
bSuccess = FALSE;
|
|
TRACE_DEBUG(("Maximum number of points for freehand object reached."));
|
|
return(bSuccess);
|
|
}
|
|
|
|
m_points->Add(point);
|
|
nPoints++;
|
|
|
|
ChangedPointList();
|
|
|
|
|
|
//
|
|
// If we hit the 256 limit fake a timer notification and resend the polyline
|
|
//
|
|
if((nPoints & 0xff) == 0)
|
|
{
|
|
g_pDraw->OnTimer(0);
|
|
}
|
|
|
|
|
|
return(bSuccess);
|
|
}
|
|
|
|
|
|
void DrawObj::AddPointToBounds(int x, int y)
|
|
{
|
|
// Create a rectangle containing the point just added (expanded
|
|
// by the width of the pen being used).
|
|
RECT rect;
|
|
RECT boundsRect;
|
|
rect.left = x - 1;
|
|
rect.top = y - 1;
|
|
rect.right = x + 1;
|
|
rect.bottom = y + 1;
|
|
|
|
|
|
GetBoundsRect(&boundsRect);
|
|
::UnionRect(&boundsRect, &boundsRect, &rect);
|
|
SetBoundsRect(&boundsRect);
|
|
}
|
|
|
|
|
|
void GetDrawingDestinationAddress(DrawingDestinationAddress *destinationAddress, PUINT workspaceHandle, PUINT planeID)
|
|
{
|
|
|
|
//
|
|
// Get the destination address
|
|
//
|
|
switch(destinationAddress->choice)
|
|
{
|
|
|
|
case(DrawingDestinationAddress_softCopyAnnotationPlane_chosen):
|
|
{
|
|
*workspaceHandle = (destinationAddress->u.softCopyAnnotationPlane.workspaceHandle);
|
|
*planeID = (destinationAddress->u.softCopyAnnotationPlane.plane);
|
|
break;
|
|
}
|
|
// case(DrawingDestinationAddress_nonStandardDestination_chosen):
|
|
// {
|
|
// break;
|
|
// }
|
|
|
|
default:
|
|
ERROR_OUT(("Invalid destinationAddress"));
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void DrawObj::SetUIToolType(void)
|
|
{
|
|
UINT drawingType = GetDrawingType();
|
|
BOOL filled = HasFillColor();
|
|
|
|
UINT rop = R2_COPYPEN;
|
|
|
|
switch (drawingType)
|
|
{
|
|
case openPolyLine_chosen:
|
|
{
|
|
if(m_points->GetSize() > 1)
|
|
{
|
|
if(GetHighlight())
|
|
{
|
|
m_ToolType = TOOLTYPE_HIGHLIGHT;
|
|
rop = R2_MASKPEN;
|
|
|
|
}
|
|
else
|
|
{
|
|
m_ToolType = TOOLTYPE_PEN;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
m_ToolType = TOOLTYPE_LINE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case rectangle_chosen:
|
|
{
|
|
if(filled)
|
|
{
|
|
m_ToolType = TOOLTYPE_FILLEDBOX;
|
|
}
|
|
else
|
|
{
|
|
m_ToolType = TOOLTYPE_BOX;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ellipse_chosen:
|
|
{
|
|
if(filled)
|
|
{
|
|
m_ToolType = TOOLTYPE_FILLEDELLIPSE;
|
|
}
|
|
else
|
|
{
|
|
m_ToolType = TOOLTYPE_ELLIPSE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
SetROP(rop);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// UI Edited the Drawing Object
|
|
//
|
|
void DrawObj::OnObjectEdit(void)
|
|
{
|
|
g_bContentsChanged = TRUE;
|
|
|
|
SIPDU *sipdu = NULL;
|
|
DBG_SAVE_FILE_LINE
|
|
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
|
if(sipdu)
|
|
{
|
|
sipdu->choice = drawingEditPDU_chosen;
|
|
|
|
CreateDrawingEditPDU(&sipdu->u.drawingEditPDU);
|
|
|
|
TRACE_DEBUG(("Sending Drawing Edit >> Drawing handle = %d", sipdu->u.drawingEditPDU.drawingHandle ));
|
|
|
|
T120Error rc = SendT126PDU(sipdu);
|
|
if(rc == T120_NO_ERROR)
|
|
{
|
|
SIPDUCleanUp(sipdu);
|
|
ResetAttrib();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRACE_MSG(("Failed to create sipdu"));
|
|
::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
|
|
}
|
|
}
|
|
|
|
//
|
|
// UI Deleted the Drawing Object
|
|
//
|
|
void DrawObj::OnObjectDelete(void)
|
|
{
|
|
SIPDU *sipdu = NULL;
|
|
DBG_SAVE_FILE_LINE
|
|
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
|
if(sipdu)
|
|
{
|
|
sipdu->choice = drawingDeletePDU_chosen;
|
|
CreateDrawingDeletePDU(&sipdu->u.drawingDeletePDU);
|
|
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);
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Get the encoded buffer for Drawing Create PDU
|
|
//
|
|
void DrawObj::GetEncodedCreatePDU(ASN1_BUF *pBuf)
|
|
{
|
|
SIPDU *sipdu = NULL;
|
|
DBG_SAVE_FILE_LINE
|
|
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
|
if(sipdu)
|
|
{
|
|
sipdu->choice = drawingCreatePDU_chosen;
|
|
CreateDrawingCreatePDU(&sipdu->u.drawingCreatePDU);
|
|
|
|
ASN1_BUF encodedPDU;
|
|
g_pCoder->Encode(sipdu, pBuf);
|
|
|
|
SIPDUCleanUp(sipdu);
|
|
}
|
|
else
|
|
{
|
|
TRACE_MSG(("Failed to create penMenu"));
|
|
::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// UI Created a new Drawing Object
|
|
//
|
|
void DrawObj::SendNewObjectToT126Apps(void)
|
|
{
|
|
|
|
SIPDU *sipdu = NULL;
|
|
DBG_SAVE_FILE_LINE
|
|
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
|
if(sipdu)
|
|
{
|
|
sipdu->choice = drawingCreatePDU_chosen;
|
|
CreateDrawingCreatePDU(&sipdu->u.drawingCreatePDU);
|
|
|
|
TRACE_DEBUG(("Sending Drawing >> Drawing handle = %d", sipdu->u.drawingCreatePDU.drawingHandle ));
|
|
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);
|
|
}
|
|
}
|
|
|
|
|