5543 lines
146 KiB
C++
5543 lines
146 KiB
C++
/**************************************************************************\
|
|
*
|
|
* Copyright (c) 1999 - 2000 Microsoft Corporation
|
|
*
|
|
* Module Name:
|
|
*
|
|
* PathWidener.cpp
|
|
*
|
|
* Abstract:
|
|
*
|
|
* Implementation of the GpPathWidener class
|
|
*
|
|
* Revision History:
|
|
*
|
|
* 11/23/99 ikkof
|
|
* Created it
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#include "precomp.hpp"
|
|
|
|
// 4*(REALSQRT(2.0) - 1)/3
|
|
#define U_CIR ((REAL)(0.552284749))
|
|
|
|
|
|
|
|
// Define DEBUG_PATHWIDENER if debugging is necessary.
|
|
|
|
//#define DEBUG_PATHWIDENER
|
|
|
|
GpStatus ReversePath(INT count,GpPointF* points,BYTE* types);
|
|
|
|
const BOOL USE_POLYGON_JOIN = FALSE;
|
|
|
|
INT
|
|
CombinePaths(
|
|
INT count,
|
|
GpPointF* points,
|
|
BYTE* types,
|
|
INT count1,
|
|
const GpPointF* points1,
|
|
const BYTE* types1,
|
|
BOOL forward1,
|
|
INT count2,
|
|
const GpPointF* points2,
|
|
const BYTE* types2,
|
|
BOOL forward2,
|
|
BOOL connect
|
|
);
|
|
|
|
GpStatus
|
|
CalculateGradientArray(
|
|
GpPointF* grad,
|
|
REAL* distances,
|
|
const GpPointF* points,
|
|
INT count
|
|
);
|
|
|
|
GpStatus
|
|
GetMajorAndMinorAxis(
|
|
REAL* majorR,
|
|
REAL* minorR,
|
|
const GpMatrix* matrix
|
|
);
|
|
|
|
enum
|
|
{
|
|
WideningClosed = 1,
|
|
WideningFirstType = 2,
|
|
WideningLastType = 4,
|
|
WideningLastPointSame = 8,
|
|
WideningNeedsToAdjustNormals = 16,
|
|
WideningUseBevelJoinInside = 32
|
|
};
|
|
|
|
enum GpTurningDirection
|
|
{
|
|
NotTurning = 0,
|
|
TurningBack = 1,
|
|
TurningRight = 2,
|
|
TurningLeft = 3,
|
|
NotMoving = -1
|
|
};
|
|
|
|
GpTurningDirection
|
|
getJoin(
|
|
GpLineJoin lineJoin,
|
|
const GpPointF& point,
|
|
const GpPointF& grad1,
|
|
const GpPointF& grad2,
|
|
const GpPointF& norm1,
|
|
const GpPointF& norm2,
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
INT *leftCount,
|
|
GpPointF *leftPoints,
|
|
BOOL *leftInside,
|
|
INT *rightCount,
|
|
GpPointF *rightPoints,
|
|
BOOL *rightInside,
|
|
BOOL needsToAdjustNormals,
|
|
REAL miterLimit2
|
|
);
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* This reverses the path data.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] count - the number of points.
|
|
* [IN/OUT] points - the data points to be reversed.
|
|
* [IN/OUT] types - the data types to be reversed.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Status
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
ReversePath(
|
|
INT count,
|
|
GpPointF* points,
|
|
BYTE* types
|
|
)
|
|
{
|
|
DpPathTypeIterator iter(types, count);
|
|
|
|
if(!iter.IsValid())
|
|
return InvalidParameter;
|
|
|
|
INT startIndex, endIndex;
|
|
BOOL isClosed;
|
|
BOOL isStartDashMode, isEndDashMode;
|
|
BOOL wasMarkerEnd = FALSE;
|
|
|
|
INT i;
|
|
|
|
while(iter.NextSubpath(&startIndex, &endIndex, &isClosed))
|
|
{
|
|
if((types[startIndex] & PathPointTypeDashMode) != 0)
|
|
isStartDashMode = TRUE;
|
|
else
|
|
isStartDashMode = FALSE;
|
|
if((types[endIndex] & PathPointTypeDashMode) != 0)
|
|
isEndDashMode = TRUE;
|
|
else
|
|
isEndDashMode = FALSE;
|
|
|
|
BOOL isMarkerEnd
|
|
= (types[endIndex] & PathPointTypePathMarker) != 0;
|
|
|
|
BYTE startType = types[startIndex]; // Save the first type.
|
|
|
|
// Shift type points.
|
|
|
|
for(i = startIndex + 1; i <= endIndex; i++)
|
|
{
|
|
types[i - 1] = types[i];
|
|
}
|
|
|
|
// Clear the close subpapth flag for original type (now at endIndex - 1).
|
|
|
|
if(endIndex > 0)
|
|
types[endIndex - 1] &= ~PathPointTypeCloseSubpath;
|
|
|
|
types[endIndex] = PathPointTypeStart;
|
|
|
|
if(isStartDashMode)
|
|
types[startIndex] |= PathPointTypeDashMode;
|
|
else
|
|
types[startIndex] &= ~PathPointTypeDashMode;
|
|
|
|
if(isEndDashMode)
|
|
types[endIndex] |= PathPointTypeDashMode;
|
|
else
|
|
types[endIndex] &= ~PathPointTypeDashMode;
|
|
|
|
// Add the dash and close flag.
|
|
|
|
if(isClosed)
|
|
types[startIndex] |= PathPointTypeCloseSubpath;
|
|
else
|
|
types[startIndex] &= ~PathPointTypeCloseSubpath;
|
|
|
|
// Shift the marker flag by 1 from the original position.
|
|
// This means we have to shift by 2 since the types array
|
|
// was shifted by -1.
|
|
|
|
for(i = endIndex; i >= startIndex + 2; i--)
|
|
{
|
|
if(types[i - 2] & PathPointTypePathMarker)
|
|
types[i] |= PathPointTypePathMarker;
|
|
else
|
|
types[i] &= ~PathPointTypePathMarker;
|
|
}
|
|
|
|
// Shift Marker flag from the startIndex.
|
|
|
|
if(startType & PathPointTypePathMarker)
|
|
types[startIndex + 1] |= PathPointTypePathMarker;
|
|
else
|
|
types[startIndex + 1] &= ~PathPointTypePathMarker;
|
|
|
|
// Shift Marker flag from the end of the previous subpath.
|
|
|
|
if(wasMarkerEnd)
|
|
types[startIndex] |= PathPointTypePathMarker;
|
|
else
|
|
types[startIndex] &= ~PathPointTypePathMarker;
|
|
|
|
wasMarkerEnd = isMarkerEnd;
|
|
|
|
// Keep the location of the internal flag. So we must
|
|
// shift back by 1.
|
|
|
|
for(i = endIndex; i >= startIndex + 1; i--)
|
|
{
|
|
if(types[i - 1] & PathPointTypeInternalUse)
|
|
types[i] |= PathPointTypeInternalUse;
|
|
else
|
|
types[i] &= ~PathPointTypeInternalUse;
|
|
}
|
|
if(startType & PathPointTypeInternalUse)
|
|
types[startIndex] |= PathPointTypeInternalUse;
|
|
else
|
|
types[startIndex] &= ~PathPointTypeInternalUse;
|
|
}
|
|
|
|
// Reverse the points and types data.
|
|
|
|
INT halfCount = count/2;
|
|
for(i = 0; i < halfCount; i++)
|
|
{
|
|
GpPointF tempPt;
|
|
BYTE tempType;
|
|
|
|
tempPt = points[count - 1 - i];
|
|
tempType = types[count - 1 - i];
|
|
points[count - 1 - i] = points[i];
|
|
types[count -1 - i] = types[i];
|
|
points[i] = tempPt;
|
|
types[i] = tempType;
|
|
}
|
|
|
|
#ifdef DEBUG_PATHWIDENER
|
|
DpPathTypeIterator iter2(types, count);
|
|
|
|
if(!iter2.IsValid())
|
|
{
|
|
WARNING(("ReversePath: failed."));
|
|
return GenericError;
|
|
}
|
|
#endif
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* This combines the two open segments each of which is continuous.
|
|
* The data is returned to points1 and types1. They must be allocated
|
|
* at least the array size of count1 + count2.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] count1 - the number of points of the first path.
|
|
* [IN/OUT] points1 - the first path points.
|
|
* [IN/OUT] types1 - the first path types.
|
|
* [IN] forward1 - the direction of the first path. TRUE if forward.
|
|
* [IN] count2 - the number of points of the second path.
|
|
* [IN] points2 - the second path points.
|
|
* [IN] types2 - the second path types.
|
|
* [IN] forward2 - the direction of the second path. TRUE if forward.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* The total number of points of the combined path.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
INT
|
|
combineTwoOpenSegments(
|
|
INT count1,
|
|
GpPointF* points1,
|
|
BYTE* types1,
|
|
BOOL forward1,
|
|
INT count2,
|
|
GpPointF* points2,
|
|
BYTE* types2,
|
|
BOOL forward2
|
|
)
|
|
{
|
|
GpStatus status = Ok;
|
|
|
|
if(
|
|
count1 < 0 || !points1 || !types1 ||
|
|
count2 < 0 || !points2 || !types2
|
|
)
|
|
return 0;
|
|
|
|
if(!forward1 && count1 > 0)
|
|
{
|
|
status = ::ReversePath(count1, points1, types1);
|
|
if(status != Ok)
|
|
return 0;
|
|
}
|
|
|
|
if(!forward2 && count2 > 0)
|
|
{
|
|
status = ::ReversePath(count2, points2, types2);
|
|
if(status != Ok)
|
|
return 0;
|
|
}
|
|
|
|
INT offset = 0;
|
|
|
|
if(count1 > 0 && count2 > 0)
|
|
{
|
|
if(REALABS(points1[count1 - 1].X - points2[0].X) +
|
|
REALABS(points1[count1 - 1].Y - points2[0].Y)
|
|
< POINTF_EPSILON
|
|
)
|
|
offset = 1;
|
|
}
|
|
|
|
if(count2 - offset > 0)
|
|
{
|
|
GpMemcpy(
|
|
points1 + count1,
|
|
points2 + offset,
|
|
(count2 - offset)*sizeof(GpPointF)
|
|
);
|
|
GpMemcpy(
|
|
types1 + count1,
|
|
types2 + offset,
|
|
count2 - offset
|
|
);
|
|
}
|
|
|
|
BYTE saveType = types1[0];
|
|
types1[0] = PathPointTypeLine |
|
|
(saveType & ~PathPointTypePathTypeMask);
|
|
|
|
// Make sure the first path is not closed.
|
|
|
|
if(count1 > 0)
|
|
{
|
|
if(types1[count1 - 1] & PathPointTypeCloseSubpath)
|
|
types1[count1 - 1] &= ~PathPointTypeCloseSubpath;
|
|
}
|
|
|
|
|
|
// Set the first point type of the second path correctly.
|
|
|
|
if(offset == 0)
|
|
{
|
|
saveType = types1[count1];
|
|
types1[count1] = PathPointTypeLine |
|
|
(saveType & ~PathPointTypePathTypeMask);
|
|
}
|
|
|
|
// Make sure this path is not closed.
|
|
|
|
INT total = count1 + count2 - offset;
|
|
|
|
if(total > 0)
|
|
{
|
|
if(types1[total - 1] & PathPointTypeCloseSubpath)
|
|
types1[total - 1] &= ~PathPointTypeCloseSubpath;
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* This combines the two closed segments each of which is made of closed
|
|
* segments.
|
|
* The data is returned to points1 and types1. They must be allocated
|
|
* at least the array size of count1 + count2.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] count1 - the number of points of the first path.
|
|
* [IN/OUT] points1 - the first path points.
|
|
* [IN/OUT] types1 - the first path types.
|
|
* [IN] forward1 - the direction of the first path. TRUE if forward.
|
|
* [IN] count2 - the number of points of the second path.
|
|
* [IN] points2 - the second path points.
|
|
* [IN] types2 - the second path types.
|
|
* [IN] forward2 - the direction of the second path. TRUE if forward.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* The total number of points of the combined path.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
INT
|
|
combineClosedSegments(
|
|
INT count1,
|
|
GpPointF* points1,
|
|
BYTE* types1,
|
|
BOOL forward1,
|
|
INT count2,
|
|
GpPointF* points2,
|
|
BYTE* types2,
|
|
BOOL forward2
|
|
)
|
|
{
|
|
GpStatus status = Ok;
|
|
|
|
if(
|
|
count1 < 0 || !points1 || !types1 ||
|
|
count2 < 0 || !points2 || !types2
|
|
)
|
|
return 0;
|
|
|
|
if(count1 == 0 && count2 == 0)
|
|
return 0;
|
|
|
|
if(!forward1 && count1 > 0)
|
|
{
|
|
status = ::ReversePath(count1, points1, types1);
|
|
if(status != Ok)
|
|
return 0;
|
|
}
|
|
|
|
if(!forward2 && count2 > 0)
|
|
{
|
|
status = ::ReversePath(count2, points2, types2);
|
|
if(status != Ok)
|
|
return 0;
|
|
}
|
|
|
|
// Make sure the first path is closed.
|
|
|
|
types1[0] = PathPointTypeStart;
|
|
if(count1 > 0)
|
|
{
|
|
if((types1[count1 - 1] & PathPointTypeCloseSubpath) == 0)
|
|
types1[count1 - 1] |= PathPointTypeCloseSubpath;
|
|
}
|
|
|
|
INT total = count1 + count2;
|
|
|
|
if(count2 > 0)
|
|
{
|
|
GpMemcpy(points1 + count1, points2, count2*sizeof(GpPointF));
|
|
GpMemcpy(types1 + count1, types2, count2);
|
|
BYTE saveType = types1[count1];
|
|
types1[count1] = PathPointTypeStart |
|
|
(saveType & ~PathPointTypePathTypeMask);
|
|
|
|
// Make sure the second path is closed.
|
|
|
|
types1[total - 1] |= PathPointTypeCloseSubpath;
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* This combines the two data points. This is a general algorithm.
|
|
* The output buffers (points and types) can be the same as the
|
|
* first input buffers (points1 and types1). In that case, both
|
|
* buffers must be allocated at least to the array size of
|
|
* count1 + count2.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] count - the allocated number of points (>= count1 + count2).
|
|
* [OUT] points - the combined data points.
|
|
* [OUT] types - the combined data types.
|
|
* [IN] count1 - the number of points of the first path.
|
|
* [IN] points1 - the first path points.
|
|
* [IN] types1 - the first path types.
|
|
* [IN] forward1 - the direction of the first path. TRUE if forward.
|
|
* [IN] count2 - the number of points of the second path.
|
|
* [IN] points2 - the second path points.
|
|
* [IN] types2 - the second path types.
|
|
* [IN] forward2 - the direction of the second path. TRUE if forward.
|
|
* [IN] connect - TRUE if the second line needs to be connected.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* The total number of points of the combined path.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
INT
|
|
CombinePaths(
|
|
INT count,
|
|
GpPointF* points,
|
|
BYTE* types,
|
|
INT count1,
|
|
const GpPointF* points1,
|
|
const BYTE* types1,
|
|
BOOL forward1,
|
|
INT count2,
|
|
const GpPointF* points2,
|
|
const BYTE* types2,
|
|
BOOL forward2,
|
|
BOOL connect
|
|
)
|
|
{
|
|
if(!points || !types || count < count1 + count2
|
|
|| count1 < 0 || !points1 || !types1
|
|
|| count2 < 0 || !points2 || !types2)
|
|
return 0;
|
|
|
|
// Check if the returning buffers are the same as the
|
|
// first input buffers.
|
|
|
|
INT resultCount = 0;
|
|
if(points != points1 || types != types1)
|
|
{
|
|
if(points == points1 || types == types1)
|
|
{
|
|
// The both output buffer must be different.
|
|
// If either of them is the same, don't combine
|
|
// the path.
|
|
|
|
return 0;
|
|
}
|
|
|
|
if(count1 > 0)
|
|
{
|
|
// Copy the first path.
|
|
|
|
DpPathIterator iter1(points1, types1, count1);
|
|
|
|
if(!iter1.IsValid())
|
|
return 0;
|
|
|
|
resultCount = iter1.Enumerate(points, types, count1);
|
|
|
|
if(resultCount <= 0)
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Both output buffers are the same as the first output
|
|
// buffers.
|
|
|
|
resultCount = count1;
|
|
}
|
|
|
|
GpStatus status = Ok;
|
|
BOOL path1Closed;
|
|
|
|
if(!forward1 && resultCount > 0)
|
|
{
|
|
status = ::ReversePath(resultCount, points, types);
|
|
if(status != Ok)
|
|
return 0;
|
|
}
|
|
|
|
if(count2 <= 0)
|
|
{
|
|
// No need to add the second path.
|
|
|
|
return resultCount;
|
|
}
|
|
|
|
// Regard the empty path as a closed path.
|
|
|
|
path1Closed = TRUE;
|
|
|
|
if(resultCount > 0)
|
|
{
|
|
// Check the last point of path1.
|
|
|
|
if((types[resultCount - 1] & PathPointTypeCloseSubpath))
|
|
path1Closed = TRUE;
|
|
else
|
|
path1Closed = FALSE;
|
|
}
|
|
|
|
INT totalCount = 0;
|
|
totalCount += resultCount;
|
|
|
|
DpPathIterator iter2(points2, types2, count2);
|
|
|
|
if(!iter2.IsValid())
|
|
return 0;
|
|
|
|
GpPointF* pts2 = points + resultCount;
|
|
BYTE* typs2 = types + resultCount;
|
|
|
|
resultCount = iter2.Enumerate(pts2, typs2, count2);
|
|
|
|
if(resultCount <= 0)
|
|
return 0;
|
|
|
|
if(!forward2)
|
|
{
|
|
status = ::ReversePath(resultCount, pts2, typs2);
|
|
if(status != Ok)
|
|
return 0;
|
|
}
|
|
|
|
// Check if the first subpath of path2 is closed or not.
|
|
|
|
BOOL path2Closed;
|
|
|
|
DpPathTypeIterator iter3(typs2, resultCount);
|
|
if(!iter3.IsValid())
|
|
return 0;
|
|
|
|
INT startIndex, endIndex;
|
|
iter3.NextSubpath(&startIndex, &endIndex, &path2Closed);
|
|
|
|
BYTE saveType= typs2[0];
|
|
|
|
if(path1Closed || path2Closed)
|
|
{
|
|
typs2[0] = PathPointTypeStart |
|
|
(saveType & ~PathPointTypePathTypeMask);
|
|
}
|
|
else
|
|
{
|
|
// Both paths are opened.
|
|
|
|
if(connect)
|
|
{
|
|
typs2[0] = PathPointTypeLine |
|
|
(saveType & ~PathPointTypePathTypeMask);
|
|
|
|
// Check if the end point of path1 and the start point of path2
|
|
// are the same. If so, skip this point.
|
|
|
|
if(REALABS(pts2[-1].X - pts2[0].X)
|
|
+ REALABS(pts2[-1].Y - pts2[0].Y) < POINTF_EPSILON)
|
|
{
|
|
for(INT i = 0; i < resultCount - 1; i++)
|
|
{
|
|
pts2[i] = pts2[i + 1];
|
|
typs2[i] = typs2[i + 1];
|
|
}
|
|
resultCount--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
typs2[0] = PathPointTypeStart |
|
|
(saveType & ~PathPointTypePathTypeMask);
|
|
}
|
|
}
|
|
|
|
totalCount += resultCount;
|
|
|
|
return totalCount;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Removes the degenerate points and copy only non-degenerate points.
|
|
* It is assumed that points and types array are allocated so that
|
|
* they can hold at least "count" number of elements.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] pathType - the type of the path data to be added.
|
|
* [OUT] points - the copied data points.
|
|
* [OUT] types - the copied data types.
|
|
* [IN] dataPoints - the original data points.
|
|
* [IN] count - the number of the original data points.
|
|
* [IN/OUT] lastPt - the last point.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* The total number of copied points.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
INT copyNonDegeneratePoints(
|
|
BYTE pathType,
|
|
GpPointF* points,
|
|
BYTE* types,
|
|
const GpPointF* dataPoints,
|
|
const BYTE* dataTypes,
|
|
INT count,
|
|
GpPointF* lastPt
|
|
)
|
|
{
|
|
GpPointF nextPt;
|
|
INT addedCount = 0;
|
|
|
|
if(pathType == PathPointTypeLine)
|
|
{
|
|
// Add only the different points.
|
|
|
|
for(INT i = 0; i < count; i++)
|
|
{
|
|
nextPt = *dataPoints++;
|
|
|
|
if( (REALABS(nextPt.X - lastPt->X) > REAL_EPSILON) ||
|
|
(REALABS(nextPt.Y - lastPt->Y) > REAL_EPSILON) )
|
|
{
|
|
*points++ = nextPt;
|
|
*lastPt = nextPt;
|
|
addedCount++;
|
|
}
|
|
}
|
|
if(addedCount > 0)
|
|
{
|
|
GpMemset(types, pathType, addedCount);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// In case of Bezier, we need to do
|
|
// degenerate case test for future.
|
|
|
|
addedCount = count;
|
|
|
|
if(addedCount > 0)
|
|
{
|
|
if(dataTypes)
|
|
{
|
|
GpMemcpy(types, dataTypes, addedCount);
|
|
}
|
|
else
|
|
{
|
|
GpMemset(types, pathType, addedCount);
|
|
}
|
|
|
|
GpMemcpy(
|
|
points,
|
|
dataPoints,
|
|
addedCount*sizeof(GpPointF)
|
|
);
|
|
}
|
|
else
|
|
{
|
|
addedCount = 0;
|
|
}
|
|
}
|
|
|
|
return addedCount;
|
|
}
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* This calculates the major and minor radius of an oval
|
|
* when the unit cricle is transformed by the given matrix.
|
|
* For further details, see ikkof's notes on Pen Transform.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [OUT] majorR - the major radius.
|
|
* [OUT] minorR - the minor radius.
|
|
* [IN] matrix - the matrix to transform the unit circle.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Status
|
|
*
|
|
* 01/28/00 ikkof
|
|
* Created it
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
GetMajorAndMinorAxis(REAL* majorR, REAL* minorR, const GpMatrix* matrix)
|
|
{
|
|
if(matrix == NULL)
|
|
{
|
|
// Regard this as an identity matrix.
|
|
*majorR = 1;
|
|
*minorR = 1;
|
|
return Ok;
|
|
}
|
|
|
|
REAL m11 = matrix->GetM11();
|
|
REAL m12 = matrix->GetM12();
|
|
REAL m21 = matrix->GetM21();
|
|
REAL m22 = matrix->GetM22();
|
|
|
|
REAL d1 = ((m11*m11 + m12*m12) - (m21*m21 + m22*m22))/2;
|
|
REAL d2 = m11*m21 + m12*m22;
|
|
REAL D = d1*d1 + d2*d2;
|
|
if(D > 0)
|
|
D = REALSQRT(D);
|
|
|
|
REAL r0 = (m11*m11 + m12*m12 + m21*m21 + m22*m22)/2;
|
|
|
|
REAL r1 = REALSQRT(r0 + D);
|
|
REAL r2 = REALSQRT(r0 - D);
|
|
|
|
// They should be positive numbers. Prevent the floating
|
|
// point underflow.
|
|
|
|
if(r1 <= CPLX_EPSILON)
|
|
r1 = CPLX_EPSILON;
|
|
if(r2 <= CPLX_EPSILON)
|
|
r2 = CPLX_EPSILON;
|
|
|
|
*majorR = r1;
|
|
*minorR = r2;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
VOID
|
|
GpPathWidener::Initialize(
|
|
const GpPointF* points,
|
|
const BYTE* types,
|
|
INT count,
|
|
const DpPen* pen,
|
|
const GpMatrix* matrix,
|
|
REAL dpiX, // These parameters are not really used
|
|
REAL dpiY, //
|
|
BOOL isAntiAliased, // This one is definitely not used.
|
|
BOOL isInsetPen
|
|
)
|
|
{
|
|
SetValid(FALSE);
|
|
|
|
Inset1 = 0;
|
|
Inset2 = 0;
|
|
NeedsToTransform = FALSE;
|
|
IsAntiAliased = isAntiAliased;
|
|
|
|
// nothing to widen, so return an invalid widener.
|
|
|
|
if( (!pen) || (count == 0) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
Pen = pen;
|
|
GpUnit unit = Pen->Unit;
|
|
InsetPenMode = isInsetPen;
|
|
|
|
if(unit == UnitWorld)
|
|
NeedsToTransform = FALSE;
|
|
else
|
|
NeedsToTransform = TRUE;
|
|
|
|
GpMatrix penTrans = ((DpPen*) Pen)->Xform;
|
|
BOOL hasPenTransform = FALSE;
|
|
|
|
if(!NeedsToTransform && !penTrans.IsTranslate())
|
|
{
|
|
hasPenTransform = TRUE;
|
|
penTrans.RemoveTranslation();
|
|
}
|
|
|
|
if(matrix)
|
|
XForm = *matrix; // Otherwise XForm remains Identity.
|
|
|
|
if(hasPenTransform)
|
|
{
|
|
XForm.Prepend(penTrans);
|
|
}
|
|
|
|
|
|
DpiX = dpiX;
|
|
DpiY = dpiY;
|
|
|
|
// 0 means use the Desktop DPI
|
|
|
|
if ((REALABS(DpiX) < REAL_EPSILON) ||
|
|
(REALABS(DpiY) < REAL_EPSILON) )
|
|
{
|
|
DpiX = Globals::DesktopDpiX;
|
|
DpiY = Globals::DesktopDpiY;
|
|
}
|
|
|
|
|
|
StrokeWidth = Pen->Width;
|
|
|
|
if(!NeedsToTransform)
|
|
{
|
|
REAL majorR, minorR;
|
|
|
|
::GetMajorAndMinorAxis(&majorR, &minorR, &XForm);
|
|
MaximumWidth = StrokeWidth*majorR;
|
|
MinimumWidth = StrokeWidth*minorR;
|
|
UnitScale = min (majorR, minorR);
|
|
}
|
|
else
|
|
{
|
|
UnitScale = ::GetDeviceWidth(1.0f, unit, dpiX);
|
|
StrokeWidth = UnitScale * StrokeWidth;
|
|
MinimumWidth = StrokeWidth;
|
|
}
|
|
|
|
OriginalStrokeWidth = StrokeWidth;
|
|
|
|
// Set minimum width to 1.0 (plus a bit for possible precision errors),
|
|
// so that narrow width pens don't end up leaving gaps in the line.
|
|
REAL minWidth = 1.000001f;
|
|
|
|
if(InsetPenMode)
|
|
{
|
|
minWidth *= 2.0f;
|
|
|
|
// Dashes smaller than a pixel are dropping out entirely in inset
|
|
// pen because of the rasterizer pixel level clipping that is taking
|
|
// place. We increase the minimum width of dashed lines making them
|
|
// roughly 4.0f. This also helps address the weird moire aliasing
|
|
// effects with the really small dash-dot round lines.
|
|
|
|
if(Pen->DashStyle != DashStyleSolid)
|
|
{
|
|
minWidth *= 2.0f;
|
|
}
|
|
}
|
|
|
|
if(!NeedsToTransform)
|
|
{
|
|
if(MinimumWidth < minWidth)
|
|
{
|
|
NeedsToTransform = TRUE;
|
|
StrokeWidth = minWidth;
|
|
MaximumWidth = minWidth;
|
|
MinimumWidth = minWidth;
|
|
|
|
// Ignore the pen transform.
|
|
|
|
XForm.Reset();
|
|
if(matrix)
|
|
XForm = *matrix;
|
|
|
|
hasPenTransform = FALSE;
|
|
penTrans.Reset();
|
|
}
|
|
}
|
|
|
|
InvXForm = XForm;
|
|
if(InvXForm.IsInvertible())
|
|
{
|
|
InvXForm.Invert();
|
|
|
|
if(hasPenTransform)
|
|
penTrans.Invert();
|
|
}
|
|
else
|
|
{
|
|
WARNING(("The matrix is degenerate for path widening constructor."));
|
|
return;
|
|
}
|
|
|
|
const GpPointF* points1 = points;
|
|
GpPointF pointBuffer[32];
|
|
GpPointF* points2 = pointBuffer;
|
|
|
|
if((hasPenTransform && !NeedsToTransform)|| (NeedsToTransform && !XForm.IsIdentity()))
|
|
{
|
|
if(count > 32)
|
|
{
|
|
points2 = (GpPointF*) GpMalloc(count*sizeof(GpPointF));
|
|
}
|
|
|
|
if(points2)
|
|
{
|
|
GpMemcpy(points2, points, count*sizeof(GpPointF));
|
|
|
|
if(hasPenTransform && !NeedsToTransform)
|
|
{
|
|
// Apply the inverse transform of Pen.
|
|
|
|
penTrans.Transform(points2, count);
|
|
}
|
|
else
|
|
{
|
|
// Transform to the device coordinates.
|
|
|
|
XForm.Transform(points2, count);
|
|
}
|
|
|
|
points1 = points2;
|
|
}
|
|
else
|
|
{
|
|
WARNING(("Not enough memory for path widening constructor."));
|
|
return;
|
|
}
|
|
}
|
|
|
|
DpPathIterator iter(points1, types, count);
|
|
|
|
if(!iter.IsValid())
|
|
{
|
|
if(points2 != pointBuffer)
|
|
{
|
|
GpFree(points2);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Make sure given poins are not degenerate.
|
|
|
|
BOOL degenerate = TRUE;
|
|
INT k = 1;
|
|
|
|
while(degenerate && k < count)
|
|
{
|
|
if(points1[k-1].X != points1[k].X || points1[k-1].Y != points1[k].Y)
|
|
degenerate = FALSE;
|
|
k++;
|
|
}
|
|
if(degenerate)
|
|
{
|
|
if(points2 != pointBuffer)
|
|
{
|
|
GpFree(points2);
|
|
}
|
|
WARNING(("Input data is degenerate for widening."));
|
|
return;
|
|
}
|
|
|
|
GpStatus status = Ok;
|
|
INT startIndex, endIndex;
|
|
BOOL isClosed;
|
|
INT dataCount = 0;
|
|
BYTE* ctrTypes = NULL;
|
|
GpPointF* ctrPoints = NULL;
|
|
GpPointF lastPt, nextPt;
|
|
|
|
while(iter.NextSubpath(&startIndex, &endIndex, &isClosed) && status == Ok)
|
|
{
|
|
INT typeStartIndex, typeEndIndex;
|
|
BYTE pathType;
|
|
BOOL isFirstPoint = TRUE;
|
|
|
|
while(iter.NextPathType(&pathType, &typeStartIndex, &typeEndIndex)
|
|
&& status == Ok)
|
|
{
|
|
INT segmentCount;
|
|
const GpPointF* dataPoints = NULL;
|
|
const BYTE* dataTypes = NULL;
|
|
|
|
nextPt = points1[typeStartIndex];
|
|
|
|
switch(pathType)
|
|
{
|
|
case PathPointTypeStart:
|
|
break;
|
|
|
|
case PathPointTypeBezier:
|
|
|
|
// The path must be flattened before calling widen.
|
|
|
|
ASSERT(FALSE);
|
|
break;
|
|
|
|
case PathPointTypeLine:
|
|
default: // And all other types are treated as line points.
|
|
|
|
// Get the data for the Line segment.
|
|
|
|
segmentCount = typeEndIndex - typeStartIndex + 1;
|
|
dataPoints = points1 + typeStartIndex;
|
|
dataTypes = NULL;
|
|
break;
|
|
}
|
|
|
|
if(status == Ok && pathType != PathPointTypeStart)
|
|
{
|
|
// Allocate memory for CenterTypes and CenterPoints.
|
|
|
|
status = CenterTypes.ReserveSpace(segmentCount);
|
|
if(status == Ok)
|
|
status = CenterPoints.ReserveSpace(segmentCount);
|
|
|
|
if(status == Ok)
|
|
{
|
|
ctrTypes = CenterTypes.GetDataBuffer();
|
|
ctrPoints = CenterPoints.GetDataBuffer();
|
|
}
|
|
else
|
|
{
|
|
ctrTypes = NULL;
|
|
ctrPoints = NULL;
|
|
}
|
|
|
|
if(ctrTypes && ctrPoints)
|
|
{
|
|
BYTE nextType;
|
|
|
|
INT count = CenterTypes.GetCount();
|
|
ctrTypes += count;
|
|
ctrPoints += count;
|
|
|
|
dataCount = 0;
|
|
|
|
// Add the first point.
|
|
|
|
if(isFirstPoint)
|
|
{
|
|
// We must check the dash mode
|
|
// for the first point of the subpath.
|
|
|
|
nextType = PathPointTypeStart;
|
|
if(iter.IsDashMode(typeStartIndex))
|
|
nextType |= PathPointTypeDashMode;
|
|
else
|
|
nextType &= ~PathPointTypeDashMode;
|
|
|
|
*ctrTypes++ = nextType;
|
|
*ctrPoints++ = nextPt;
|
|
lastPt = nextPt;
|
|
isFirstPoint = FALSE;
|
|
dataCount++;
|
|
}
|
|
else
|
|
{
|
|
// Don't copy the first
|
|
// if it is the same as the last point.
|
|
|
|
if(lastPt.X != nextPt.X || lastPt.Y != nextPt.Y)
|
|
{
|
|
// We don't have to check dash mode
|
|
// for the intermediate points.
|
|
|
|
nextType = PathPointTypeLine;
|
|
|
|
*ctrTypes++ = nextType;
|
|
*ctrPoints++ = nextPt;
|
|
lastPt = nextPt;
|
|
dataCount++;
|
|
}
|
|
}
|
|
|
|
// Add the remaining points.
|
|
|
|
segmentCount--;
|
|
dataPoints++;
|
|
if(dataTypes)
|
|
dataTypes++;
|
|
INT addedCount = copyNonDegeneratePoints(
|
|
pathType,
|
|
ctrPoints,
|
|
ctrTypes,
|
|
dataPoints,
|
|
dataTypes,
|
|
segmentCount,
|
|
&lastPt);
|
|
dataCount += addedCount;
|
|
|
|
CenterTypes.AdjustCount(dataCount);
|
|
CenterPoints.AdjustCount(dataCount);
|
|
}
|
|
else
|
|
status = OutOfMemory;
|
|
}
|
|
lastPt = points1[typeEndIndex];
|
|
}
|
|
|
|
if(status == Ok)
|
|
{
|
|
ctrTypes = CenterTypes.GetDataBuffer();
|
|
dataCount = CenterTypes.GetCount();
|
|
|
|
if(isClosed)
|
|
ctrTypes[dataCount - 1] |= PathPointTypeCloseSubpath;
|
|
else
|
|
ctrTypes[dataCount - 1] &= ~PathPointTypeCloseSubpath;
|
|
|
|
// We must check the dash mode for the last
|
|
// point of the subpath.
|
|
|
|
if(iter.IsDashMode(endIndex))
|
|
ctrTypes[dataCount - 1] |= PathPointTypeDashMode;
|
|
else
|
|
ctrTypes[dataCount - 1] &= ~PathPointTypeDashMode;
|
|
}
|
|
}
|
|
|
|
if(points2 != pointBuffer)
|
|
{
|
|
GpFree(points2);
|
|
}
|
|
|
|
if(status == Ok)
|
|
{
|
|
ctrPoints = CenterPoints.GetDataBuffer();
|
|
ctrTypes = CenterTypes.GetDataBuffer();
|
|
dataCount = CenterPoints.GetCount();
|
|
|
|
Iterator.SetData(ctrPoints, ctrTypes, dataCount);
|
|
SetValid(Iterator.IsValid());
|
|
|
|
#ifdef DEBUG_PATHWIDENER
|
|
|
|
if(!IsValid())
|
|
{
|
|
WARNING(("PathWidener is invalid."));
|
|
}
|
|
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Calculates the unit gradient vectors of points as array of
|
|
* (count + 1). All the memories must be allocated and be checked
|
|
* by the caller.
|
|
*
|
|
* The first element of the gradient is from the end point to the
|
|
* the start point. If the end point is identical to the start point,
|
|
* the previous point is used.
|
|
* The last element of the gradient is from the start point to the end
|
|
* point. If the start point is identical to the end point, the next
|
|
* point is used.
|
|
* If distances array is not NULL, this returns the distance of each
|
|
* segments.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [OUT] grad - The gradient array of (count + 1) elements.
|
|
* [OUT] distances - The distance array of (count + 1) elements or NULL.
|
|
* [IN] points - The given points of count elements.
|
|
* [IN] count - The number of given points.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Status
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
CalculateGradientArray(
|
|
GpPointF* grad,
|
|
REAL* distances,
|
|
const GpPointF* points,
|
|
INT count
|
|
)
|
|
{
|
|
GpPointF* grad1 = grad;
|
|
REAL* distances1 = distances;
|
|
const GpPointF* points1 = points;
|
|
|
|
// Go to the starting point of this subpath.
|
|
|
|
GpPointF startPt, endPt, lastPt, nextPt;
|
|
|
|
startPt = *points1;
|
|
|
|
INT i = count - 1;
|
|
BOOL different = FALSE;
|
|
points1 += i; // Go to the end point.
|
|
|
|
while(i > 0 && !different)
|
|
{
|
|
endPt = *points1--;
|
|
|
|
if(endPt.X != startPt.X || endPt.Y != startPt.Y)
|
|
different = TRUE;
|
|
|
|
i--;
|
|
}
|
|
|
|
if(!different)
|
|
{
|
|
// All points are the same.
|
|
|
|
WARNING(("Trying to calculate the gradients for degenerate points."));
|
|
return GenericError;
|
|
}
|
|
|
|
points1 = points;
|
|
lastPt = endPt;
|
|
|
|
i = 0;
|
|
|
|
while(i <= count)
|
|
{
|
|
REAL dx, dy, d;
|
|
|
|
if(i < count)
|
|
nextPt = *points1++;
|
|
else
|
|
nextPt = startPt;
|
|
|
|
dx = nextPt.X - lastPt.X;
|
|
dy = nextPt.Y - lastPt.Y;
|
|
d = dx*dx + dy*dy;
|
|
|
|
if(d > 0)
|
|
{
|
|
d = REALSQRT(d);
|
|
dx /= d;
|
|
dy /= d;
|
|
}
|
|
grad1->X = dx;
|
|
grad1->Y = dy;
|
|
|
|
// Record the distance only when the given distance array is not NULL.
|
|
|
|
if(distances)
|
|
*distances1++ = d;
|
|
|
|
grad1++;
|
|
lastPt = nextPt;
|
|
i++;
|
|
}
|
|
|
|
// Make sure the last gradient is not 0.
|
|
|
|
grad1 = grad + count;
|
|
if(grad1->X == 0 && grad1->Y == 0)
|
|
{
|
|
// The start and end point are the same. Find
|
|
// the next non-zero gradient.
|
|
|
|
i = 1;
|
|
grad1 = grad + i;
|
|
|
|
while(i < count)
|
|
{
|
|
if(grad1->X != 0 || grad1->Y != 0)
|
|
{
|
|
grad[count] = *grad1;
|
|
|
|
if(distances)
|
|
distances[count] = distances[i];
|
|
break;
|
|
}
|
|
i++;
|
|
grad1++;
|
|
}
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Calculates the normal gradient of points between startIndex
|
|
* and endIndex. The last element of the gradient is from endIndex
|
|
* to startIndex. If the next point is identical to the previous point,
|
|
* the gradient is set to (0, 0).
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] startIndex - the starting index.
|
|
* [IN] endIndex - the ending index.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Status
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
GpPathWidener::CalculateGradients(INT startIndex, INT endIndex)
|
|
{
|
|
GpPointF* points0 = CenterPoints.GetDataBuffer();
|
|
INT count = endIndex - startIndex + 1;
|
|
|
|
if(!points0 || count <= 0)
|
|
return GenericError;
|
|
|
|
Gradients.Reset(FALSE);
|
|
|
|
GpPointF* grad = Gradients.AddMultiple(count + 1);
|
|
|
|
if(!grad)
|
|
return OutOfMemory;
|
|
|
|
GpPointF* points = points0 + startIndex;
|
|
|
|
return CalculateGradientArray(grad, NULL, points, count);
|
|
}
|
|
|
|
|
|
GpStatus
|
|
GpPathWidener::CalculateNormals(
|
|
REAL leftWidth,
|
|
REAL rightWidth
|
|
)
|
|
{
|
|
NeedsToAdjustNormals = FALSE;
|
|
|
|
INT count = Gradients.GetCount();
|
|
GpPointF* grad0 = Gradients.GetDataBuffer();
|
|
|
|
if(count <= 0)
|
|
{
|
|
WARNING(("Gradients must be calculated\n"
|
|
"before the normals are calculated."));
|
|
return GenericError;
|
|
}
|
|
|
|
Normals.Reset(FALSE);
|
|
GpPointF* norm0 = Normals.AddMultiple(count);
|
|
|
|
if(!norm0)
|
|
return OutOfMemory;
|
|
|
|
|
|
GpPointF* norm = norm0;
|
|
GpPointF* grad = grad0;
|
|
|
|
// Calculate the left normals.
|
|
|
|
INT i;
|
|
|
|
for(i = 0; i < count; i++)
|
|
{
|
|
norm->X = grad->Y;
|
|
norm->Y = - grad->X;
|
|
norm++;
|
|
grad++;
|
|
}
|
|
|
|
if(IsAntiAliased)
|
|
return Ok;
|
|
|
|
// Check if the minimum width is less than 1.0.
|
|
|
|
REAL width = REALABS(leftWidth - rightWidth);
|
|
|
|
if(width*MinimumWidth >= 1.0f)
|
|
return Ok;
|
|
|
|
NeedsToAdjustNormals = TRUE;
|
|
|
|
if(!NeedsToTransform)
|
|
{
|
|
// Transform to the device space.
|
|
// When NeedsToTransform is TRUE, the gradient is already
|
|
// calculated in the device coordinates.
|
|
|
|
if(!XForm.IsIdentity())
|
|
XForm.VectorTransform(norm0, count);
|
|
}
|
|
|
|
// Set the minimum line width to be just over 1.0
|
|
REAL criteria = 1.00005f;
|
|
REAL value;
|
|
|
|
if(width > 0)
|
|
value = criteria/width;
|
|
else
|
|
value = criteria*MinimumWidth/1.0f;
|
|
|
|
norm = norm0;
|
|
|
|
for(i = 0; i < count; i++)
|
|
{
|
|
REAL xx = REALABS(norm->X);
|
|
REAL yy = REALABS(norm->Y);
|
|
|
|
if(xx >= yy)
|
|
{
|
|
if(width*xx < criteria)
|
|
{
|
|
if(norm->X >= 0)
|
|
norm->X = value;
|
|
else
|
|
norm->X = - value;
|
|
|
|
norm->Y = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(width*yy < criteria)
|
|
{
|
|
if(norm->Y >= 0)
|
|
norm->Y = value;
|
|
else
|
|
norm->Y = - value;
|
|
|
|
norm->X = 0;
|
|
}
|
|
}
|
|
|
|
norm++;
|
|
}
|
|
|
|
if(!NeedsToTransform)
|
|
{
|
|
// Transform back to the world space in case of
|
|
// a non fixed width pen.
|
|
|
|
if(!InvXForm.IsIdentity())
|
|
InvXForm.VectorTransform(norm0, count);
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus
|
|
GpPathWidener::Widen(GpPath **path)
|
|
{
|
|
// Must be a pointer to a path pointer that is NULL.
|
|
|
|
ASSERT(path != NULL);
|
|
ASSERT(*path == NULL);
|
|
|
|
GpStatus status = Ok;
|
|
|
|
// Get the widened path points and types into the
|
|
// dynarray objects.
|
|
|
|
DynPointFArray widenedPoints;
|
|
DynByteArray widenedTypes;
|
|
|
|
status = Widen(
|
|
&widenedPoints,
|
|
&widenedTypes
|
|
);
|
|
|
|
if(status != Ok) { return status; }
|
|
|
|
// Remove the internal flag.
|
|
|
|
INT pathCount = widenedTypes.GetCount();
|
|
BYTE* pathTypes = widenedTypes.GetDataBuffer();
|
|
for(INT i = 0; i < pathCount; i++, pathTypes++)
|
|
{
|
|
if(*pathTypes & PathPointTypeInternalUse)
|
|
{
|
|
*pathTypes &= ~PathPointTypeInternalUse;
|
|
}
|
|
}
|
|
|
|
// If everything worked, create a new path
|
|
// from the widened points.
|
|
|
|
if(status == Ok)
|
|
{
|
|
*path = new GpPath(
|
|
widenedPoints.GetDataBuffer(),
|
|
widenedTypes.GetDataBuffer(),
|
|
widenedPoints.GetCount(),
|
|
FillModeWinding
|
|
);
|
|
|
|
if(*path == NULL) { status = OutOfMemory; }
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
GpStatus
|
|
GpPathWidener::Widen(
|
|
DynPointFArray* widenedPoints,
|
|
DynByteArray* widenedTypes
|
|
)
|
|
{
|
|
FPUStateSaver::AssertMode();
|
|
|
|
if(!IsValid() || !widenedPoints || !widenedTypes)
|
|
{
|
|
return InvalidParameter;
|
|
}
|
|
|
|
const GpPointF* centerPoints = CenterPoints.GetDataBuffer();
|
|
const BYTE* centerTypes = CenterTypes.GetDataBuffer();
|
|
INT centerCount = CenterPoints.GetCount();
|
|
|
|
INT startIndex, endIndex;
|
|
BOOL isClosed;
|
|
GpStatus status = Ok;
|
|
|
|
DynPointFArray customStartCapPoints;
|
|
DynPointFArray customEndCapPoints;
|
|
DynByteArray customStartCapTypes;
|
|
DynByteArray customEndCapTypes;
|
|
|
|
// Clear the data in widenedPoints and widenedTypes.
|
|
|
|
widenedPoints->Reset(FALSE);
|
|
widenedTypes->Reset(FALSE);
|
|
|
|
REAL width = OriginalStrokeWidth;
|
|
|
|
INT compoundCount = Pen->CompoundCount;
|
|
|
|
REAL* compoundArray = NULL;
|
|
INT cpCount;
|
|
|
|
if(compoundCount > 0)
|
|
cpCount = compoundCount;
|
|
else
|
|
cpCount = 2;
|
|
|
|
REAL compoundArray0[8];
|
|
|
|
if(cpCount <= 8)
|
|
compoundArray = &compoundArray0[0];
|
|
else
|
|
compoundArray = (REAL*) GpMalloc(cpCount*sizeof(REAL));
|
|
|
|
INT kk;
|
|
|
|
if(compoundArray)
|
|
{
|
|
// Don't attempt to draw a compound line that is empty, or is aliased and has
|
|
// more line components than the width of the line. It can be rounded out of
|
|
// existance
|
|
if(compoundCount > 0 &&
|
|
(IsAntiAliased || (compoundCount / 2) <= (width * UnitScale)))
|
|
{
|
|
// Don't attempt to draw a compound line that is less than 0.5 device
|
|
// units in width. These can disappear when rasterized, depending on
|
|
// what Y coordinate they fall on.
|
|
if ((UnitScale * width) >= 0.5f)
|
|
{
|
|
GpMemcpy(compoundArray, Pen->CompoundArray, compoundCount*sizeof(REAL));
|
|
|
|
for(kk = 0; kk < compoundCount; kk++)
|
|
{
|
|
compoundArray[kk] *= width;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
compoundArray[0] = 0;
|
|
compoundArray[1] = 0.5f;
|
|
if (cpCount > 2)
|
|
{
|
|
cpCount = 2;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
compoundArray[0] = 0;
|
|
compoundArray[1] = StrokeWidth;
|
|
if (cpCount > 2)
|
|
{
|
|
cpCount = 2;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetValid(FALSE);
|
|
return OutOfMemory;
|
|
}
|
|
|
|
|
|
REAL left0, right0;
|
|
BOOL isCenteredPen = FALSE;
|
|
BOOL needsToFlip = FALSE;
|
|
|
|
if(Pen->PenAlignment == PenAlignmentInset)
|
|
{
|
|
// Check if the coordinates are flipped.
|
|
// If the determinant of the transform matrix is negative,
|
|
// the coordinate system is flipped.
|
|
|
|
if(XForm.IsInvertible() && XForm.GetDeterminant() < 0)
|
|
needsToFlip = TRUE;
|
|
}
|
|
|
|
// OriginalStrokeWidth is required for the compound lines, but we're
|
|
// widening now and StrokeWidth == max(OriginalStrokeWidth, MinimumWidth)
|
|
// which is the value we need to widen at in order to avoid dropping out
|
|
// lines.
|
|
|
|
width = StrokeWidth;
|
|
|
|
switch(Pen->PenAlignment)
|
|
{
|
|
case PenAlignmentInset:
|
|
if(!needsToFlip)
|
|
left0 = 0; // Same as right align.
|
|
else
|
|
left0 = width; // Same as left align.
|
|
break;
|
|
|
|
case PenAlignmentCenter:
|
|
default:
|
|
left0 = width/2;
|
|
isCenteredPen = TRUE;
|
|
}
|
|
|
|
right0 = left0 - width;
|
|
|
|
REAL startInset0 = 0, endInset0 = 0;
|
|
GpCustomLineCap* customStartCap = NULL;
|
|
GpCustomLineCap* customEndCap = NULL;
|
|
|
|
while(Iterator.NextSubpath(&startIndex, &endIndex, &isClosed)
|
|
&& status == Ok)
|
|
{
|
|
GpLineCap startCap = Pen->StartCap;
|
|
GpLineCap endCap = Pen->EndCap;
|
|
BYTE startType = centerTypes[startIndex];
|
|
BYTE endType = centerTypes[endIndex];
|
|
|
|
GpLineCapMode startCapMode = LineCapDefaultMode;
|
|
GpLineCapMode endCapMode = LineCapDefaultMode;
|
|
|
|
if(startType & PathPointTypeDashMode)
|
|
{
|
|
startCap = Pen->DashCap;
|
|
startCapMode = LineCapDashMode;
|
|
}
|
|
else
|
|
{
|
|
// If the start cap is one of the anchor caps, default the widener
|
|
// to using the dashcap for the startCap.
|
|
|
|
if(((startCap & LineCapAnchorMask) != 0) ||
|
|
(startCap == LineCapCustom))
|
|
{
|
|
startCap = Pen->DashCap;
|
|
}
|
|
}
|
|
|
|
if(endType & PathPointTypeDashMode)
|
|
{
|
|
endCap = Pen->DashCap;
|
|
endCapMode = LineCapDashMode;
|
|
}
|
|
else
|
|
{
|
|
// If the end cap is one of the anchor caps, default the widener
|
|
// to using the dashcap for the endCap.
|
|
|
|
if(((endCap & LineCapAnchorMask) != 0) ||
|
|
(endCap == LineCapCustom))
|
|
{
|
|
endCap = Pen->DashCap;
|
|
}
|
|
}
|
|
|
|
if(InsetPenMode)
|
|
{
|
|
// Inset pen only supports these caps.
|
|
|
|
if(endCap != LineCapRound && endCap != LineCapFlat)
|
|
{
|
|
endCap = LineCapFlat;
|
|
}
|
|
if(startCap != LineCapRound && startCap != LineCapFlat)
|
|
{
|
|
startCap = LineCapFlat;
|
|
}
|
|
}
|
|
|
|
Inset1 = Inset2 = 0.0f;
|
|
if(startCap == LineCapSquare)
|
|
{
|
|
Inset1 = -0.5f*StrokeWidth;
|
|
}
|
|
if(endCap == LineCapSquare)
|
|
{
|
|
Inset2 = -0.5f*StrokeWidth;
|
|
}
|
|
|
|
status = CalculateGradients(startIndex, endIndex);
|
|
|
|
kk = 0;
|
|
|
|
BOOL isCompoundLine = FALSE;
|
|
GpLineCap startCap1 = startCap;
|
|
GpLineCap endCap1 = endCap;
|
|
|
|
if(cpCount > 2)
|
|
{
|
|
// Don't add the caps for the individual
|
|
// compound line.
|
|
|
|
isCompoundLine = TRUE;
|
|
startCap1 = LineCapFlat;
|
|
endCap1 = LineCapFlat;
|
|
}
|
|
|
|
while(kk < cpCount && status == Ok)
|
|
{
|
|
REAL leftWidth = left0 - compoundArray[kk];
|
|
REAL rightWidth = left0 - compoundArray[kk + 1];
|
|
|
|
if(REALABS(leftWidth-rightWidth)>REAL_EPSILON)
|
|
{
|
|
status = CalculateNormals(leftWidth, rightWidth);
|
|
if(status != Ok) { break; }
|
|
|
|
// Check if we can use the Bevel join for inside lines.
|
|
|
|
BOOL useBevelJoinInside = isCenteredPen && !isCompoundLine;
|
|
|
|
if(USE_POLYGON_JOIN)
|
|
{
|
|
status = SetPolygonJoin(leftWidth, rightWidth, FALSE);
|
|
}
|
|
|
|
status = WidenSubpath(
|
|
widenedPoints,
|
|
widenedTypes,
|
|
leftWidth,
|
|
rightWidth,
|
|
startIndex,
|
|
endIndex,
|
|
isClosed,
|
|
startCap1,
|
|
endCap1,
|
|
useBevelJoinInside
|
|
);
|
|
|
|
Iterator.RewindSubpath();
|
|
}
|
|
|
|
kk += 2;
|
|
}
|
|
// Add the compound line caps if necessary.
|
|
|
|
if(status == Ok && isCompoundLine && !isClosed)
|
|
{
|
|
status = AddCompoundCaps(
|
|
widenedPoints,
|
|
widenedTypes,
|
|
left0,
|
|
right0,
|
|
startIndex,
|
|
endIndex,
|
|
startCap,
|
|
endCap
|
|
);
|
|
}
|
|
|
|
}
|
|
|
|
if(status != Ok) { return status; }
|
|
|
|
GpPointF* pts;
|
|
INT count;
|
|
|
|
if(!NeedsToTransform)
|
|
{
|
|
GpMatrix penTrans = ((DpPen*) Pen)->Xform;
|
|
BOOL hasPenTransform = FALSE;
|
|
|
|
if(!penTrans.IsTranslate())
|
|
{
|
|
hasPenTransform = TRUE;
|
|
penTrans.RemoveTranslation();
|
|
|
|
pts = widenedPoints->GetDataBuffer();
|
|
count = widenedPoints->GetCount();
|
|
penTrans.Transform(pts, count);
|
|
}
|
|
}
|
|
else if(!InvXForm.IsIdentity())
|
|
{
|
|
// Case of the Fixed width pen.
|
|
|
|
pts = widenedPoints->GetDataBuffer();
|
|
count = widenedPoints->GetCount();
|
|
InvXForm.Transform(pts, count);
|
|
}
|
|
|
|
#ifdef DEBUG_PATHWIDENER
|
|
|
|
if(status == Ok)
|
|
{
|
|
DpPathTypeIterator iter2(widenedTypes->GetDataBuffer(),
|
|
widenedTypes->GetCount());
|
|
|
|
if(!iter2.IsValid())
|
|
{
|
|
WARNING(("Widening result is not valid."));
|
|
status = GenericError;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
if(status == Ok)
|
|
SetValid(TRUE);
|
|
|
|
if(compoundArray != &compoundArray0[0])
|
|
GpFree(compoundArray);
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
GpStatus
|
|
GpPathWidener::WidenSubpath(
|
|
DynPointFArray* widenedPoints,
|
|
DynByteArray* widenedTypes,
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
INT startIndex,
|
|
INT endIndex,
|
|
BOOL isClosed,
|
|
GpLineCap startCap,
|
|
GpLineCap endCap,
|
|
BOOL useBevelJoinInside
|
|
)
|
|
{
|
|
const GpPointF* centerPoints = CenterPoints.GetDataBuffer();
|
|
const BYTE* centerTypes = CenterTypes.GetDataBuffer();
|
|
INT centerCount = CenterPoints.GetCount();
|
|
|
|
GpLineJoin lineJoin = Pen->Join;
|
|
REAL miterLimit2 = Pen->MiterLimit;
|
|
miterLimit2 *= miterLimit2;
|
|
|
|
INT typeStartIndex, typeEndIndex;
|
|
BYTE pathType;
|
|
BOOL isFirstType = TRUE;
|
|
BOOL isLastType = FALSE;
|
|
BOOL isLastPointSame;
|
|
GpPointF startPt, endPt;
|
|
|
|
startPt = centerPoints[startIndex];
|
|
endPt = centerPoints[endIndex];
|
|
|
|
if(startPt.X != endPt.X || startPt.Y != endPt.Y)
|
|
isLastPointSame = FALSE;
|
|
else
|
|
isLastPointSame = TRUE;
|
|
|
|
// Reset the left and right buffers.
|
|
|
|
LeftTypes.Reset(FALSE);
|
|
LeftPoints.Reset(FALSE);
|
|
RightTypes.Reset(FALSE);
|
|
RightPoints.Reset(FALSE);
|
|
|
|
INT subpathCount = endIndex - startIndex + 1;
|
|
INT joinMultiplier = 2;
|
|
|
|
if(lineJoin == LineJoinRound)
|
|
joinMultiplier = 7;
|
|
|
|
GpStatus status = LeftTypes.ReserveSpace(joinMultiplier*subpathCount);
|
|
if(status == Ok)
|
|
status = LeftPoints.ReserveSpace(joinMultiplier*subpathCount);
|
|
if(status == Ok)
|
|
status = RightTypes.ReserveSpace(joinMultiplier*subpathCount);
|
|
if(status == Ok)
|
|
status = RightPoints.ReserveSpace(joinMultiplier*subpathCount);
|
|
|
|
if(status != Ok)
|
|
return status;
|
|
|
|
// Get Gradient data buffer.
|
|
|
|
GpPointF *grad0, *norm0;
|
|
|
|
grad0 = Gradients.GetDataBuffer();
|
|
norm0 = Normals.GetDataBuffer();
|
|
|
|
// Get Left and Right data buffers.
|
|
|
|
GpPointF* leftPoints0 = LeftPoints.GetDataBuffer();
|
|
BYTE* leftTypes0 = LeftTypes.GetDataBuffer();
|
|
GpPointF* rightPoints0 = RightPoints.GetDataBuffer();
|
|
BYTE* rightTypes0 = RightTypes.GetDataBuffer();
|
|
|
|
GpPointF lastPt, nextPt;
|
|
GpPointF leftEndPt, rightEndPt;
|
|
|
|
INT leftCount = 0, rightCount = 0;
|
|
|
|
INT flag = 0;
|
|
|
|
if(isClosed)
|
|
flag |= WideningClosed;
|
|
if(isFirstType)
|
|
flag |= WideningFirstType;
|
|
if(isLastType)
|
|
flag |= WideningLastType;
|
|
if(isLastPointSame)
|
|
flag |= WideningLastPointSame;
|
|
if(NeedsToAdjustNormals)
|
|
flag |= WideningNeedsToAdjustNormals;
|
|
if(useBevelJoinInside)
|
|
flag |= WideningUseBevelJoinInside;
|
|
|
|
const GpPointF* dataPoints = centerPoints + startIndex;
|
|
INT dataCount = endIndex - startIndex + 1;
|
|
|
|
REAL firstInsets[2], lastInsets[2];
|
|
|
|
// Never inset more than the length of the line for the first inset, and
|
|
// never more than the amount left on the line after the first inset
|
|
// has been applied. This can result in odd endcaps and dashcaps when you
|
|
// have a line that ends in the middle of a short dash segment.
|
|
|
|
REAL linelength = REALSQRT(
|
|
distance_squared(
|
|
centerPoints[startIndex],
|
|
centerPoints[endIndex]
|
|
)
|
|
);
|
|
|
|
firstInsets[0] = min(Inset1, linelength);
|
|
firstInsets[1] = min(Inset1, linelength);
|
|
lastInsets[0] = min(Inset2, linelength-firstInsets[0]);
|
|
lastInsets[1] = min(Inset2, linelength-firstInsets[1]);
|
|
|
|
WidenFirstPoint(
|
|
leftWidth,
|
|
rightWidth,
|
|
lineJoin,
|
|
miterLimit2,
|
|
leftPoints0,
|
|
leftTypes0,
|
|
&leftCount,
|
|
rightPoints0,
|
|
rightTypes0,
|
|
&rightCount,
|
|
&leftEndPt,
|
|
&rightEndPt,
|
|
grad0,
|
|
norm0,
|
|
dataPoints,
|
|
dataCount,
|
|
&lastPt,
|
|
&firstInsets[0],
|
|
flag
|
|
);
|
|
|
|
// Iterate through all subtypes in the current subpath.
|
|
|
|
while(Iterator.NextPathType(&pathType, &typeStartIndex, &typeEndIndex)
|
|
&& status == Ok)
|
|
{
|
|
// Offset index from the current subpath.
|
|
|
|
INT offsetIndex = typeStartIndex - startIndex;
|
|
GpPointF* grad = grad0 + offsetIndex;
|
|
GpPointF* norm = norm0 + offsetIndex;
|
|
|
|
// Get the starting data buffers of the current subtypes.
|
|
|
|
dataPoints = centerPoints + typeStartIndex;
|
|
dataCount = typeEndIndex - typeStartIndex + 1;
|
|
|
|
// Get the starting buffers for the left and right data.
|
|
|
|
GpPointF* leftPoints = leftPoints0 + leftCount;
|
|
BYTE* leftTypes = leftTypes0 + leftCount;
|
|
GpPointF* rightPoints = rightPoints0 + rightCount;
|
|
BYTE* rightTypes = rightTypes0 + rightCount;
|
|
|
|
INT addedLeftCount = 0, addedRightCount = 0;
|
|
|
|
if(pathType != PathPointTypeStart)
|
|
{
|
|
if(typeEndIndex == endIndex)
|
|
isLastType = TRUE;
|
|
|
|
flag = 0;
|
|
|
|
if(isClosed)
|
|
flag |= WideningClosed;
|
|
if(isFirstType)
|
|
flag |= WideningFirstType;
|
|
if(isLastType)
|
|
flag |= WideningLastType;
|
|
if(isLastPointSame)
|
|
flag |= WideningLastPointSame;
|
|
if(NeedsToAdjustNormals)
|
|
flag |= WideningNeedsToAdjustNormals;
|
|
if(useBevelJoinInside)
|
|
flag |= WideningUseBevelJoinInside;
|
|
|
|
status = WidenEachPathType(
|
|
pathType,
|
|
leftWidth,
|
|
rightWidth,
|
|
lineJoin,
|
|
miterLimit2,
|
|
leftPoints,
|
|
leftTypes,
|
|
&addedLeftCount,
|
|
rightPoints,
|
|
rightTypes,
|
|
&addedRightCount,
|
|
grad,
|
|
norm,
|
|
dataPoints,
|
|
dataCount,
|
|
&lastPt,
|
|
&lastInsets[0],
|
|
flag
|
|
);
|
|
|
|
leftCount += addedLeftCount;
|
|
rightCount += addedRightCount;
|
|
if(isFirstType && (leftCount > 0 || rightCount > 0))
|
|
isFirstType = FALSE;
|
|
}
|
|
lastPt = centerPoints[typeEndIndex];
|
|
|
|
}
|
|
|
|
if(status == Ok)
|
|
{
|
|
LeftTypes.SetCount(leftCount);
|
|
LeftPoints.SetCount(leftCount);
|
|
RightTypes.SetCount(rightCount);
|
|
RightPoints.SetCount(rightCount);
|
|
}
|
|
else
|
|
return status;
|
|
|
|
GpPointF startPoint, endPoint;
|
|
GpPointF startGrad, endGrad;
|
|
GpPointF startNorm, endNorm;
|
|
|
|
startPoint = *(centerPoints + startIndex);
|
|
endPoint = *(centerPoints + endIndex);
|
|
startGrad = grad0[1];
|
|
endGrad = grad0[endIndex - startIndex];
|
|
startNorm = norm0[1];
|
|
endNorm = norm0[endIndex - startIndex];
|
|
|
|
status = SetCaps(
|
|
startCap,
|
|
endCap,
|
|
startPoint,
|
|
startGrad,
|
|
startNorm,
|
|
endPoint,
|
|
endGrad,
|
|
endNorm,
|
|
leftWidth,
|
|
rightWidth,
|
|
centerPoints + startIndex,
|
|
endIndex - startIndex + 1
|
|
);
|
|
|
|
status = CombineSubpathOutlines(
|
|
widenedPoints,
|
|
widenedTypes,
|
|
isClosed
|
|
);
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
|
|
GpStatus
|
|
GpPathWidener::SetPolygonJoin(
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
BOOL isAntialiased
|
|
)
|
|
{
|
|
// This codes is intended to non-pen transform and in WorldUnit for now.
|
|
|
|
REAL minimumWidth = MinimumWidth;
|
|
if(leftWidth - rightWidth < StrokeWidth)
|
|
minimumWidth = (leftWidth - rightWidth)/StrokeWidth;
|
|
|
|
const INT maxPolyCount = 8;
|
|
INT count = 0;
|
|
GpPointF points[maxPolyCount];
|
|
REAL grads[maxPolyCount];
|
|
|
|
JoinPolygonPoints.Reset(FALSE);
|
|
JoinPolygonAngles.Reset(FALSE);
|
|
|
|
// Define Hobby's polygon.
|
|
|
|
if(minimumWidth < 1.06)
|
|
{
|
|
count = 4;
|
|
points[0].X = 0.0f; points[0].Y = -0.5f;
|
|
points[1].X = 0.5f; points[1].Y = 0.0f;
|
|
points[2].X = 0.0f; points[2].Y = 0.5f;
|
|
points[3].X = -0.5f; points[3].Y = 0.0f;
|
|
}
|
|
else if(minimumWidth < 1.5)
|
|
{
|
|
count = 4;
|
|
points[0].X = -0.5f; points[0].Y = -0.5f;
|
|
points[1].X = 0.5f; points[1].Y = -0.5f;
|
|
points[2].X = 0.5f; points[2].Y = 0.5f;
|
|
points[3].X = -0.5f; points[3].Y = 0.5f;
|
|
}
|
|
else if(minimumWidth < 1.77)
|
|
{
|
|
count = 4;
|
|
points[0].X = 0.0f; points[0].Y = -1.0f;
|
|
points[1].X = 1.0f; points[1].Y = 0.0f;
|
|
points[2].X = 0.0f; points[2].Y = 1.0f;
|
|
points[3].X = -1.0f; points[3].Y = 0.0f;
|
|
}
|
|
else if(minimumWidth < 2.02)
|
|
{
|
|
count = 6;
|
|
points[0].X = -0.5f; points[0].Y = -1.0f;
|
|
points[1].X = 0.5f; points[1].Y = -1.0f;
|
|
points[2].X = 1.0f; points[2].Y = 0.0f;
|
|
points[3].X = 0.5f; points[3].Y = 1.0f;
|
|
points[4].X = -0.5f; points[4].Y = 1.0f;
|
|
points[5].X = -1.0f; points[5].Y = 0.0f;
|
|
}
|
|
else if(minimumWidth < 2.48)
|
|
{
|
|
count = 8;
|
|
points[0].X = -0.5f; points[0].Y = -1.0f;
|
|
points[1].X = 0.5f; points[1].Y = -1.0f;
|
|
points[2].X = 1.0f; points[2].Y = -0.5f;
|
|
points[3].X = 1.0f; points[3].Y = 0.5f;
|
|
points[4].X = 0.5f; points[4].Y = 1.0f;
|
|
points[5].X = -0.5f; points[5].Y = 1.0f;
|
|
points[6].X = -1.0f; points[6].Y = 0.5f;
|
|
points[7].X = -1.0f; points[7].Y = -0.5f;
|
|
}
|
|
else if(minimumWidth < 2.5)
|
|
{
|
|
count = 4;
|
|
points[0].X = -1.0f; points[0].Y = -1.0f;
|
|
points[1].X = 1.0f; points[1].Y = -1.0f;
|
|
points[2].X = 1.0f; points[2].Y = 1.0f;
|
|
points[3].X = -1.0f; points[3].Y = 1.0f;
|
|
}
|
|
else if(minimumWidth < 2.91)
|
|
{
|
|
count = 8;
|
|
points[0].X = 0.0f; points[0].Y = -1.5f;
|
|
points[1].X = 1.0f; points[1].Y = -1.0f;
|
|
points[2].X = 1.5f; points[2].Y = 0.0f;
|
|
points[3].X = 1.0f; points[3].Y = 1.0f;
|
|
points[4].X = 0.0f; points[4].Y = 1.5f;
|
|
points[5].X = -1.0f; points[5].Y = 1.0f;
|
|
points[6].X = -1.5f; points[6].Y = 0.0f;
|
|
points[7].X = -1.0f; points[7].Y = -1.0f;
|
|
}
|
|
else
|
|
count = 0;
|
|
|
|
if(count > 0)
|
|
{
|
|
GpPointF dP;
|
|
|
|
for(INT i = 0; i < count - 1; i++)
|
|
{
|
|
dP = points[i + 1] - points[i];
|
|
GetFastAngle(&grads[i], dP);
|
|
}
|
|
|
|
dP = points[0] - points[count - 1];
|
|
GetFastAngle(&grads[count - 1], dP);
|
|
|
|
|
|
|
|
REAL lastAngle = grads[0];
|
|
REAL nextAngle;
|
|
|
|
/*
|
|
// Find out the smallest gradient.
|
|
|
|
INT i0 = 0;
|
|
for(i = 1; i < count; i++)
|
|
{
|
|
nextAngle = grads[i];
|
|
if(nextAngle < lastAngle)
|
|
i0 = i;
|
|
lastAngle = nextAngle;
|
|
}
|
|
|
|
// Rearrange so that the polygon starts with the smallest
|
|
// gradient.
|
|
|
|
if(i0 > 1)
|
|
{
|
|
GpPointF tempPointsBuff[maxPolyCount];
|
|
REAL tempGradsBuff[maxPolyCount];
|
|
|
|
GpMemcpy(&tempPointsBuff[0], &points[0], i0*sizeof(GpPointF));
|
|
GpMemcpy(&tempGradsBuff[0], &grads[0], i0);
|
|
GpMemcpy(&points[0],
|
|
&points[i0], (count - i0)*sizeof(GpPointF));
|
|
GpMemcpy(&grads[0], &grads[i0], count - i0);
|
|
GpMemcpy(&points[count - i0], &tempPointsBuff[0],
|
|
i0*sizeof(GpPointF));
|
|
GpMemcpy(&grads[count - i0], &tempGradsBuff[0], i0);
|
|
}
|
|
*/
|
|
|
|
BOOL monotonic = TRUE;
|
|
i = 1;
|
|
lastAngle = grads[0];
|
|
|
|
while(monotonic && i < count)
|
|
{
|
|
nextAngle = grads[i];
|
|
if(nextAngle < lastAngle)
|
|
monotonic = FALSE;
|
|
i++;
|
|
lastAngle = nextAngle;
|
|
}
|
|
|
|
ASSERTMSG(monotonic, ("Polygon for join is not concave."));
|
|
}
|
|
|
|
if(count > 0)
|
|
{
|
|
JoinPolygonPoints.AddMultiple(&points[0], count);
|
|
JoinPolygonAngles.AddMultiple(&grads[0], count);
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
INT getVertexID(const GpPointF& vector, BOOL forLeftEdge, INT count, const REAL* grads)
|
|
{
|
|
INT left, right, middle;
|
|
REAL angle = 0.0f;
|
|
|
|
GetFastAngle(&angle, vector);
|
|
|
|
if(!forLeftEdge)
|
|
{
|
|
angle += 4;
|
|
if(angle >= 8)
|
|
angle -= 8;
|
|
}
|
|
|
|
if(angle <= grads[0])
|
|
return 0;
|
|
|
|
if(angle >= grads[count - 1])
|
|
return count - 1;
|
|
|
|
INT i = 1;
|
|
|
|
while(angle >= grads[i] && i < count)
|
|
{
|
|
i++;
|
|
}
|
|
|
|
return i - 1;
|
|
}
|
|
|
|
GpStatus
|
|
GpPathWidener::AddCompoundCaps(
|
|
DynPointFArray* widenedPoints,
|
|
DynByteArray* widenedTypes,
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
INT startIndex,
|
|
INT endIndex,
|
|
GpLineCap startCap,
|
|
GpLineCap endCap
|
|
)
|
|
{
|
|
const GpPointF* centerPoints = CenterPoints.GetDataBuffer();
|
|
const BYTE* centerTypes = CenterTypes.GetDataBuffer();
|
|
INT centerCount = CenterPoints.GetCount();
|
|
const GpPointF* grad0 = Gradients.GetDataBuffer();
|
|
const GpPointF* norm0 = Normals.GetDataBuffer();
|
|
|
|
GpPointF startPoint, endPoint;
|
|
GpPointF startGrad, endGrad;
|
|
GpPointF startNorm, endNorm;
|
|
|
|
startPoint = *(centerPoints + startIndex);
|
|
endPoint = *(centerPoints + endIndex);
|
|
startGrad = grad0[1];
|
|
endGrad = grad0[endIndex - startIndex];
|
|
startNorm = norm0[1];
|
|
endNorm = norm0[endIndex - startIndex];
|
|
|
|
GpStatus status;
|
|
status = SetCaps(
|
|
startCap,
|
|
endCap,
|
|
startPoint,
|
|
startGrad,
|
|
startNorm,
|
|
endPoint,
|
|
endGrad,
|
|
endNorm,
|
|
leftWidth,
|
|
rightWidth,
|
|
centerPoints + startIndex,
|
|
endIndex - startIndex + 1
|
|
);
|
|
|
|
status = CombineClosedCaps(
|
|
widenedPoints,
|
|
widenedTypes,
|
|
&CapPoints1,
|
|
&CapPoints2,
|
|
&CapTypes1,
|
|
&CapTypes2
|
|
);
|
|
|
|
return status;
|
|
}
|
|
|
|
GpStatus
|
|
GpPathWidener::SetCaps(
|
|
GpLineCap startCap,
|
|
GpLineCap endCap,
|
|
const GpPointF& startPoint,
|
|
const GpPointF& startGrad,
|
|
const GpPointF& startNorm,
|
|
const GpPointF& endPoint,
|
|
const GpPointF& endGrad,
|
|
const GpPointF& endNorm,
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
const GpPointF *points,
|
|
INT pointCount
|
|
)
|
|
{
|
|
GpStatus status = Ok;
|
|
|
|
CapPoints1.Reset(FALSE);
|
|
CapTypes1.Reset(FALSE);
|
|
CapPoints2.Reset(FALSE);
|
|
CapTypes2.Reset(FALSE);
|
|
|
|
switch(startCap)
|
|
{
|
|
case LineCapRound:
|
|
if(InsetPenMode)
|
|
{
|
|
status = SetDoubleRoundCap(
|
|
startPoint,
|
|
startGrad,
|
|
TRUE,
|
|
leftWidth,
|
|
rightWidth
|
|
);
|
|
}
|
|
else
|
|
{
|
|
status = SetRoundCap(
|
|
startPoint,
|
|
startGrad,
|
|
TRUE,
|
|
leftWidth,
|
|
rightWidth
|
|
);
|
|
}
|
|
break;
|
|
|
|
case LineCapTriangle:
|
|
ASSERT(!InsetPenMode);
|
|
status = SetTriangleCap(startPoint, startGrad, TRUE, leftWidth, rightWidth, points, pointCount);
|
|
break;
|
|
|
|
default:
|
|
// Flat cap.
|
|
|
|
break;
|
|
}
|
|
|
|
switch(endCap)
|
|
{
|
|
case LineCapRound:
|
|
if(InsetPenMode)
|
|
{
|
|
status = SetDoubleRoundCap(
|
|
endPoint,
|
|
endGrad,
|
|
FALSE,
|
|
leftWidth,
|
|
rightWidth
|
|
);
|
|
}
|
|
else
|
|
{
|
|
status = SetRoundCap(
|
|
endPoint,
|
|
endGrad,
|
|
FALSE,
|
|
leftWidth,
|
|
rightWidth
|
|
);
|
|
}
|
|
break;
|
|
|
|
case LineCapTriangle:
|
|
ASSERT(!InsetPenMode);
|
|
status = SetTriangleCap(endPoint, endGrad, FALSE, leftWidth, rightWidth, points, pointCount);
|
|
break;
|
|
|
|
default:
|
|
// Flat cap.
|
|
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
VOID modifyEdges(
|
|
GpPointF* leftPoints,
|
|
BYTE* leftTypes,
|
|
INT* leftCount,
|
|
INT* leftOffset,
|
|
GpPointF* rightPoints,
|
|
BYTE* rightTypes,
|
|
INT* rightCount,
|
|
INT* rightOffset,
|
|
GpPointF* grad,
|
|
INT gradCount
|
|
)
|
|
{
|
|
INT leftOffset1 = 0;
|
|
INT rightOffset1 = 0;
|
|
INT leftCount0 = *leftCount;
|
|
INT rightCount0 = *rightCount;
|
|
INT leftCount1 = leftCount0;
|
|
INT rightCount1 = rightCount0;
|
|
|
|
if(gradCount > 2)
|
|
{
|
|
GpPointF firstGrad = grad[1];
|
|
GpPointF lastGrad = grad[gradCount - 2];
|
|
|
|
GpPointF dP;
|
|
if(leftCount0 > 2)
|
|
{
|
|
dP.X = leftPoints[1].X - leftPoints[0].X;
|
|
dP.Y = leftPoints[1].Y - leftPoints[0].Y;
|
|
if(dP.X*firstGrad.X + dP.Y*firstGrad.Y < 0)
|
|
{
|
|
leftPoints[0] = leftPoints[1];
|
|
}
|
|
dP.X = leftPoints[leftCount0 - 1].X
|
|
- leftPoints[leftCount0 - 2].X;
|
|
dP.Y = leftPoints[leftCount0 - 1].Y
|
|
- leftPoints[leftCount0 - 2].Y;
|
|
if(dP.X*lastGrad.X + dP.Y*lastGrad.Y < 0)
|
|
{
|
|
leftPoints[leftCount0 - 1]
|
|
= leftPoints[leftCount0 - 2];
|
|
}
|
|
}
|
|
|
|
if(rightCount0 > 2)
|
|
{
|
|
dP.X = rightPoints[1].X - rightPoints[0].X;
|
|
dP.Y = rightPoints[1].Y - rightPoints[0].Y;
|
|
if(dP.X*firstGrad.X + dP.Y*firstGrad.Y < 0)
|
|
{
|
|
rightPoints[0] = rightPoints[1];
|
|
}
|
|
dP.X = rightPoints[rightCount0 - 1].X
|
|
- rightPoints[rightCount0 - 2].X;
|
|
dP.Y = rightPoints[rightCount0 - 1].Y
|
|
- rightPoints[rightCount0 - 2].Y;
|
|
if(dP.X*lastGrad.X + dP.Y*lastGrad.Y < 0)
|
|
{
|
|
rightPoints[rightCount0 - 1]
|
|
= rightPoints[rightCount0 - 2];
|
|
}
|
|
}
|
|
}
|
|
|
|
*leftCount = leftCount1;
|
|
*leftOffset = leftOffset1;
|
|
*rightCount = rightCount1;
|
|
*rightOffset = rightOffset1;
|
|
}
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Combines left path, right path, start cap, and end cap.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [OUT] windedPoints - Output point data.
|
|
* [OUT] widnedTypes - Output type data.
|
|
* [IN] isClosed - TRUE is the current suppat is closed.
|
|
* [IN] closeStartCap - TRUE if the start cap needs to be closed.
|
|
* [IN] closeEndCap - TRUE if the end cap needs to be closed.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Status
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
GpPathWidener::CombineSubpathOutlines(
|
|
DynPointFArray* widenedPoints,
|
|
DynByteArray* widenedTypes,
|
|
BOOL isClosed,
|
|
BOOL closeStartCap,
|
|
BOOL closeEndCap
|
|
)
|
|
{
|
|
GpStatus status = Ok;
|
|
|
|
INT startCapCount = CapPoints1.GetCount();
|
|
GpPointF* startCapPoints = CapPoints1.GetDataBuffer();
|
|
BYTE* startCapTypes = CapTypes1.GetDataBuffer();
|
|
INT endCapCount = CapPoints2.GetCount();
|
|
GpPointF* endCapPoints = CapPoints2.GetDataBuffer();
|
|
BYTE* endCapTypes = CapTypes2.GetDataBuffer();
|
|
|
|
BYTE* leftTypes;
|
|
GpPointF* leftPoints;
|
|
BYTE* rightTypes;
|
|
GpPointF* rightPoints;
|
|
INT leftCount, rightCount;
|
|
|
|
leftCount = LeftPoints.GetCount();
|
|
leftTypes = LeftTypes.GetDataBuffer();
|
|
leftPoints = LeftPoints.GetDataBuffer();
|
|
rightCount = RightPoints.GetCount();
|
|
rightTypes = RightTypes.GetDataBuffer();
|
|
rightPoints = RightPoints.GetDataBuffer();
|
|
|
|
if(!isClosed)
|
|
{
|
|
GpPointF *grad = Gradients.GetDataBuffer();
|
|
INT gradCount = Gradients.GetCount();
|
|
INT leftOffset, rightOffset;
|
|
|
|
modifyEdges(leftPoints, leftTypes, &leftCount, &leftOffset,
|
|
rightPoints, rightTypes, &rightCount, &rightOffset,
|
|
grad, gradCount);
|
|
|
|
leftPoints += leftOffset;
|
|
leftTypes += leftOffset;
|
|
rightPoints += rightOffset;
|
|
rightTypes += rightOffset;
|
|
}
|
|
|
|
status = widenedPoints->ReserveSpace(
|
|
leftCount + rightCount + startCapCount + endCapCount + 2);
|
|
if(status == Ok)
|
|
status = widenedTypes->ReserveSpace(
|
|
leftCount + rightCount + startCapCount + endCapCount + 2);
|
|
|
|
GpPointF* wPts = NULL;
|
|
BYTE* wTypes = NULL;
|
|
|
|
if(status == Ok)
|
|
{
|
|
wPts = widenedPoints->GetDataBuffer();
|
|
wTypes = widenedTypes->GetDataBuffer();
|
|
}
|
|
|
|
if(wPts && wTypes)
|
|
{
|
|
// Set the pointers to the current location.
|
|
|
|
INT count0 = widenedPoints->GetCount();
|
|
wPts += count0;
|
|
wTypes += count0;
|
|
|
|
INT resultCount;
|
|
BOOL isStartCapClosed = FALSE;
|
|
BOOL isEndCapClosed = FALSE;
|
|
|
|
if(isClosed)
|
|
{
|
|
leftTypes[leftCount - 1] |= PathPointTypeCloseSubpath;
|
|
rightTypes[rightCount - 1] |= PathPointTypeCloseSubpath;
|
|
}
|
|
else
|
|
{
|
|
if(startCapCount > 0)
|
|
{
|
|
if(!closeStartCap)
|
|
{
|
|
if(startCapTypes[startCapCount - 1] & PathPointTypeCloseSubpath)
|
|
isStartCapClosed = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Force the start cap to be closed.
|
|
|
|
startCapTypes[startCapCount - 1] |= PathPointTypeCloseSubpath;
|
|
isStartCapClosed = TRUE;
|
|
}
|
|
}
|
|
|
|
if(endCapCount > 0)
|
|
{
|
|
if(!closeEndCap)
|
|
{
|
|
if(endCapTypes[endCapCount - 1] & PathPointTypeCloseSubpath)
|
|
isEndCapClosed = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Force the end cap to be closed.
|
|
|
|
endCapTypes[endCapCount - 1] |= PathPointTypeCloseSubpath;
|
|
isEndCapClosed = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(isClosed || (startCapCount == 0 && endCapCount == 0))
|
|
{
|
|
BOOL connect = TRUE;
|
|
resultCount =
|
|
::CombinePaths(leftCount + rightCount, wPts, wTypes,
|
|
leftCount, leftPoints, leftTypes, TRUE,
|
|
rightCount, rightPoints, rightTypes, FALSE,
|
|
connect);
|
|
}
|
|
else
|
|
{
|
|
resultCount = leftCount;
|
|
|
|
if(leftCount > 0)
|
|
{
|
|
GpMemcpy(wPts, leftPoints, leftCount*sizeof(GpPointF));
|
|
GpMemcpy(wTypes, leftTypes, leftCount);
|
|
}
|
|
|
|
if(endCapCount > 0 && !isEndCapClosed)
|
|
{
|
|
resultCount =
|
|
combineTwoOpenSegments(
|
|
resultCount, wPts, wTypes, TRUE,
|
|
endCapCount, endCapPoints, endCapTypes, TRUE);
|
|
}
|
|
|
|
if(rightCount > 0)
|
|
{
|
|
resultCount =
|
|
combineTwoOpenSegments(
|
|
resultCount, wPts, wTypes, TRUE,
|
|
rightCount, rightPoints, rightTypes, FALSE);
|
|
}
|
|
|
|
if(startCapCount > 0 && !isStartCapClosed)
|
|
{
|
|
resultCount =
|
|
combineTwoOpenSegments(
|
|
resultCount, wPts, wTypes, TRUE,
|
|
startCapCount, startCapPoints, startCapTypes, TRUE);
|
|
}
|
|
|
|
wTypes[0] = PathPointTypeStart;
|
|
}
|
|
|
|
if(resultCount > 0)
|
|
{
|
|
// If the original subpath is open, the combined path needs to be
|
|
// closed. If the original path is closed, the left and
|
|
// right paths are already closed.
|
|
|
|
if(!isClosed)
|
|
{
|
|
wTypes[resultCount - 1] |= PathPointTypeCloseSubpath;
|
|
|
|
// Add the closed caps.
|
|
|
|
if(endCapCount > 0 && isEndCapClosed)
|
|
{
|
|
resultCount =
|
|
combineClosedSegments(
|
|
resultCount, wPts, wTypes, TRUE,
|
|
endCapCount, endCapPoints, endCapTypes, TRUE);
|
|
}
|
|
|
|
if(startCapCount > 0 && isStartCapClosed)
|
|
{
|
|
resultCount =
|
|
combineClosedSegments(
|
|
resultCount, wPts, wTypes, TRUE,
|
|
startCapCount, startCapPoints, startCapTypes, TRUE);
|
|
}
|
|
}
|
|
|
|
widenedPoints->AdjustCount(resultCount);
|
|
widenedTypes->AdjustCount(resultCount);
|
|
}
|
|
else
|
|
status = GenericError;
|
|
}
|
|
else
|
|
status = OutOfMemory;
|
|
|
|
return status;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Combines the closed cap paths.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [OUT] windedPoints - Output point data.
|
|
* [OUT] widnedTypes - Output type data.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Status
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
GpPathWidener::CombineClosedCaps(
|
|
DynPointFArray* widenedPoints,
|
|
DynByteArray* widenedTypes,
|
|
DynPointFArray *daStartCapPoints,
|
|
DynPointFArray *daEndCapPoints,
|
|
DynByteArray *daStartCapTypes,
|
|
DynByteArray *daEndCapTypes
|
|
)
|
|
{
|
|
GpStatus status = Ok;
|
|
|
|
INT startCapCount = daStartCapPoints->GetCount();
|
|
GpPointF* startCapPoints = daStartCapPoints->GetDataBuffer();
|
|
BYTE* startCapTypes = daStartCapTypes->GetDataBuffer();
|
|
INT endCapCount = daEndCapPoints->GetCount();
|
|
GpPointF* endCapPoints = daEndCapPoints->GetDataBuffer();
|
|
BYTE* endCapTypes = daEndCapTypes->GetDataBuffer();
|
|
|
|
if(startCapCount == 0 && endCapCount == 0)
|
|
{
|
|
return status;
|
|
}
|
|
|
|
status = widenedPoints->ReserveSpace(startCapCount + endCapCount);
|
|
if(status == Ok)
|
|
status = widenedTypes->ReserveSpace(startCapCount + endCapCount);
|
|
|
|
GpPointF* wPts = NULL;
|
|
BYTE* wTypes = NULL;
|
|
|
|
if(status == Ok)
|
|
{
|
|
wPts = widenedPoints->GetDataBuffer();
|
|
wTypes = widenedTypes->GetDataBuffer();
|
|
}
|
|
else
|
|
status = OutOfMemory;
|
|
|
|
if(status == Ok && wPts && wTypes)
|
|
{
|
|
INT count0 = widenedPoints->GetCount();
|
|
|
|
// Make sure the previous path is closed.
|
|
|
|
if(count0 > 0)
|
|
wTypes[count0 - 1] |= PathPointTypeCloseSubpath;
|
|
|
|
// Set the pointers to the current location.
|
|
|
|
wPts += count0;
|
|
wTypes += count0;
|
|
|
|
INT resultCount = 0;
|
|
|
|
if(startCapCount > 0)
|
|
{
|
|
// Force the start cap to be closed.
|
|
|
|
startCapTypes[startCapCount - 1] |= PathPointTypeCloseSubpath;
|
|
resultCount =
|
|
combineClosedSegments(
|
|
resultCount, wPts, wTypes, TRUE,
|
|
startCapCount, startCapPoints, startCapTypes, TRUE);
|
|
}
|
|
|
|
if(endCapCount > 0)
|
|
{
|
|
// Force the end cap to be closed.
|
|
|
|
endCapTypes[endCapCount - 1] |= PathPointTypeCloseSubpath;
|
|
resultCount =
|
|
combineClosedSegments(
|
|
resultCount, wPts, wTypes, TRUE,
|
|
endCapCount, endCapPoints, endCapTypes, TRUE);
|
|
}
|
|
|
|
widenedPoints->AdjustCount(resultCount);
|
|
widenedTypes->AdjustCount(resultCount);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
GpTurningDirection
|
|
getTurningDirection(
|
|
REAL* crossProduct,
|
|
const GpPointF& grad1,
|
|
const GpPointF& grad2
|
|
)
|
|
{
|
|
ASSERT(crossProduct);
|
|
|
|
GpTurningDirection direction = NotTurning;
|
|
*crossProduct = 0;
|
|
|
|
// Handle the degenerate cases.
|
|
|
|
GpPointF v;
|
|
|
|
if(( (REALABS(grad1.X) < REAL_EPSILON) &&
|
|
(REALABS(grad1.Y) < REAL_EPSILON) ) ||
|
|
( (REALABS(grad2.X) < REAL_EPSILON) &&
|
|
(REALABS(grad2.Y) < REAL_EPSILON) )
|
|
)
|
|
{
|
|
return NotTurning;
|
|
}
|
|
|
|
// Handle the case of straight or nearly straight lines.
|
|
// The following constant is completely bogus - we need a number here
|
|
// and we're fairly certain it must be small. Probably a better estimate
|
|
// would be some fraction of a device pixel over the length of the line -
|
|
// if we can figure out how big that is.
|
|
|
|
const REAL gradErr = 0.00001f;
|
|
|
|
if(distance_squared(grad1, grad2) < gradErr)
|
|
{
|
|
direction = NotTurning;
|
|
|
|
return direction;
|
|
}
|
|
|
|
// Calculate the cross product.
|
|
|
|
REAL cross = grad1.X*grad2.Y - grad1.Y*grad2.X;
|
|
|
|
// When it comes here, the lines are turning.
|
|
// Get the turning direction.
|
|
|
|
if (REALABS(cross) <= REAL_EPSILON)
|
|
{
|
|
direction = TurningBack;
|
|
cross = 0;
|
|
}
|
|
else
|
|
{
|
|
if(cross > 0)
|
|
{
|
|
direction = TurningRight;
|
|
}
|
|
else // if(cross < 0)
|
|
{
|
|
direction = TurningLeft;
|
|
}
|
|
}
|
|
|
|
*crossProduct = cross;
|
|
|
|
return direction;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Calculates if the miter join will exceed the miter limit.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] grad1 - the unit tangent vector of the last edge.
|
|
* [IN] grad2 - the unit tangent vector of the current edge.
|
|
* [IN] miterLimit2 - the square of the Miter limit.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* TRUE if the miter limit of this join is exceeded
|
|
*
|
|
\**************************************************************************/
|
|
|
|
BOOL
|
|
getMiterExceeded(
|
|
const GpPointF& grad1,
|
|
const GpPointF& grad2,
|
|
REAL miterLimit2
|
|
)
|
|
{
|
|
REAL cross = grad1.X*grad2.Y - grad1.Y*grad2.X;
|
|
|
|
// If cross product is zero, the lines are colinear and can be
|
|
// turning back on themselves.
|
|
if (REALABS(cross) <= REAL_EPSILON)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
// Get the normal direction for the miter join.
|
|
GpPointF v(0, 0);
|
|
v.X = grad1.X - grad2.X;
|
|
v.Y = grad1.Y - grad2.Y;
|
|
|
|
// Test the miter limit.
|
|
REAL test = v.X*v.X + v.Y*v.Y - cross*cross*miterLimit2;
|
|
|
|
return test > 0;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Calculates the vector for Miter or Bevel join. This vector represents
|
|
* the shift to the left along the moving direction.
|
|
* In case of Miter join, when the Miter join exceeds the miter limit,
|
|
* this returns the Bevel join.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [OUT] vector - the left shift for the Miter join. This must be
|
|
* allocated at least for the dimension of 2.
|
|
* [OUT] count - the number of join points.
|
|
* [IN] miterLimit2 - the square of the Miter limit.
|
|
* [IN] grad1 - the unit tangent vector of the last edge.
|
|
* [IN] grad2 - the unit tangent vector of the current edge.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Turning direction from the last edge to the current edge.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpTurningDirection
|
|
getMiterBevelJoin(
|
|
const GpPointF& point,
|
|
const GpPointF& grad1,
|
|
const GpPointF& grad2,
|
|
const GpPointF& norm1,
|
|
const GpPointF& norm2,
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
INT *leftCount,
|
|
GpPointF *leftPoints,
|
|
BOOL* leftInside,
|
|
INT *rightCount,
|
|
GpPointF *rightPoints,
|
|
BOOL* rightInside,
|
|
BOOL needsToAdjustNormals,
|
|
REAL miterLimit2,
|
|
BOOL isMiter,
|
|
BOOL useBevelJoinInside
|
|
)
|
|
{
|
|
*leftInside = FALSE;
|
|
*rightInside = FALSE;
|
|
|
|
if(miterLimit2 <= 1)
|
|
isMiter = FALSE;
|
|
|
|
GpTurningDirection direction = NotTurning;
|
|
|
|
// Handle the degenerate cases.
|
|
|
|
GpPointF v(0, 0);
|
|
REAL cross;
|
|
|
|
direction = getTurningDirection(&cross, grad1, grad2);
|
|
|
|
if(direction == NotMoving)
|
|
{
|
|
*leftCount = 0;
|
|
*rightCount = 0;
|
|
return direction;
|
|
}
|
|
else if(direction == NotTurning)
|
|
{
|
|
if(norm1.X != 0 || norm1.Y != 0)
|
|
v = norm1;
|
|
else
|
|
v = norm2;
|
|
|
|
leftPoints[0].X = point.X + leftWidth*v.X;
|
|
leftPoints[0].Y = point.Y + leftWidth*v.Y;
|
|
*leftCount = 1;
|
|
|
|
rightPoints[0].X = point.X + rightWidth*v.X;
|
|
rightPoints[0].Y = point.Y + rightWidth*v.Y;
|
|
*rightCount = 1;
|
|
|
|
return direction;
|
|
}
|
|
|
|
if(cross > 0)
|
|
{
|
|
// Right Turn
|
|
|
|
// If the width is positive, this point is outside.
|
|
// For the zero width, we regard this as non-inside point.
|
|
|
|
if(leftWidth >= 0)
|
|
*leftInside = FALSE;
|
|
else
|
|
*leftInside = TRUE;
|
|
|
|
if(rightWidth >= 0)
|
|
*rightInside = FALSE;
|
|
else
|
|
*rightInside = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Left Turn
|
|
|
|
// If the width is negative, this point is outside.
|
|
// For the zero width, we regard this as non-inside point.
|
|
|
|
if(leftWidth <= 0)
|
|
*leftInside = FALSE;
|
|
else
|
|
*leftInside = TRUE;
|
|
|
|
if(rightWidth <= 0)
|
|
*rightInside = FALSE;
|
|
else
|
|
*rightInside = TRUE;
|
|
}
|
|
|
|
BOOL isLeftMiterJoin = FALSE, isRightMiterJoin = FALSE;
|
|
REAL leftShift1 = 0, rightShift1 = 0;
|
|
REAL leftShift2 = 0, rightShift2 = 0;
|
|
|
|
if(isMiter && cross != 0)
|
|
{
|
|
REAL test = 0;
|
|
|
|
// Get the normal direction for the miter join.
|
|
|
|
v.X = grad1.X - grad2.X;
|
|
v.Y = grad1.Y - grad2.Y;
|
|
|
|
// Test the miter limit.
|
|
|
|
test = v.X*v.X + v.Y*v.Y - cross*cross*miterLimit2;
|
|
|
|
if(test <= 0 )
|
|
{
|
|
// Use the miter join.
|
|
|
|
if(needsToAdjustNormals)
|
|
{
|
|
// Use adjusted normals so that aliased thin lines
|
|
// won't disappear.
|
|
|
|
REAL c1, c2;
|
|
|
|
c1 = norm2.X*grad2.Y - norm2.Y*grad2.X;
|
|
c2 = norm1.X*grad1.Y - norm1.Y*grad1.X;
|
|
v.X = c1*grad1.X - c2*grad2.X;
|
|
v.Y = c1*grad1.Y - c2*grad2.Y;
|
|
}
|
|
|
|
v.X /= cross;
|
|
v.Y /= cross;
|
|
|
|
GpPointF *outPoints, *inPoints;
|
|
REAL outWidth, inWidth;
|
|
INT *outCount, *inCount;
|
|
|
|
if(cross > 0)
|
|
{
|
|
// When a miter join is used, set the inside flag to
|
|
// FALSE since there is no overlap.
|
|
|
|
isLeftMiterJoin = TRUE;
|
|
*leftInside = FALSE;
|
|
|
|
if(useBevelJoinInside)
|
|
{
|
|
if(*rightInside)
|
|
isRightMiterJoin = FALSE;
|
|
else
|
|
{
|
|
// When the right edges are outside,
|
|
// we cannot use Bevel join since
|
|
// Bevel join shape will actually appear.
|
|
|
|
isRightMiterJoin = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// When a miter join is used, set the inside flag to
|
|
// FALSE since there is no overlap.
|
|
|
|
isRightMiterJoin = TRUE;
|
|
*rightInside = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// When a miter join is used, set the inside flag to
|
|
// FALSE since there is no overlap.
|
|
|
|
isRightMiterJoin = TRUE;
|
|
*rightInside = FALSE;
|
|
|
|
if(useBevelJoinInside)
|
|
{
|
|
if(*leftInside)
|
|
isLeftMiterJoin = FALSE;
|
|
else
|
|
{
|
|
// When the right edges are outside,
|
|
// we cannot use Bevel join since
|
|
// Bevel join shape will actually appear.
|
|
|
|
isLeftMiterJoin = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// When a miter join is used, set the inside flag to
|
|
// FALSE since there is no overlap.
|
|
|
|
isLeftMiterJoin = TRUE;
|
|
*leftInside = FALSE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The turn is too sharp and it exceeds the miter limit.
|
|
// We must chop off the miter join tips.
|
|
|
|
REAL n1n1 = 1, n2n2 = 1, g1n1 = 0, g2n2 = 0;
|
|
|
|
if(needsToAdjustNormals)
|
|
{
|
|
n1n1 = norm1.X*norm1.X + norm1.Y*norm1.Y;
|
|
n2n2 = norm2.X*norm2.X + norm2.Y*norm2.Y;
|
|
g1n1 = grad1.X*norm1.X + grad1.Y*norm1.Y;
|
|
g2n2 = grad2.X*norm2.X + grad2.Y*norm2.Y;
|
|
}
|
|
|
|
if(miterLimit2 > max(n1n1, n2n2))
|
|
{
|
|
if(*leftInside == FALSE)
|
|
{
|
|
REAL lWidth;
|
|
|
|
if(cross > 0)
|
|
lWidth = leftWidth; // Right Turn
|
|
else
|
|
lWidth = - leftWidth; // Left Turn
|
|
|
|
leftShift1 = (REALSQRT(miterLimit2 - n1n1 + g1n1*g1n1)
|
|
- g1n1)*lWidth;
|
|
leftShift2 = (REALSQRT(miterLimit2 - n2n2 + g2n2*g2n2)
|
|
+ g2n2)*lWidth;
|
|
}
|
|
|
|
if(*rightInside == FALSE)
|
|
{
|
|
REAL rWidth;
|
|
|
|
if(cross > 0)
|
|
rWidth = rightWidth; // Right Turn
|
|
else
|
|
rWidth = - rightWidth; // Left Turn
|
|
|
|
rightShift1 = (REALSQRT(miterLimit2 - n1n1 + g1n1*g1n1)
|
|
- g1n1)*rWidth;
|
|
rightShift2 = (REALSQRT(miterLimit2 - n2n2 + g2n2*g2n2)
|
|
+ g2n2)*rWidth;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(isLeftMiterJoin)
|
|
{
|
|
leftPoints[0].X = point.X + leftWidth*v.X;
|
|
leftPoints[0].Y = point.Y + leftWidth*v.Y;
|
|
*leftCount = 1;
|
|
}
|
|
else
|
|
{
|
|
leftPoints[0].X = point.X + leftWidth*norm1.X + leftShift1*grad1.X;
|
|
leftPoints[0].Y = point.Y + leftWidth*norm1.Y + leftShift1*grad1.Y;
|
|
leftPoints[1].X = point.X + leftWidth*norm2.X - leftShift2*grad2.X;
|
|
leftPoints[1].Y = point.Y + leftWidth*norm2.Y - leftShift2*grad2.Y;
|
|
|
|
// Check if two points are degenerate.
|
|
|
|
if(REALABS(leftPoints[1].X - leftPoints[0].X) +
|
|
REALABS(leftPoints[1].Y - leftPoints[0].Y)
|
|
> POINTF_EPSILON)
|
|
{
|
|
*leftCount = 2;
|
|
}
|
|
else
|
|
{
|
|
// Since there is no overlap, set the inside flag to FALSE.
|
|
|
|
*leftCount = 1;
|
|
*leftInside = FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
if(isRightMiterJoin)
|
|
{
|
|
rightPoints[0].X = point.X + rightWidth*v.X;
|
|
rightPoints[0].Y = point.Y + rightWidth*v.Y;
|
|
*rightCount = 1;
|
|
}
|
|
else
|
|
{
|
|
rightPoints[0].X = point.X + rightWidth*norm1.X + rightShift1*grad1.X;
|
|
rightPoints[0].Y = point.Y + rightWidth*norm1.Y + rightShift1*grad1.Y;
|
|
rightPoints[1].X = point.X + rightWidth*norm2.X - rightShift2*grad2.X;
|
|
rightPoints[1].Y = point.Y + rightWidth*norm2.Y - rightShift2*grad2.Y;
|
|
|
|
// Check if two points are degenerate.
|
|
|
|
if(REALABS(rightPoints[1].X - rightPoints[0].X) +
|
|
REALABS(rightPoints[1].Y - rightPoints[0].Y)
|
|
> POINTF_EPSILON)
|
|
{
|
|
*rightCount = 2;
|
|
}
|
|
else
|
|
{
|
|
// Since there is no overlap, set the inside flag to FALSE.
|
|
|
|
*rightCount = 1;
|
|
*rightInside = FALSE;
|
|
}
|
|
}
|
|
|
|
return direction;
|
|
}
|
|
|
|
enum GpRoundJoinFlag
|
|
{
|
|
NeedsNone = 0,
|
|
NeedsOnlyRoundJoin = 1,
|
|
NeedsOnlyNonRoundJoin = 2,
|
|
NeedsBoth = 3
|
|
};
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* From the given point and the two tangent vectors of the two edges,
|
|
* and the radius of the round join, this returns the verteces for
|
|
* left edges and right edges of the round join for the current point.
|
|
* This is used when the bending angle is less than 90 degrees
|
|
* and is called by GetRoundJoin.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] point - The current points in the original path.
|
|
* [IN] grad1 - The tangent of the current edge.
|
|
* [IN] grad2 - The tangent of the next edge.
|
|
* [IN] dot - The dot product of grad1 and grad2.
|
|
* [IN] leftWidth - The left width of the round join.
|
|
* [IN] rightWidth - The right width of the round join.
|
|
* [OUT] leftCount - The count of the left points.
|
|
* [OUT] leftPoints - The left points.
|
|
* [OUT] rightCount - The count of the right points.
|
|
* [OUT] rightPoints - The right points.
|
|
*
|
|
* Both leftPoints and rightPoints must have at least dimension of 4.
|
|
* If leftCount is positive (negative), this means the left edges are
|
|
* lines with leftCount points (cubic Bezier curves with -leftCount
|
|
* control points).
|
|
* If rightCount is positive (negative), this means the right edges are
|
|
* lines with rightCount points (cubic Bezier curves with -rightCount
|
|
* control points).
|
|
*
|
|
* Return Value:
|
|
*
|
|
* None
|
|
*
|
|
* 06/16/99 ikkof
|
|
* Created it
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID
|
|
getSmallRoundJoin(
|
|
const GpPointF& point,
|
|
const GpPointF& grad1,
|
|
const GpPointF& grad2,
|
|
const GpPointF& norm1,
|
|
const GpPointF& norm2,
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
INT *leftCount,
|
|
GpPointF *leftPoints,
|
|
INT *rightCount,
|
|
GpPointF *rightPoints,
|
|
REAL dot,
|
|
REAL cross,
|
|
BOOL needsToAdjustNormals,
|
|
REAL miterLimit2,
|
|
INT condition,
|
|
BOOL useBevelJoinInside
|
|
)
|
|
{
|
|
if((condition & NeedsBoth) == 0)
|
|
{
|
|
*leftCount = 0;
|
|
*rightCount = 0;
|
|
|
|
return;
|
|
}
|
|
|
|
GpPointF n1, n2;
|
|
n1 = norm1;
|
|
n2 = norm2;
|
|
|
|
REAL k;
|
|
REAL almostStraight = 1.0f - 0.01f;
|
|
|
|
if(dot < almostStraight)
|
|
{
|
|
// Obtain the distance from the first control point
|
|
// or from the last control point.
|
|
// For its derivation, see ikkof's notes for "Round Joins".
|
|
|
|
REAL cross1 = cross;
|
|
if(cross < 0)
|
|
cross1 = - cross;
|
|
k = 4*(REALSQRT(2*(1 - dot)) - cross1)/(3*(1 - dot));
|
|
|
|
GpPointF *outPoints, *inPoints;
|
|
INT *outCount, *inCount;
|
|
|
|
REAL outWidth, inWidth;
|
|
|
|
if(cross >= 0)
|
|
{
|
|
// The left edges are round join.
|
|
|
|
outPoints = leftPoints;
|
|
inPoints = rightPoints;
|
|
outCount = leftCount;
|
|
inCount = rightCount;
|
|
outWidth = leftWidth;
|
|
inWidth = rightWidth;
|
|
}
|
|
else
|
|
{
|
|
// The right edges are round join.
|
|
|
|
outPoints = rightPoints;
|
|
inPoints = leftPoints;
|
|
outCount = rightCount;
|
|
inCount = leftCount;
|
|
outWidth = - rightWidth;
|
|
inWidth = - leftWidth;
|
|
n1.X = - n1.X;
|
|
n1.Y = - n1.Y;
|
|
n2.X = - n2.X;
|
|
n2.Y = - n2.Y;
|
|
}
|
|
|
|
|
|
// Get the normal direction for the miter join.
|
|
|
|
GpPointF v;
|
|
REAL test;
|
|
|
|
v.X = grad1.X - grad2.X;
|
|
v.Y = grad1.Y - grad2.Y;
|
|
|
|
// Test the miter limit.
|
|
|
|
BOOL useMiterJoin = FALSE;;
|
|
|
|
// Reduce the miter limit
|
|
|
|
miterLimit2 = 3*3;
|
|
|
|
// Note that abs(cross) == abs(cross1) from the definition.
|
|
|
|
if(REALABS(cross1) >= REAL_EPSILON)
|
|
{
|
|
REAL test = v.X*v.X + v.Y*v.Y - cross*cross*miterLimit2;
|
|
if(test <= 0)
|
|
{
|
|
useMiterJoin = TRUE;
|
|
v.X /= cross1;
|
|
v.Y /= cross1;
|
|
}
|
|
}
|
|
|
|
useMiterJoin = useMiterJoin && !useBevelJoinInside;
|
|
|
|
REAL k1;
|
|
if(outWidth > 0)
|
|
{
|
|
if(condition & NeedsOnlyRoundJoin)
|
|
{
|
|
k1 = outWidth*k;
|
|
outPoints[0].X = point.X + outWidth*n1.X;
|
|
outPoints[0].Y = point.Y + outWidth*n1.Y;
|
|
outPoints[1].X = outPoints[0].X + k1*grad1.X;
|
|
outPoints[1].Y = outPoints[0].Y + k1*grad1.Y;
|
|
outPoints[3].X = point.X + outWidth*n2.X;
|
|
outPoints[3].Y = point.Y + outWidth*n2.Y;
|
|
outPoints[2].X = outPoints[3].X - k1*grad2.X;
|
|
outPoints[2].Y = outPoints[3].Y - k1*grad2.Y;
|
|
*outCount = -4; // Indicate "-" for Bezier
|
|
}
|
|
else
|
|
*outCount = 0;
|
|
}
|
|
else
|
|
{
|
|
if(condition & NeedsOnlyNonRoundJoin)
|
|
{
|
|
if(outWidth == 0)
|
|
{
|
|
outPoints[0] = point;
|
|
*outCount = 1;
|
|
}
|
|
else
|
|
{
|
|
if(useMiterJoin)
|
|
{
|
|
outPoints[0].X = point.X + outWidth*v.X;
|
|
outPoints[0].Y = point.Y + outWidth*v.Y;
|
|
*outCount = 1;
|
|
}
|
|
else
|
|
{
|
|
outPoints[0].X = point.X + outWidth*n1.X;
|
|
outPoints[0].Y = point.Y + outWidth*n1.Y;
|
|
outPoints[1].X = point.X + outWidth*n2.X;
|
|
outPoints[1].Y = point.Y + outWidth*n2.Y;
|
|
*outCount = 2;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
*outCount = 0;
|
|
}
|
|
|
|
if(inWidth > 0)
|
|
{
|
|
if(condition & NeedsOnlyRoundJoin)
|
|
{
|
|
k1 = inWidth*k;
|
|
inPoints[0].X = point.X + inWidth*n1.X;
|
|
inPoints[0].Y = point.Y + inWidth*n1.Y;
|
|
inPoints[1].X = inPoints[0].X + k1*grad1.X;
|
|
inPoints[1].Y = inPoints[0].Y + k1*grad1.Y;
|
|
inPoints[3].X = point.X + inWidth*n2.X;
|
|
inPoints[3].Y = point.Y + inWidth*n2.Y;
|
|
inPoints[2].X = inPoints[3].X - k1*grad2.X;
|
|
inPoints[2].Y = inPoints[3].Y - k1*grad2.Y;
|
|
*inCount = -4; // Indicate "-" for Bezier
|
|
}
|
|
else
|
|
*inCount = 0;
|
|
}
|
|
else
|
|
{
|
|
if(condition & NeedsOnlyNonRoundJoin)
|
|
{
|
|
if(inWidth == 0)
|
|
{
|
|
inPoints[0] = point;
|
|
*inCount = 1;
|
|
}
|
|
else
|
|
{
|
|
if(useMiterJoin)
|
|
{
|
|
inPoints[0].X = point.X + inWidth*v.X;
|
|
inPoints[0].Y = point.Y + inWidth*v.Y;
|
|
*inCount = 1;
|
|
}
|
|
else
|
|
{
|
|
inPoints[0].X = point.X + inWidth*n1.X;
|
|
inPoints[0].Y = point.Y + inWidth*n1.Y;
|
|
inPoints[1].X = point.X + inWidth*n2.X;
|
|
inPoints[1].Y = point.Y + inWidth*n2.Y;
|
|
*inCount = 2;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
*inCount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(condition & NeedsOnlyNonRoundJoin)
|
|
{
|
|
// This is a straight line.
|
|
|
|
leftPoints[0].X = point.X + leftWidth*n1.X;
|
|
leftPoints[0].Y = point.Y + leftWidth*n1.Y;
|
|
*leftCount = 1;
|
|
|
|
rightPoints[0].X = point.X + rightWidth*n1.X;
|
|
rightPoints[0].Y = point.Y + rightWidth*n1.Y;
|
|
*rightCount = 1;
|
|
}
|
|
else
|
|
{
|
|
*leftCount = 0;
|
|
*rightCount = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* From the given previous, current, and next points and the radius
|
|
* of the round join, this returns the verteces for left edges and
|
|
* right edges of the round join for the current point.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] points - The previous, current, and next points
|
|
* in the original path.
|
|
* [IN] leftWidth - The left width of the round join.
|
|
* [IN] rightWidth - The right width of the round join.
|
|
* [OUT] leftCount - The count of the left points.
|
|
* [OUT] leftPoints - The left points.
|
|
* [OUT] rightCount - The count of the right points.
|
|
* [OUT] rightPoints - The right points.
|
|
*
|
|
* Both leftPoints and rightPoints must have at least dimension of 7.
|
|
* If leftCount is positive (negative), this means the left edges are
|
|
* lines with leftCount points (cubic Bezier curves with -leftCount
|
|
* control points).
|
|
* If rightCount is positive (negative), this means the right edges are
|
|
* lines with rightCount points (cubic Bezier curves with -rightCount
|
|
* control points).
|
|
*
|
|
* Return Value:
|
|
*
|
|
* FALSE if the current point coindes with the previous point or
|
|
* the next point. Otherwise, this returns TRUE.
|
|
*
|
|
* 06/16/99 ikkof
|
|
* Created it
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpTurningDirection
|
|
getRoundJoin(
|
|
const GpPointF& point,
|
|
const GpPointF& grad1,
|
|
const GpPointF& grad2,
|
|
const GpPointF& norm1,
|
|
const GpPointF& norm2,
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
INT* leftCount,
|
|
GpPointF* leftPoints,
|
|
BOOL* leftInside,
|
|
INT* rightCount,
|
|
GpPointF* rightPoints,
|
|
BOOL* rightInside,
|
|
BOOL needsToAdjustNormals,
|
|
REAL miterLimit2,
|
|
BOOL useBevelJoinInside
|
|
)
|
|
{
|
|
//!!! We need to update inside flags for Round joins later.
|
|
|
|
*leftInside = FALSE;
|
|
*rightInside = FALSE;
|
|
|
|
ASSERT(leftPoints && rightPoints);
|
|
ASSERT(leftCount && rightCount);
|
|
|
|
REAL radius = leftWidth;
|
|
|
|
// When it comes here, the three points are not degenerate.
|
|
|
|
REAL dot = grad1.X*grad2.X + grad1.Y*grad2.Y; // dot product.
|
|
|
|
REAL cross;
|
|
GpTurningDirection direction = getTurningDirection(
|
|
&cross, grad1, grad2);
|
|
// &cross, grad1, grad2, norm1, norm2);
|
|
|
|
// If dot >= 0 (the bending angle is less than or equal to 90 degrees,
|
|
// we can approximate this arc with one cubic Beizer curve.
|
|
|
|
INT condition;
|
|
REAL smallErr = - 0.001f;
|
|
if(dot > smallErr)
|
|
{
|
|
condition = NeedsBoth;
|
|
getSmallRoundJoin(point, grad1, grad2, norm1, norm2,
|
|
leftWidth, rightWidth,
|
|
leftCount, leftPoints, rightCount, rightPoints,
|
|
dot, cross, needsToAdjustNormals, miterLimit2,
|
|
condition, useBevelJoinInside);
|
|
}
|
|
else
|
|
{
|
|
// The bending angle is larger than 90 and less than or
|
|
// equal to 180 degrees.
|
|
// We can approximate this arc with two cubic Beizer curves.
|
|
|
|
GpPointF *pts1, *pts2;
|
|
INT count1, count2;
|
|
|
|
pts1 = leftPoints;
|
|
pts2 = rightPoints;
|
|
|
|
// First obtain the non-round join parts.
|
|
|
|
condition = NeedsOnlyNonRoundJoin;
|
|
|
|
getSmallRoundJoin(point, grad1, grad2, norm1, norm2,
|
|
leftWidth, rightWidth,
|
|
&count1, pts1, &count2, pts2,
|
|
dot, cross, needsToAdjustNormals, miterLimit2,
|
|
condition, useBevelJoinInside);
|
|
|
|
INT cnt1, cnt2;
|
|
|
|
if(count1 > 0)
|
|
cnt1 = count1;
|
|
else
|
|
cnt1 = 0;
|
|
|
|
if(count2 > 0)
|
|
cnt2 = count2;
|
|
else
|
|
cnt2 = 0;
|
|
|
|
pts1 += cnt1;
|
|
pts2 += cnt2;
|
|
*leftCount = cnt1;
|
|
*rightCount = cnt2;
|
|
|
|
// Obtain the middle unit gradient vector.
|
|
|
|
GpPointF midNorm;
|
|
midNorm.X = norm1.X + norm2.X;
|
|
midNorm.Y = norm1.Y + norm2.Y;
|
|
|
|
if(midNorm.X != 0 || midNorm.Y != 0)
|
|
{
|
|
REAL dm = midNorm.X*midNorm.X + midNorm.Y*midNorm.Y;
|
|
dm = REALSQRT(dm);
|
|
midNorm.X /= dm;
|
|
midNorm.Y /= dm;
|
|
}
|
|
else
|
|
{
|
|
midNorm.X = - norm1.Y;
|
|
midNorm.Y = norm1.X;
|
|
}
|
|
|
|
GpPointF lm;
|
|
|
|
// Rotate the mid normal +90 degrees.
|
|
|
|
lm.X = - midNorm.Y;
|
|
lm.Y = midNorm.X;
|
|
|
|
// Obtain the first half of the round join.
|
|
|
|
condition = NeedsOnlyRoundJoin;
|
|
|
|
dot = grad1.X*lm.X + grad1.Y*lm.Y;
|
|
cross = grad1.X*lm.Y - grad1.Y*lm.X;
|
|
getSmallRoundJoin(point, grad1, lm, norm1, midNorm,
|
|
leftWidth, rightWidth,
|
|
&count1, pts1, &count2, pts2,
|
|
dot, cross, needsToAdjustNormals, miterLimit2,
|
|
condition, useBevelJoinInside);
|
|
|
|
// Note that since the end point of the first half of
|
|
// the round join and the start point of the second
|
|
// of the round join are the same, don't copy
|
|
// the end point of the first half of the round join.
|
|
|
|
if(count1 < 0)
|
|
cnt1 = - count1 - 1;
|
|
else
|
|
cnt1 = 0;
|
|
|
|
if(count2 < 0)
|
|
cnt2 = - count2 - 1;
|
|
else
|
|
cnt2 = 0;
|
|
|
|
pts1 += cnt1;
|
|
pts2 += cnt2;
|
|
*leftCount += cnt1;
|
|
*rightCount += cnt2;
|
|
|
|
// Obtain the second half of the round join.
|
|
|
|
dot = lm.X*grad2.X + lm.Y*grad2.Y;
|
|
cross = lm.X*grad2.Y - lm.Y*grad2.X;
|
|
getSmallRoundJoin(point, lm, grad2, midNorm, norm2,
|
|
leftWidth, rightWidth,
|
|
&count1, pts1, &count2, pts2,
|
|
dot, cross, needsToAdjustNormals, miterLimit2,
|
|
condition, useBevelJoinInside);
|
|
|
|
// Combines the two curves or lines.
|
|
|
|
if(count1 < 0)
|
|
cnt1 += - count1;
|
|
else
|
|
cnt1 = 0;
|
|
|
|
if(count2 < 0)
|
|
cnt2 += - count2;
|
|
else
|
|
cnt2 = 0;
|
|
|
|
if(cnt1 > 0)
|
|
*leftCount = - cnt1;
|
|
if(cnt2 > 0)
|
|
*rightCount = - cnt2;
|
|
}
|
|
|
|
return direction;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Calculates the vector for Miter or Bevel join. This vector represents
|
|
* the shift to the left along the moving direction.
|
|
* In case of Miter join, when the Miter join exceeds the miter limit,
|
|
* this returns the Bevel join.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [OUT] vector - the left shift for the Miter join. This must be
|
|
* allocated at least for the dimension of 2.
|
|
* [OUT] count - the number of join points.
|
|
* [IN] miterLimit2 - the square of the Miter limit.
|
|
* [IN] grad1 - the unit tangent vector of the last edge.
|
|
* [IN] grad2 - the unit tangent vector of the current edge.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Turning direction from the last edge to the current edge.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpTurningDirection
|
|
getHobbyJoin(
|
|
const GpPointF& point,
|
|
const GpPointF& grad1,
|
|
const GpPointF& grad2,
|
|
INT polyCount,
|
|
const GpPointF* polyPoints,
|
|
const REAL* polyAngles,
|
|
// const GpPointF& norm1,
|
|
// const GpPointF& norm2,
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
INT *leftCount,
|
|
GpPointF *leftPoints,
|
|
INT *rightCount,
|
|
GpPointF *rightPoints,
|
|
BOOL needsToAdjustNormals,
|
|
REAL miterLimit2,
|
|
BOOL isMiter,
|
|
BOOL useBevelJoinInside
|
|
)
|
|
{
|
|
if(miterLimit2 <= 1)
|
|
isMiter = FALSE;
|
|
|
|
GpTurningDirection direction = NotTurning;
|
|
|
|
// Handle the degenerate cases.
|
|
|
|
GpPointF v;
|
|
REAL cross;
|
|
|
|
direction = getTurningDirection(&cross, grad1, grad2);
|
|
|
|
if(direction == NotMoving)
|
|
{
|
|
*leftCount = 0;
|
|
*rightCount = 0;
|
|
return direction;
|
|
}
|
|
|
|
// Find the left vertex ids.
|
|
|
|
INT leftIndex1, leftIndex2;
|
|
leftIndex1 = getVertexID(grad1, TRUE, polyCount, polyAngles);
|
|
leftIndex2 = getVertexID(grad2, TRUE, polyCount, polyAngles);
|
|
|
|
INT i;
|
|
|
|
if(direction == TurningLeft)
|
|
{
|
|
*leftCount = 2;
|
|
leftPoints[0] = point + polyPoints[leftIndex1];
|
|
leftPoints[1] = point + polyPoints[leftIndex2];
|
|
}
|
|
else if(direction == TurningRight)
|
|
{
|
|
if(leftIndex2 > leftIndex1)
|
|
{
|
|
*leftCount = leftIndex2 - leftIndex1 + 1;
|
|
|
|
for(i = 0; i <= leftIndex2 - leftIndex1; i++)
|
|
leftPoints[i] = point + polyPoints[i + leftIndex1];
|
|
}
|
|
else if(leftIndex2 < leftIndex1)
|
|
{
|
|
*leftCount = polyCount - leftIndex1 + leftIndex2 + 1;
|
|
|
|
for(i = 0; i < polyCount - leftIndex1; i++)
|
|
leftPoints[i] = point + polyPoints[i + leftIndex1];
|
|
|
|
for(i = 0; i <= leftIndex2; i++)
|
|
leftPoints[polyCount - leftIndex1 + i]
|
|
= point + polyPoints[i];
|
|
}
|
|
else
|
|
{
|
|
*leftCount = 1;
|
|
leftPoints[0] = point + polyPoints[leftIndex1];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*leftCount = 1;
|
|
leftPoints[0] = point + polyPoints[leftIndex1];
|
|
}
|
|
|
|
INT rightIndex1, rightIndex2;
|
|
rightIndex1 = getVertexID(grad1, FALSE, polyCount, polyAngles);
|
|
rightIndex2 = getVertexID(grad2, FALSE, polyCount, polyAngles);
|
|
|
|
if(direction == TurningRight)
|
|
{
|
|
*rightCount = 2;
|
|
rightPoints[0] = point + polyPoints[rightIndex1];
|
|
rightPoints[1] = point + polyPoints[rightIndex2];
|
|
}
|
|
else if(direction == TurningLeft)
|
|
{
|
|
if(rightIndex1 > rightIndex2)
|
|
{
|
|
*rightCount = rightIndex1 - rightIndex2 + 1;
|
|
|
|
for(i = 0; i <= rightIndex1 - rightIndex2; i++)
|
|
rightPoints[i] = point + polyPoints[rightIndex1 - i];
|
|
}
|
|
else if(rightIndex1 < rightIndex2)
|
|
{
|
|
*rightCount = polyCount - rightIndex2 + rightIndex1 + 1;
|
|
|
|
for(i = 0; i <= rightIndex1; i++)
|
|
rightPoints[i] = point + polyPoints[rightIndex1 - i];
|
|
|
|
for(i = 0; i < polyCount - rightIndex2; i++)
|
|
rightPoints[rightIndex1 + 1 + i]
|
|
= point + polyPoints[polyCount - i - 1];
|
|
}
|
|
else
|
|
{
|
|
*rightCount = 1;
|
|
rightPoints[0] = point + polyPoints[rightIndex1];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*rightCount = 1;
|
|
rightPoints[0] = point + polyPoints[rightIndex1];
|
|
}
|
|
|
|
return direction;
|
|
}
|
|
|
|
GpTurningDirection
|
|
getJoin(
|
|
GpLineJoin lineJoin,
|
|
const GpPointF& point,
|
|
const GpPointF& grad1,
|
|
const GpPointF& grad2,
|
|
const GpPointF& norm1,
|
|
const GpPointF& norm2,
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
INT *leftCount,
|
|
GpPointF *leftPoints,
|
|
BOOL *leftInside,
|
|
INT *rightCount,
|
|
GpPointF *rightPoints,
|
|
BOOL *rightInside,
|
|
BOOL needsToAdjustNormals,
|
|
REAL miterLimit2,
|
|
BOOL useBevelJoinInside
|
|
)
|
|
{
|
|
BOOL isMiter = TRUE;
|
|
|
|
GpTurningDirection direction;
|
|
|
|
switch(lineJoin)
|
|
{
|
|
case LineJoinBevel:
|
|
isMiter = FALSE; // Fall through to Miter case.
|
|
|
|
case LineJoinMiterClipped:
|
|
// Treat Miter clipped joints that exceed the miter limit as
|
|
// beveled joints. Fall through to Miter case.
|
|
if (lineJoin == LineJoinMiterClipped &&
|
|
getMiterExceeded(grad1, grad2, miterLimit2))
|
|
{
|
|
isMiter = FALSE;
|
|
}
|
|
|
|
case LineJoinMiter:
|
|
direction = getMiterBevelJoin(point, grad1, grad2, norm1, norm2,
|
|
leftWidth, rightWidth,
|
|
leftCount, leftPoints, leftInside,
|
|
rightCount, rightPoints, rightInside,
|
|
needsToAdjustNormals, miterLimit2, isMiter, useBevelJoinInside);
|
|
break;
|
|
|
|
case LineJoinRound:
|
|
direction = getRoundJoin(point, grad1, grad2, norm1, norm2,
|
|
leftWidth, rightWidth,
|
|
leftCount, leftPoints, leftInside,
|
|
rightCount, rightPoints, rightInside,
|
|
needsToAdjustNormals, miterLimit2, useBevelJoinInside);
|
|
break;
|
|
}
|
|
|
|
return direction;
|
|
}
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* From the given the reference point, gradient, and widths,
|
|
* this returns the verteces for the round cap.
|
|
* The direction of the round cap is always clockwise.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] point - The reference point.
|
|
* [IN] grad - The gradient.
|
|
* [IN] isStartCap - TRUE if this is the start cap.
|
|
* [IN] leftWidth - The left width from the reference.
|
|
* [IN] rightWidth - The right width from the reference point.
|
|
*
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Ok if successfull.
|
|
*
|
|
* 06/16/99 ikkof
|
|
* Created it
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
GpPathWidener::SetRoundCap(
|
|
const GpPointF& point,
|
|
const GpPointF& grad,
|
|
BOOL isStartCap,
|
|
REAL leftWidth,
|
|
REAL rightWidth
|
|
)
|
|
{
|
|
if( (REALABS(grad.X) < REAL_EPSILON) &&
|
|
(REALABS(grad.Y) < REAL_EPSILON) )
|
|
{
|
|
return InvalidParameter;
|
|
}
|
|
|
|
GpPointF* capPoints = NULL;
|
|
BYTE* capTypes = NULL;
|
|
|
|
if(isStartCap)
|
|
{
|
|
CapPoints1.Reset(FALSE);
|
|
CapTypes1.Reset(FALSE);
|
|
capPoints = CapPoints1.AddMultiple(7);
|
|
if(capPoints)
|
|
capTypes = CapTypes1.AddMultiple(7);
|
|
|
|
if(!capPoints || !capTypes)
|
|
return OutOfMemory;
|
|
}
|
|
else
|
|
{
|
|
CapPoints2.Reset(FALSE);
|
|
CapTypes2.Reset(FALSE);
|
|
capPoints = CapPoints2.AddMultiple(7);
|
|
if(capPoints)
|
|
capTypes = CapTypes2.AddMultiple(7);
|
|
|
|
if(!capPoints || !capTypes)
|
|
return OutOfMemory;
|
|
}
|
|
|
|
GpMemset(capTypes, PathPointTypeBezier, 7);
|
|
capTypes[0] = PathPointTypeLine;
|
|
|
|
GpPointF tangent;
|
|
|
|
if(isStartCap)
|
|
{
|
|
tangent.X = - grad.X;
|
|
tangent.Y = - grad.Y;
|
|
}
|
|
else
|
|
tangent = grad;
|
|
|
|
REAL radius = (leftWidth - rightWidth)/2;
|
|
GpPointF center;
|
|
|
|
center.X = point.X + (leftWidth + rightWidth)*grad.Y/2;
|
|
center.Y = point.Y - (leftWidth + rightWidth)*grad.X/2;
|
|
|
|
if(isStartCap)
|
|
{
|
|
center.X -= Inset1*tangent.X;
|
|
center.Y -= Inset1*tangent.Y;
|
|
}
|
|
else
|
|
{
|
|
center.X -= Inset2*tangent.X;
|
|
center.Y -= Inset2*tangent.Y;
|
|
}
|
|
|
|
REAL s1, c1;
|
|
|
|
// Direction of the left normal multipled by radius.
|
|
|
|
c1 = radius*tangent.Y;
|
|
s1 = - radius*tangent.X;
|
|
|
|
// 2 Bezier segments for a half circle with radius 1.
|
|
|
|
REAL u_cir = U_CIR;
|
|
capPoints[ 0].X = 1; capPoints[ 0].Y = 0;
|
|
capPoints[ 1].X = 1; capPoints[ 1].Y = u_cir;
|
|
capPoints[ 2].X = u_cir; capPoints[ 2].Y = 1;
|
|
capPoints[ 3].X = 0; capPoints[ 3].Y = 1;
|
|
capPoints[ 4].X = -u_cir; capPoints[ 4].Y = 1;
|
|
capPoints[ 5].X = -1; capPoints[ 5].Y = u_cir;
|
|
capPoints[ 6].X = -1; capPoints[ 6].Y = 0;
|
|
|
|
// Rotate, scale, and translate the original half circle.
|
|
|
|
for(INT i = 0; i < 7; i++)
|
|
{
|
|
REAL x, y;
|
|
|
|
x = capPoints[i].X;
|
|
y = capPoints[i].Y;
|
|
capPoints[i].X = (c1*x - s1*y) + center.X;
|
|
capPoints[i].Y = (s1*x + c1*y) + center.Y;
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Creates a double round cap for inset pen ('B' shaped)
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] point - The reference point.
|
|
* [IN] grad - The gradient.
|
|
* [IN] isStartCap - TRUE if this is the start cap.
|
|
* [IN] leftWidth - The left width from the reference.
|
|
* [IN] rightWidth - The right width from the reference point.
|
|
*
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Ok if successfull.
|
|
*
|
|
* 10/01/2000 asecchia
|
|
* Created it
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
GpPathWidener::SetDoubleRoundCap(
|
|
const GpPointF& point,
|
|
const GpPointF& grad,
|
|
BOOL isStartCap,
|
|
REAL leftWidth,
|
|
REAL rightWidth
|
|
)
|
|
{
|
|
if( (REALABS(grad.X) < REAL_EPSILON) &&
|
|
(REALABS(grad.Y) < REAL_EPSILON) )
|
|
{
|
|
return InvalidParameter;
|
|
}
|
|
|
|
GpPointF* capPoints = NULL;
|
|
BYTE* capTypes = NULL;
|
|
|
|
if(isStartCap)
|
|
{
|
|
CapPoints1.Reset(FALSE);
|
|
CapTypes1.Reset(FALSE);
|
|
capPoints = CapPoints1.AddMultiple(14);
|
|
if(capPoints)
|
|
capTypes = CapTypes1.AddMultiple(14);
|
|
|
|
if(!capPoints || !capTypes)
|
|
return OutOfMemory;
|
|
}
|
|
else
|
|
{
|
|
CapPoints2.Reset(FALSE);
|
|
CapTypes2.Reset(FALSE);
|
|
capPoints = CapPoints2.AddMultiple(14);
|
|
if(capPoints)
|
|
capTypes = CapTypes2.AddMultiple(14);
|
|
|
|
if(!capPoints || !capTypes)
|
|
return OutOfMemory;
|
|
}
|
|
|
|
GpMemset(capTypes, PathPointTypeBezier, 14);
|
|
capTypes[0] = PathPointTypeLine;
|
|
capTypes[7] = PathPointTypeLine;
|
|
|
|
GpPointF tangent;
|
|
|
|
if(isStartCap)
|
|
{
|
|
tangent.X = - grad.X;
|
|
tangent.Y = - grad.Y;
|
|
}
|
|
else
|
|
tangent = grad;
|
|
|
|
REAL radius = (leftWidth - rightWidth)/2;
|
|
GpPointF center;
|
|
|
|
center.X = point.X + (leftWidth + rightWidth)*grad.Y/2;
|
|
center.Y = point.Y - (leftWidth + rightWidth)*grad.X/2;
|
|
|
|
if(isStartCap)
|
|
{
|
|
center.X -= Inset1*tangent.X;
|
|
center.Y -= Inset1*tangent.Y;
|
|
}
|
|
else
|
|
{
|
|
center.X -= Inset2*tangent.X;
|
|
center.Y -= Inset2*tangent.Y;
|
|
}
|
|
|
|
REAL s1, c1;
|
|
|
|
// Direction of the left normal multipled by radius.
|
|
|
|
c1 = radius*tangent.Y;
|
|
s1 = - radius*tangent.X;
|
|
|
|
// 2 Bezier segments for a half circle with radius 1.
|
|
|
|
REAL u_cir = U_CIR;
|
|
capPoints[ 0].X = 1; capPoints[ 0].Y = 0;
|
|
capPoints[ 1].X = 1; capPoints[ 1].Y = u_cir;
|
|
capPoints[ 2].X = u_cir; capPoints[ 2].Y = 1;
|
|
capPoints[ 3].X = 0; capPoints[ 3].Y = 1;
|
|
capPoints[ 4].X = -u_cir; capPoints[ 4].Y = 1;
|
|
capPoints[ 5].X = -1; capPoints[ 5].Y = u_cir;
|
|
capPoints[ 6].X = -1; capPoints[ 6].Y = 0;
|
|
|
|
// Create the second bump and scale the first one.
|
|
|
|
for(int i=0; i<7; i++)
|
|
{
|
|
capPoints[i+7].X = capPoints[i].X * 0.5f-0.5f;
|
|
capPoints[i+7].Y = capPoints[i].Y * 0.5f;
|
|
capPoints[i].X = 0.5f + capPoints[i].X * 0.5f;
|
|
capPoints[i].Y = capPoints[i].Y * 0.5f;
|
|
}
|
|
|
|
// Rotate, scale, and translate the original half circle.
|
|
|
|
for(INT i = 0; i < 14; i++)
|
|
{
|
|
REAL x, y;
|
|
|
|
x = capPoints[i].X;
|
|
y = capPoints[i].Y;
|
|
capPoints[i].X = (c1*x - s1*y) + center.X;
|
|
capPoints[i].Y = (s1*x + c1*y) + center.Y;
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus
|
|
GpPathWidener::SetTriangleCap(
|
|
const GpPointF& point,
|
|
const GpPointF& grad,
|
|
BOOL isStartCap,
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
const GpPointF *points,
|
|
INT pointCount
|
|
)
|
|
{
|
|
if( (REALABS(grad.X) < REAL_EPSILON) &&
|
|
(REALABS(grad.Y) < REAL_EPSILON) )
|
|
{
|
|
return InvalidParameter;
|
|
}
|
|
|
|
GpPointF* capPoints = NULL;
|
|
BYTE* capTypes = NULL;
|
|
|
|
DynByteArray *capTypesArray;
|
|
DynPointFArray *capPointsArray;
|
|
|
|
|
|
if(isStartCap)
|
|
{
|
|
CapPoints1.Reset(FALSE);
|
|
CapTypes1.Reset(FALSE);
|
|
capPoints = CapPoints1.AddMultiple(3);
|
|
if(capPoints)
|
|
capTypes = CapTypes1.AddMultiple(3);
|
|
|
|
if(!capPoints || !capTypes)
|
|
return OutOfMemory;
|
|
}
|
|
else
|
|
{
|
|
CapPoints2.Reset(FALSE);
|
|
CapTypes2.Reset(FALSE);
|
|
capPoints = CapPoints2.AddMultiple(3);
|
|
if(capPoints)
|
|
capTypes = CapTypes2.AddMultiple(3);
|
|
|
|
if(!capPoints || !capTypes)
|
|
return OutOfMemory;
|
|
}
|
|
|
|
GpMemset(&capTypes[0], PathPointTypeLine, 3);
|
|
|
|
|
|
GpPointF norm, tangent;
|
|
|
|
norm.X = grad.Y;
|
|
norm.Y = - grad.X;
|
|
|
|
if(isStartCap)
|
|
{
|
|
tangent.X = - grad.X;
|
|
tangent.Y = - grad.Y;
|
|
}
|
|
else
|
|
{
|
|
tangent = grad;
|
|
}
|
|
|
|
GpPointF leftPt, rightPt;
|
|
|
|
leftPt.X = point.X + leftWidth*norm.X;
|
|
leftPt.Y = point.Y + leftWidth*norm.Y;
|
|
rightPt.X = point.X + rightWidth*norm.X;
|
|
rightPt.Y = point.Y + rightWidth*norm.Y;
|
|
|
|
GpPointF center;
|
|
|
|
REAL width = REALABS(leftWidth-rightWidth);
|
|
|
|
center.X = 0.5f*(leftPt.X + rightPt.X + width*tangent.X);
|
|
center.Y = 0.5f*(leftPt.Y + rightPt.Y + width*tangent.Y);
|
|
|
|
capPoints[1] = center;
|
|
|
|
if(isStartCap)
|
|
{
|
|
capPoints[0] = rightPt;
|
|
capPoints[2] = leftPt;
|
|
}
|
|
else
|
|
{
|
|
capPoints[0] = leftPt;
|
|
capPoints[2] = rightPt;
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Add the first widened point of the current path type.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* [IN] leftWidth - The left width for widened line.
|
|
* [IN] rightWidth - The right width for the widened line.
|
|
* [IN] lineJoin - The type of the line join.
|
|
* [OUT] leftPoints1 - The buffer for the left points.
|
|
* [OUT] leftTypes1 - The buffer for the left types.
|
|
* [OUT] addedLeftCount - The number of the added left points and types.
|
|
* [OUT] rightPoints1 - The buffer for the right points.
|
|
* [OUT] rightTypes1 - The buffer for the right types.
|
|
* [OUT] addedRightCount - The number of the added right points and types.
|
|
* [OUT] leftEndPt - The end point of the left line for the current
|
|
* subpath. This is calculated only for the first
|
|
* subpath point.
|
|
* [OUT] rightEndPt - The end point of the right line for tha current
|
|
* subpath. This is calculated only for the first
|
|
* subpath point.
|
|
* [IN] grad - The gradients of the center points for the
|
|
* current path type.
|
|
* [IN] dataPoints - The center points data for the current path type
|
|
* [IN] dataCount - The number of data points in the current path type.
|
|
* [IN/OUT] lastPt - The last point used in calculations.
|
|
* [IN] flag - The flag to indicates the various properties
|
|
* of the current subpath and type.
|
|
*
|
|
*
|
|
* Return Value:
|
|
*
|
|
* NONE
|
|
*
|
|
* 01/24/2000 ikkof
|
|
* Created it
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID
|
|
GpPathWidener::WidenFirstPoint(
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
GpLineJoin lineJoin,
|
|
REAL miterLimit2,
|
|
GpPointF* leftPoints,
|
|
BYTE* leftTypes,
|
|
INT* addedLeftCount,
|
|
GpPointF* rightPoints,
|
|
BYTE* rightTypes,
|
|
INT* addedRightCount,
|
|
GpPointF* leftEndPt,
|
|
GpPointF* rightEndPt,
|
|
const GpPointF* grad,
|
|
const GpPointF* norm,
|
|
const GpPointF* dataPoints,
|
|
INT dataCount,
|
|
GpPointF* lastPt,
|
|
const REAL* firstInsets,
|
|
INT flag
|
|
)
|
|
{
|
|
GpPointF nextPt = dataPoints[0];
|
|
GpPointF grad1, grad2;
|
|
GpPointF norm1, norm2;
|
|
|
|
|
|
INT leftCount = 0;
|
|
INT rightCount = 0;
|
|
grad1 = *grad++;
|
|
grad2 = *grad;
|
|
norm1 = *norm++;
|
|
norm2 = *norm;
|
|
|
|
INT numOfAddedFirstPts = 0;
|
|
|
|
if(flag & WideningFirstType)
|
|
{
|
|
BOOL needsToAdjustNormals = FALSE;
|
|
|
|
GpLineJoin lineJoin1 = lineJoin;
|
|
if(flag & WideningNeedsToAdjustNormals)
|
|
{
|
|
needsToAdjustNormals = TRUE;
|
|
lineJoin1 = LineJoinMiter; // Don't use RoundJoin.
|
|
}
|
|
|
|
if(!(flag & WideningClosed))
|
|
{
|
|
lineJoin1 = LineJoinBevel;
|
|
}
|
|
|
|
const INT bufferCount = 32;
|
|
GpPointF lPts[bufferCount], rPts[bufferCount];
|
|
INT lCnt, rCnt;
|
|
GpTurningDirection direction;
|
|
BOOL useBevelJoinInside = (flag & WideningUseBevelJoinInside) != 0;
|
|
|
|
INT polyCount = JoinPolygonPoints.GetCount();
|
|
const GpPointF* polyPoints = JoinPolygonPoints.GetDataBuffer();
|
|
const REAL* polyAngles = JoinPolygonAngles.GetDataBuffer();
|
|
|
|
BOOL leftInside = FALSE, rightInside = FALSE;
|
|
|
|
if(polyCount > 0)
|
|
direction = getHobbyJoin(
|
|
// lineJoin1,
|
|
nextPt,
|
|
grad1,
|
|
grad2,
|
|
polyCount,
|
|
polyPoints,
|
|
polyAngles,
|
|
leftWidth,
|
|
rightWidth,
|
|
&lCnt,
|
|
&lPts[0],
|
|
&rCnt,
|
|
&rPts[0],
|
|
needsToAdjustNormals,
|
|
miterLimit2,
|
|
FALSE, // IsMiter
|
|
useBevelJoinInside
|
|
);
|
|
else
|
|
direction = getJoin(
|
|
lineJoin1,
|
|
nextPt,
|
|
grad1,
|
|
grad2,
|
|
norm1,
|
|
norm2,
|
|
leftWidth,
|
|
rightWidth,
|
|
&lCnt,
|
|
&lPts[0],
|
|
&leftInside,
|
|
&rCnt,
|
|
&rPts[0],
|
|
&rightInside,
|
|
needsToAdjustNormals,
|
|
miterLimit2,
|
|
useBevelJoinInside
|
|
);
|
|
|
|
//!!! Inside flag check
|
|
if(leftInside)
|
|
{
|
|
ASSERT((lCnt & 0x01) == 0);
|
|
}
|
|
|
|
|
|
//!!! Inside flag check
|
|
if(rightInside)
|
|
{
|
|
ASSERT((rCnt & 0x01) == 0);
|
|
}
|
|
|
|
*leftEndPt = lPts[0];
|
|
*rightEndPt = rPts[0];
|
|
|
|
BYTE pathType;
|
|
|
|
if(flag & WideningClosed)
|
|
{
|
|
if(lCnt > 0)
|
|
{
|
|
pathType = PathPointTypeLine;
|
|
}
|
|
else if(lCnt < 0)
|
|
{
|
|
lCnt = - lCnt;
|
|
pathType = PathPointTypeBezier;
|
|
}
|
|
|
|
if(lCnt > 0)
|
|
{
|
|
//!!! Inside flag check
|
|
if(leftInside)
|
|
{
|
|
ASSERT((lCnt & 0x01) == 0);
|
|
}
|
|
|
|
if(leftInside)
|
|
pathType |= PathPointTypeInternalUse;
|
|
GpMemset(leftTypes, pathType, lCnt);
|
|
leftTypes[0] = PathPointTypeStart;
|
|
if(leftInside)
|
|
leftTypes[0] |= PathPointTypeInternalUse;
|
|
|
|
GpMemcpy(leftPoints, &lPts[0], lCnt*sizeof(GpPointF));
|
|
leftTypes += lCnt;
|
|
leftPoints += lCnt;
|
|
leftCount += lCnt;
|
|
}
|
|
|
|
if(rCnt > 0)
|
|
{
|
|
pathType = PathPointTypeLine;
|
|
}
|
|
else if(rCnt < 0)
|
|
{
|
|
rCnt = - rCnt;
|
|
pathType = PathPointTypeBezier;
|
|
}
|
|
|
|
if(rCnt > 0)
|
|
{
|
|
//!!! Inside flag check
|
|
if(rightInside)
|
|
{
|
|
ASSERT((rCnt & 0x01) == 0);
|
|
}
|
|
|
|
if(rightInside)
|
|
pathType |= PathPointTypeInternalUse;
|
|
GpMemset(rightTypes, pathType, rCnt);
|
|
rightTypes[0] = PathPointTypeStart;
|
|
if(rightInside)
|
|
rightTypes[0] |= PathPointTypeInternalUse;
|
|
|
|
GpMemcpy(rightPoints, &rPts[0], rCnt*sizeof(GpPointF));
|
|
rightTypes += rCnt;
|
|
rightPoints += rCnt;
|
|
rightCount += rCnt;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The path is not closed. Bevel join is used.
|
|
|
|
GpPointF leftStartPt;
|
|
GpPointF rightStartPt;
|
|
INT index;
|
|
|
|
if(lCnt == 1)
|
|
index = 0;
|
|
else
|
|
index = 1;
|
|
leftStartPt = lPts[index];
|
|
|
|
if(rCnt == 1)
|
|
index = 0;
|
|
else
|
|
index = 1;
|
|
rightStartPt = rPts[index];
|
|
|
|
if(!(flag & WideningClosed) && firstInsets[0] != 0)
|
|
{
|
|
leftStartPt.X += firstInsets[0]*grad2.X;
|
|
leftStartPt.Y += firstInsets[0]*grad2.Y;
|
|
}
|
|
|
|
if(!(flag & WideningClosed) && firstInsets[1] != 0)
|
|
{
|
|
rightStartPt.X += firstInsets[1]*grad2.X;
|
|
rightStartPt.Y += firstInsets[1]*grad2.Y;
|
|
}
|
|
|
|
*leftTypes++ = PathPointTypeStart;
|
|
*rightTypes++ = PathPointTypeStart;
|
|
*leftPoints = leftStartPt;
|
|
*rightPoints = rightStartPt;
|
|
|
|
leftPoints++;
|
|
rightPoints++;
|
|
leftCount++;
|
|
rightCount++;
|
|
}
|
|
|
|
*lastPt = nextPt;
|
|
}
|
|
else
|
|
{
|
|
leftCount = rightCount = 0;
|
|
}
|
|
|
|
*addedLeftCount = leftCount;
|
|
*addedRightCount = rightCount;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Add the widened points for Lines
|
|
*
|
|
* For the arguments, See comments for widenFirstPoints
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
GpPathWidener::WidenLinePoints(
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
GpLineJoin lineJoin,
|
|
REAL miterLimit2,
|
|
GpPointF* leftPoints,
|
|
BYTE* leftTypes,
|
|
INT* addedLeftCount,
|
|
GpPointF* rightPoints,
|
|
BYTE* rightTypes,
|
|
INT* addedRightCount,
|
|
const GpPointF* grad,
|
|
const GpPointF* norm,
|
|
const GpPointF* dataPoints,
|
|
INT dataCount,
|
|
GpPointF* lastPt,
|
|
const REAL* lastInsets,
|
|
INT flag
|
|
)
|
|
{
|
|
GpPointF grad1, grad2;
|
|
GpPointF norm1, norm2;
|
|
|
|
// Skip the first point since it is already added either by
|
|
// widenFirstPoint() or by the widen call of the previous type.
|
|
|
|
dataPoints++;
|
|
dataCount--; // The number of the remaining points.
|
|
|
|
// Also skip the first gradient.
|
|
|
|
grad++;
|
|
grad1 = *grad++;
|
|
norm++;
|
|
norm1 = *norm++;
|
|
|
|
BOOL isLastType = FALSE;
|
|
|
|
if(flag & WideningLastType)
|
|
isLastType = TRUE;
|
|
|
|
BOOL needsToAdjustNormals = FALSE;
|
|
|
|
GpLineJoin lineJoin1 = lineJoin;
|
|
if(flag & WideningNeedsToAdjustNormals)
|
|
{
|
|
needsToAdjustNormals = TRUE;
|
|
lineJoin1 = LineJoinMiter; // Don't use RoundJoin.
|
|
}
|
|
|
|
INT leftCount = 0, rightCount = 0;
|
|
BOOL isLastPoint = FALSE;
|
|
BYTE pathType = PathPointTypeLine;
|
|
|
|
INT jmax = dataCount;
|
|
if(isLastType)
|
|
{
|
|
if(flag & WideningClosed)
|
|
{
|
|
if(!(flag & WideningLastPointSame))
|
|
{
|
|
// When the subpath is closed, and the last point is not
|
|
// the same as the start point, don't regard this as
|
|
// the last type. Add points as usual.
|
|
|
|
isLastType = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// No need to add the last point since this is already
|
|
// added by the first point.
|
|
|
|
jmax--;
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL useBevelJoinInside = (flag & WideningUseBevelJoinInside) != 0;
|
|
|
|
INT polyCount = JoinPolygonPoints.GetCount();
|
|
const GpPointF* polyPoints = JoinPolygonPoints.GetDataBuffer();
|
|
const REAL* polyAngles = JoinPolygonAngles.GetDataBuffer();
|
|
|
|
INT i, j;
|
|
for(j = 0; j < jmax; j++)
|
|
{
|
|
GpPointF nextPt = *dataPoints;
|
|
|
|
if(isLastType && (j == dataCount - 1))
|
|
{
|
|
isLastPoint = TRUE;
|
|
lineJoin1 = LineJoinBevel;
|
|
}
|
|
|
|
if(lastPt->X != nextPt.X || lastPt->Y != nextPt.Y)
|
|
{
|
|
grad2 = *grad;
|
|
norm2 = *norm;
|
|
|
|
const INT bufferCount = 32;
|
|
GpPointF lPts[bufferCount], rPts[bufferCount];
|
|
INT lCnt, rCnt;
|
|
GpTurningDirection direction;
|
|
BOOL leftInside = FALSE, rightInside = FALSE;
|
|
|
|
if(polyCount > 0)
|
|
direction = getHobbyJoin(
|
|
// lineJoin1,
|
|
nextPt,
|
|
grad1,
|
|
grad2,
|
|
polyCount,
|
|
polyPoints,
|
|
polyAngles,
|
|
leftWidth,
|
|
rightWidth,
|
|
&lCnt,
|
|
&lPts[0],
|
|
&rCnt,
|
|
&rPts[0],
|
|
needsToAdjustNormals,
|
|
miterLimit2,
|
|
FALSE, // IsMiter
|
|
useBevelJoinInside
|
|
);
|
|
else
|
|
direction = getJoin(
|
|
lineJoin1,
|
|
nextPt,
|
|
grad1,
|
|
grad2,
|
|
norm1,
|
|
norm2,
|
|
leftWidth,
|
|
rightWidth,
|
|
&lCnt,
|
|
&lPts[0],
|
|
&leftInside,
|
|
&rCnt,
|
|
&rPts[0],
|
|
&rightInside,
|
|
needsToAdjustNormals,
|
|
miterLimit2,
|
|
useBevelJoinInside
|
|
);
|
|
|
|
//!!! Inside flag check
|
|
if(leftInside)
|
|
{
|
|
ASSERT((lCnt & 0x01) == 0);
|
|
}
|
|
|
|
|
|
//!!! Inside flag check
|
|
if(rightInside)
|
|
{
|
|
ASSERT((rCnt & 0x01) == 0);
|
|
}
|
|
|
|
if(isLastPoint)
|
|
{
|
|
lCnt = 1;
|
|
rCnt = 1;
|
|
leftInside = FALSE;
|
|
rightInside = FALSE;
|
|
|
|
if(lastInsets[0] != 0)
|
|
{
|
|
lPts[0].X -= lastInsets[0]*grad1.X;
|
|
lPts[0].Y -= lastInsets[0]*grad1.Y;
|
|
}
|
|
|
|
if(lastInsets[1] != 0)
|
|
{
|
|
rPts[0].X -= lastInsets[1]*grad1.X;
|
|
rPts[0].Y -= lastInsets[1]*grad1.Y;
|
|
}
|
|
}
|
|
|
|
if(lCnt > 0)
|
|
{
|
|
pathType = PathPointTypeLine;
|
|
}
|
|
else if(lCnt < 0)
|
|
{
|
|
lCnt = - lCnt;
|
|
pathType = PathPointTypeBezier;
|
|
}
|
|
|
|
if(lCnt > 0)
|
|
{
|
|
//!!! Inside flag check
|
|
if(leftInside)
|
|
{
|
|
ASSERT((lCnt & 0x01) == 0);
|
|
}
|
|
|
|
if(leftInside)
|
|
pathType |= PathPointTypeInternalUse;
|
|
GpMemset(leftTypes, pathType, lCnt);
|
|
leftTypes[0] = PathPointTypeLine;
|
|
if(leftInside)
|
|
leftTypes[0] |= PathPointTypeInternalUse;
|
|
|
|
GpMemcpy(leftPoints, &lPts[0], lCnt*sizeof(GpPointF));
|
|
leftTypes += lCnt;
|
|
leftPoints += lCnt;
|
|
leftCount += lCnt;
|
|
}
|
|
|
|
if(rCnt > 0)
|
|
{
|
|
pathType = PathPointTypeLine;
|
|
}
|
|
else if(rCnt < 0)
|
|
{
|
|
rCnt = - rCnt;
|
|
pathType = PathPointTypeBezier;
|
|
}
|
|
|
|
if(rCnt > 0)
|
|
{
|
|
//!!! Inside flag check
|
|
if(rightInside)
|
|
{
|
|
ASSERT((rCnt & 0x01) == 0);
|
|
}
|
|
|
|
if(rightInside)
|
|
pathType |= PathPointTypeInternalUse;
|
|
GpMemset(rightTypes, pathType, rCnt);
|
|
rightTypes[0] = PathPointTypeLine;
|
|
if(rightInside)
|
|
rightTypes[0] |= PathPointTypeInternalUse;
|
|
|
|
GpMemcpy(rightPoints, &rPts[0], rCnt*sizeof(GpPointF));
|
|
rightTypes += rCnt;
|
|
rightPoints += rCnt;
|
|
rightCount += rCnt;
|
|
}
|
|
|
|
grad1 = grad2;
|
|
norm1 = norm2;
|
|
*lastPt = nextPt;
|
|
}
|
|
|
|
grad++;
|
|
norm++;
|
|
dataPoints++;
|
|
}
|
|
|
|
*addedLeftCount = leftCount;
|
|
*addedRightCount = rightCount;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Add the widened points for Beziers
|
|
*
|
|
* For the arguments, See comments for widenFirstPoints
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
GpPathWidener::WidenBezierPoints(
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
GpLineJoin lineJoin,
|
|
REAL miterLimit2,
|
|
GpPointF* leftPoints,
|
|
BYTE* leftTypes,
|
|
INT* addedLeftCount,
|
|
GpPointF* rightPoints,
|
|
BYTE* rightTypes,
|
|
INT* addedRightCount,
|
|
const GpPointF* grad,
|
|
const GpPointF* norm,
|
|
const GpPointF* dataPoints,
|
|
INT dataCount,
|
|
GpPointF* lastPt,
|
|
const REAL* lastInsets,
|
|
INT flag
|
|
)
|
|
{
|
|
//!!! Kink removal has not been considered here yet.
|
|
|
|
GpPointF grad1, grad2;
|
|
GpPointF norm1, norm2;
|
|
|
|
// Skip the first point since it is already added either by
|
|
// widenFirstPoint() or by the widen call of the previous type.
|
|
|
|
dataPoints++;
|
|
dataCount--; // The number of the remaining points.
|
|
|
|
// Also skip the first gradient.
|
|
|
|
grad++;
|
|
grad1 = *grad++;
|
|
|
|
norm++;
|
|
norm1 = *norm++;
|
|
|
|
BOOL isLastType = FALSE;
|
|
|
|
if(flag & WideningLastType)
|
|
isLastType = TRUE;
|
|
|
|
BOOL needsToAdjustNormals = FALSE;
|
|
|
|
GpLineJoin lineJoin1 = lineJoin;
|
|
if(flag & WideningNeedsToAdjustNormals)
|
|
{
|
|
needsToAdjustNormals = TRUE;
|
|
lineJoin1 = LineJoinMiter; // Don't use RoundJoin.
|
|
}
|
|
|
|
INT remainder = dataCount % 3;
|
|
INT bezierCount = dataCount/3;
|
|
|
|
ASSERT(remainder == 0); // dataCount must be multiple of 3.
|
|
|
|
INT leftCount = 0, rightCount = 0;
|
|
BOOL isLastPoint = FALSE;
|
|
BYTE pathType = PathPointTypeBezier;
|
|
|
|
if(isLastType)
|
|
{
|
|
if((flag & WideningClosed) && !(flag & WideningLastPointSame))
|
|
{
|
|
// When the subpath is closed, and the last point is not
|
|
// the same as the start point, don't regard this as
|
|
// the last type. Add points as usual.
|
|
|
|
isLastType = FALSE;
|
|
}
|
|
|
|
// When the path is closed and the last point is the same,
|
|
// we must do the special treatment since the last join points
|
|
// were already added as the first join points.
|
|
// So keep isLastType to TRUE for this case.
|
|
}
|
|
|
|
BOOL useBevelJoinInside = flag & WideningUseBevelJoinInside;
|
|
|
|
INT i, j;
|
|
for(j = 0; j < bezierCount; j++)
|
|
{
|
|
for(INT k = 0; k < 3; k++)
|
|
{
|
|
GpPointF nextPt = *dataPoints;
|
|
|
|
if(k < 2)
|
|
{
|
|
// Second and third control point.
|
|
|
|
lineJoin1 = LineJoinMiter;
|
|
}
|
|
else
|
|
{
|
|
// The last control point.
|
|
|
|
// lineJoin1 = lineJoin;
|
|
lineJoin1 = LineJoinRound;
|
|
}
|
|
|
|
if(isLastType
|
|
&& (j == bezierCount - 1) && (k == 2))
|
|
{
|
|
isLastPoint = TRUE;
|
|
|
|
if(!(flag & WideningClosed))
|
|
{
|
|
// When the subpath is not closed, make the
|
|
// last join as Bevel join.
|
|
|
|
lineJoin1 = LineJoinBevel;
|
|
|
|
// When the subpath is closed, use the current
|
|
// join.
|
|
}
|
|
else
|
|
{
|
|
lineJoin1 = LineJoinRound;
|
|
}
|
|
}
|
|
|
|
grad2 = *grad;
|
|
norm2 = *norm;
|
|
GpPointF lPts[7], rPts[7];
|
|
INT lCnt, rCnt;
|
|
GpTurningDirection direction;
|
|
BOOL leftInside = FALSE, rightInside = FALSE;
|
|
|
|
direction = getJoin(
|
|
lineJoin1,
|
|
nextPt,
|
|
grad1,
|
|
grad2,
|
|
norm1,
|
|
norm2,
|
|
leftWidth,
|
|
rightWidth,
|
|
&lCnt,
|
|
&lPts[0],
|
|
&leftInside,
|
|
&rCnt,
|
|
&rPts[0],
|
|
&rightInside,
|
|
needsToAdjustNormals,
|
|
miterLimit2,
|
|
useBevelJoinInside
|
|
);
|
|
|
|
if(k < 2)
|
|
{
|
|
// In case that the miter join was not availabe
|
|
// for k < 2, take the average of two vectors.
|
|
|
|
if(lCnt == 2)
|
|
{
|
|
lPts[0].X = (lPts[0].X + lPts[1].X)/2;
|
|
lPts[0].Y = (lPts[0].Y + lPts[1].Y)/2;
|
|
}
|
|
lCnt = 1;
|
|
|
|
if(rCnt == 2)
|
|
{
|
|
rPts[0].X = (rPts[0].X + rPts[1].X)/2;
|
|
rPts[0].Y = (rPts[0].Y + rPts[1].Y)/2;
|
|
}
|
|
rCnt = 1;
|
|
}
|
|
|
|
if(isLastPoint)
|
|
{
|
|
// In order to keep the 3n point format for the Bezier
|
|
// curves, we must add the first point of the join
|
|
// points as the last point of the last Bezier segment.
|
|
|
|
if(!(flag & WideningClosed))
|
|
{
|
|
lCnt = 1;
|
|
rCnt = 1;
|
|
|
|
if(lastInsets[0] != 0)
|
|
{
|
|
lPts[0].X -= lastInsets[0]*grad1.X;
|
|
lPts[0].Y -= lastInsets[0]*grad1.Y;
|
|
}
|
|
|
|
if(lastInsets[1] != 0)
|
|
{
|
|
rPts[0].X -= lastInsets[1]*grad1.X;
|
|
rPts[0].Y -= lastInsets[1]*grad1.Y;
|
|
}
|
|
}
|
|
}
|
|
|
|
*leftPoints++ = lPts[0];
|
|
*leftTypes++ = pathType;
|
|
leftCount++;
|
|
|
|
*rightPoints++ = rPts[0];
|
|
*rightTypes++ = pathType;
|
|
rightCount++;
|
|
|
|
if(k == 2)
|
|
{
|
|
if(lCnt > 1)
|
|
{
|
|
*leftPoints++ = lPts[1];
|
|
*leftTypes++ = PathPointTypeLine;
|
|
leftCount++;
|
|
}
|
|
else if(lCnt < 0)
|
|
{
|
|
lCnt = - lCnt;
|
|
ASSERT(lCnt % 3 == 1);
|
|
GpMemcpy(leftPoints, &lPts[1], (lCnt - 1)*sizeof(GpPointF));
|
|
GpMemset(leftTypes, pathType, lCnt - 1);
|
|
leftPoints += lCnt - 1;
|
|
leftTypes += lCnt - 1;
|
|
leftCount += lCnt - 1;
|
|
}
|
|
|
|
if(rCnt > 1)
|
|
{
|
|
*rightPoints++ = rPts[1];
|
|
*rightTypes++ = PathPointTypeLine;
|
|
rightCount++;
|
|
}
|
|
else if(rCnt < 0)
|
|
{
|
|
rCnt = - rCnt;
|
|
ASSERT(rCnt % 3 == 1);
|
|
GpMemcpy(rightPoints, &rPts[1], (rCnt - 1)*sizeof(GpPointF));
|
|
GpMemset(rightTypes, pathType, rCnt - 1);
|
|
rightPoints += rCnt - 1;
|
|
rightTypes += rCnt - 1;
|
|
rightCount += rCnt - 1;
|
|
}
|
|
}
|
|
|
|
grad1 = grad2;
|
|
norm1 = norm2;
|
|
*lastPt = nextPt;
|
|
|
|
grad++;
|
|
norm++;
|
|
dataPoints++;
|
|
}
|
|
}
|
|
|
|
*addedLeftCount = leftCount;
|
|
*addedRightCount = rightCount;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* Add the widened points for each path type.
|
|
*
|
|
* For the arguments, See comments for widenFirstPoints
|
|
*
|
|
\**************************************************************************/
|
|
|
|
GpStatus
|
|
GpPathWidener::WidenEachPathType(
|
|
BYTE pathType,
|
|
REAL leftWidth,
|
|
REAL rightWidth,
|
|
GpLineJoin lineJoin,
|
|
REAL miterLimit2,
|
|
GpPointF* leftPoints,
|
|
BYTE* leftTypes,
|
|
INT* addedLeftCount,
|
|
GpPointF* rightPoints,
|
|
BYTE* rightTypes,
|
|
INT* addedRightCount,
|
|
const GpPointF* grad,
|
|
const GpPointF* norm,
|
|
const GpPointF* dataPoints,
|
|
INT dataCount,
|
|
GpPointF* lastPt,
|
|
const REAL* lastInsets,
|
|
INT flag
|
|
)
|
|
{
|
|
GpStatus status = GenericError;
|
|
|
|
switch(pathType)
|
|
{
|
|
case PathPointTypeLine:
|
|
status = WidenLinePoints(
|
|
leftWidth,
|
|
rightWidth,
|
|
lineJoin,
|
|
miterLimit2,
|
|
leftPoints,
|
|
leftTypes,
|
|
addedLeftCount,
|
|
rightPoints,
|
|
rightTypes,
|
|
addedRightCount,
|
|
grad,
|
|
norm,
|
|
dataPoints,
|
|
dataCount,
|
|
lastPt,
|
|
lastInsets,
|
|
flag);
|
|
break;
|
|
|
|
case PathPointTypeBezier:
|
|
status = WidenBezierPoints(
|
|
leftWidth,
|
|
rightWidth,
|
|
lineJoin,
|
|
miterLimit2,
|
|
leftPoints,
|
|
leftTypes,
|
|
addedLeftCount,
|
|
rightPoints,
|
|
rightTypes,
|
|
addedRightCount,
|
|
grad,
|
|
norm,
|
|
dataPoints,
|
|
dataCount,
|
|
lastPt,
|
|
lastInsets,
|
|
flag);
|
|
break;
|
|
|
|
default:
|
|
WARNING(("Trying to widen undefined types."));
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
REAL
|
|
getCapDelta(
|
|
const DpPen* pen
|
|
)
|
|
{
|
|
GpLineCap startCap = pen->StartCap;
|
|
GpLineCap endCap = pen->EndCap;
|
|
GpLineCap dashCap = pen->DashCap;
|
|
|
|
REAL delta = 0, delta1;
|
|
|
|
if(!(startCap & LineCapAnchorMask))
|
|
delta1 = 0.5f;
|
|
else
|
|
delta1 = 3.0f; // We must adjust later.
|
|
|
|
if(delta < delta1)
|
|
delta = delta1;
|
|
|
|
if(!(endCap & LineCapAnchorMask))
|
|
delta1 = 0.5f;
|
|
else
|
|
delta1 = 3.0f; // We must adjust later.
|
|
|
|
if(delta < delta1)
|
|
delta = delta1;
|
|
|
|
if(!(dashCap & LineCapAnchorMask))
|
|
delta1 = 0.5f;
|
|
else
|
|
delta1 = 3.0f; // We must adjust later.
|
|
|
|
if(delta < delta1)
|
|
delta = delta1;
|
|
|
|
//!!! Add cutom line case.
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* This calculates the extra width due to pen.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* None
|
|
*
|
|
* Return Value:
|
|
*
|
|
* The extra width.
|
|
*
|
|
* 02/29/00 ikkof
|
|
* Created it
|
|
*
|
|
\**************************************************************************/
|
|
|
|
REAL
|
|
GpPathWidener::GetPenDelta()
|
|
{
|
|
const GpPointF* centerPoints = CenterPoints.GetDataBuffer();
|
|
const BYTE* centerTypes = CenterTypes.GetDataBuffer();
|
|
INT centerCount = CenterPoints.GetCount();
|
|
|
|
INT startIndex, endIndex;
|
|
BOOL isClosed;
|
|
GpStatus status = Ok;
|
|
|
|
REAL scale;
|
|
|
|
switch(Pen->PenAlignment)
|
|
{
|
|
case PenAlignmentCenter:
|
|
default:
|
|
scale = 0.5f;
|
|
break;
|
|
}
|
|
|
|
REAL capDelta = getCapDelta(Pen);
|
|
|
|
REAL joinDelta = 1.0f;
|
|
|
|
if(Pen->Join == LineJoinMiter ||
|
|
Pen->Join == LineJoinMiterClipped)
|
|
{
|
|
while(Iterator.NextSubpath(&startIndex, &endIndex, &isClosed)
|
|
&& status == Ok)
|
|
{
|
|
status = CalculateGradients(startIndex, endIndex);
|
|
|
|
if(status == Ok)
|
|
{
|
|
REAL delta = GetSubpathPenMiterDelta(isClosed);
|
|
if(delta > joinDelta)
|
|
joinDelta = delta;
|
|
}
|
|
}
|
|
|
|
if(status != Ok)
|
|
{
|
|
// We have to use the possible maximum for miter join.
|
|
// Usually this is an over-estimate since the most path
|
|
// don't have very sharp edges which correspond to miter limit.
|
|
|
|
joinDelta = Pen->MiterLimit;
|
|
}
|
|
}
|
|
|
|
REAL penDelta = max(joinDelta, capDelta)*scale;
|
|
|
|
if(NeedsToTransform)
|
|
{
|
|
// This is already in device unit.
|
|
|
|
penDelta *= StrokeWidth;
|
|
}
|
|
else
|
|
{
|
|
// Convert the width to the device unit.
|
|
|
|
penDelta *= MaximumWidth;
|
|
}
|
|
if(penDelta < 1)
|
|
penDelta = 1;
|
|
|
|
return penDelta;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Function Description:
|
|
*
|
|
* This calculates the extra within a subpath due to a pen.
|
|
* This is called by GetPenDelta().
|
|
*
|
|
* Arguments:
|
|
*
|
|
* None
|
|
*
|
|
* Return Value:
|
|
*
|
|
* The extra width.
|
|
*
|
|
* 02/29/00 ikkof
|
|
* Created it
|
|
*
|
|
\**************************************************************************/
|
|
|
|
REAL
|
|
GpPathWidener::GetSubpathPenMiterDelta(
|
|
BOOL isClosed
|
|
)
|
|
{
|
|
INT count = Gradients.GetCount();
|
|
|
|
GpPointF* grad0 = Gradients.GetDataBuffer();
|
|
|
|
INT imin, imax;
|
|
if(isClosed)
|
|
{
|
|
imin = 0;
|
|
imax = count - 1;
|
|
}
|
|
else
|
|
{
|
|
imin = 1;
|
|
imax = count - 2;
|
|
}
|
|
|
|
GpPointF* grad = grad0 + imin;
|
|
GpPointF prevGrad = *grad++;
|
|
GpPointF nextGrad;
|
|
|
|
REAL dot = 0;
|
|
|
|
for(INT i = imin; i < imax; i++)
|
|
{
|
|
nextGrad = *grad++;
|
|
REAL dot1 = prevGrad.X*nextGrad.X + prevGrad.Y*nextGrad.Y;
|
|
prevGrad = nextGrad;
|
|
|
|
if(dot1 < dot)
|
|
dot = dot1;
|
|
}
|
|
|
|
REAL cosHalfTheta = (dot + 1.0f)*0.5f;
|
|
REAL miterDelta = Pen->MiterLimit;
|
|
|
|
// If the miterDelta is smaller than the miter limit, calculate it.
|
|
|
|
if(cosHalfTheta > 0 && cosHalfTheta*miterDelta*miterDelta > 1)
|
|
{
|
|
cosHalfTheta = REALSQRT(cosHalfTheta);
|
|
miterDelta = 1.0f/cosHalfTheta;
|
|
}
|
|
|
|
return miterDelta;
|
|
}
|