705 lines
19 KiB
C
705 lines
19 KiB
C
/*
|
|
* Graphics paths (BeginPath, EndPath etc.)
|
|
*
|
|
* Copyright 1997 Martin Boehme
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <malloc.h>
|
|
|
|
#include "windows.h"
|
|
#include "winerror.h"
|
|
|
|
#include "dc.h"
|
|
#include "debug.h"
|
|
#include "path.h"
|
|
|
|
/* Notes on the implementation
|
|
*
|
|
* The implementation is based on dynamically resizable arrays of points and
|
|
* flags. I dithered for a bit before deciding on this implementation, and
|
|
* I had even done a bit of work on a linked list version before switching
|
|
* to arrays. It's a bit of a tradeoff. When you use linked lists, the
|
|
* implementation of FlattenPath is easier, because you can rip the
|
|
* PT_BEZIERTO entries out of the middle of the list and link the
|
|
* corresponding PT_LINETO entries in. However, when you use arrays,
|
|
* PathToRegion becomes easier, since you can essentially just pass your array
|
|
* of points to CreatePolyPolygonRgn. Also, if I'd used linked lists, I would
|
|
* have had the extra effort of creating a chunk-based allocation scheme
|
|
* in order to use memory effectively. That's why I finally decided to use
|
|
* arrays. Note by the way that the array based implementation has the same
|
|
* linear time complexity that linked lists would have since the arrays grow
|
|
* exponentially.
|
|
*
|
|
* The points are stored in the path in device coordinates. This is
|
|
* consistent with the way Windows does things (for instance, see the Win32
|
|
* SDK documentation for GetPath).
|
|
*
|
|
* The word "stroke" appears in several places (e.g. in the flag
|
|
* GdiPath.newStroke). A stroke consists of a PT_MOVETO followed by one or
|
|
* more PT_LINETOs or PT_BEZIERTOs, up to, but not including, the next
|
|
* PT_MOVETO. Note that this is not the same as the definition of a figure;
|
|
* a figure can contain several strokes.
|
|
*
|
|
* I modified the drawing functions (MoveTo, LineTo etc.) to test whether
|
|
* the path is open and to call the corresponding function in path.c if this
|
|
* is the case. A more elegant approach would be to modify the function
|
|
* pointers in the DC_FUNCTIONS structure; however, this would be a lot more
|
|
* complex. Also, the performance degradation caused by my approach in the
|
|
* case where no path is open is so small that it cannot be measured.
|
|
*
|
|
* Martin Boehme
|
|
*/
|
|
|
|
/* FIXME: A lot of stuff isn't implemented yet. There is much more to come. */
|
|
|
|
#define NUM_ENTRIES_INITIAL 16 /* Initial size of points / flags arrays */
|
|
#define GROW_FACTOR_NUMER 2 /* Numerator of grow factor for the array */
|
|
#define GROW_FACTOR_DENOM 1 /* Denominator of grow factor */
|
|
|
|
|
|
static BOOL32 PATH_PathToRegion(const GdiPath *pPath, INT32 nPolyFillMode,
|
|
HRGN32 *pHrgn);
|
|
static void PATH_EmptyPath(GdiPath *pPath);
|
|
static BOOL32 PATH_AddEntry(GdiPath *pPath, POINT32 point, BYTE flags);
|
|
static BOOL32 PATH_ReserveEntries(GdiPath *pPath, INT32 numEntries);
|
|
static BOOL32 PATH_GetPathFromHDC(HDC32 hdc, GdiPath **ppPath);
|
|
|
|
/***********************************************************************
|
|
* BeginPath32 (GDI32.9)
|
|
*/
|
|
BOOL32 WINAPI BeginPath32(HDC32 hdc)
|
|
{
|
|
GdiPath *pPath;
|
|
|
|
/* Get pointer to path */
|
|
if(!PATH_GetPathFromHDC(hdc, &pPath))
|
|
{
|
|
SetLastError(ERROR_INVALID_HANDLE);
|
|
return FALSE;
|
|
}
|
|
|
|
/* If path is already open, do nothing */
|
|
if(pPath->state==PATH_Open)
|
|
return TRUE;
|
|
|
|
/* Make sure that path is empty */
|
|
PATH_EmptyPath(pPath);
|
|
|
|
/* Initialize variables for new path */
|
|
pPath->newStroke=TRUE;
|
|
pPath->state=PATH_Open;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* EndPath32 (GDI32.78)
|
|
*/
|
|
BOOL32 WINAPI EndPath32(HDC32 hdc)
|
|
{
|
|
GdiPath *pPath;
|
|
|
|
/* Get pointer to path */
|
|
if(!PATH_GetPathFromHDC(hdc, &pPath))
|
|
{
|
|
SetLastError(ERROR_INVALID_HANDLE);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Check that path is currently being constructed */
|
|
if(pPath->state!=PATH_Open)
|
|
{
|
|
SetLastError(ERROR_CAN_NOT_COMPLETE);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Set flag to indicate that path is finished */
|
|
pPath->state=PATH_Closed;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AbortPath32 (GDI32.1)
|
|
*/
|
|
BOOL32 WINAPI AbortPath32(HDC32 hdc)
|
|
/* FIXME: Check that SetLastError is being called correctly */
|
|
{
|
|
GdiPath *pPath;
|
|
|
|
/* Get pointer to path */
|
|
if(!PATH_GetPathFromHDC(hdc, &pPath))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Remove all entries from the path */
|
|
PATH_EmptyPath(pPath);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CloseFigure32 (GDI32.16)
|
|
*/
|
|
BOOL32 WINAPI CloseFigure32(HDC32 hdc)
|
|
/* FIXME: Check that SetLastError is being called correctly */
|
|
{
|
|
GdiPath *pPath;
|
|
|
|
/* Get pointer to path */
|
|
if(!PATH_GetPathFromHDC(hdc, &pPath))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Check that path is open */
|
|
if(pPath->state!=PATH_Open)
|
|
{
|
|
SetLastError(ERROR_CAN_NOT_COMPLETE);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Set PT_CLOSEFIGURE on the last entry and start a new stroke */
|
|
if(pPath->numEntriesUsed)
|
|
{
|
|
pPath->pFlags[pPath->numEntriesUsed-1]|=PT_CLOSEFIGURE;
|
|
pPath->newStroke=TRUE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetPath32 (GDI32.210)
|
|
*/
|
|
INT32 WINAPI GetPath32(HDC32 hdc, LPPOINT32 pPoints, LPBYTE pTypes,
|
|
INT32 nSize)
|
|
{
|
|
GdiPath *pPath;
|
|
BOOL32 temp_flag;
|
|
|
|
/* Get pointer to path */
|
|
if(!PATH_GetPathFromHDC(hdc, &pPath))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return -1;
|
|
}
|
|
|
|
/* Check that path is closed */
|
|
if(pPath->state!=PATH_Closed)
|
|
{
|
|
SetLastError(ERROR_CAN_NOT_COMPLETE);
|
|
return -1;
|
|
}
|
|
|
|
if(nSize==0)
|
|
return pPath->numEntriesUsed;
|
|
else if(nSize<pPath->numEntriesUsed)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
memcpy(pPoints, pPath->pPoints, sizeof(POINT32)*pPath->numEntriesUsed);
|
|
memcpy(pTypes, pPath->pFlags, sizeof(BYTE)*pPath->numEntriesUsed);
|
|
|
|
/* Convert the points to logical coordinates */
|
|
temp_flag=DPtoLP32(hdc, pPoints, pPath->numEntriesUsed);
|
|
|
|
/* Since hdc is valid, conversion should never fail */
|
|
assert(temp_flag);
|
|
|
|
return pPath->numEntriesUsed;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* PathToRegion32 (GDI32.261)
|
|
*/
|
|
HRGN32 WINAPI PathToRegion32(HDC32 hdc)
|
|
/* FIXME: Check that SetLastError is being called correctly */
|
|
/* The documentation does not state this explicitly, but a test under Windows
|
|
* shows that the region which is returned should be in device coordinates.
|
|
*/
|
|
{
|
|
GdiPath *pPath;
|
|
HRGN32 hrgnRval;
|
|
|
|
/* Get pointer to path */
|
|
if(!PATH_GetPathFromHDC(hdc, &pPath))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return 0;
|
|
}
|
|
|
|
/* Check that path is closed */
|
|
if(pPath->state!=PATH_Closed)
|
|
{
|
|
SetLastError(ERROR_CAN_NOT_COMPLETE);
|
|
return 0;
|
|
}
|
|
|
|
/* FIXME: Should we empty the path even if conversion failed? */
|
|
if(PATH_PathToRegion(pPath, GetPolyFillMode32(hdc), &hrgnRval))
|
|
PATH_EmptyPath(pPath);
|
|
else
|
|
hrgnRval=0;
|
|
|
|
return hrgnRval;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* FillPath32 (GDI32.100)
|
|
*/
|
|
BOOL32 WINAPI FillPath32(HDC32 hdc)
|
|
/* FIXME: Check that SetLastError is being called correctly */
|
|
{
|
|
GdiPath *pPath;
|
|
INT32 mapMode;
|
|
POINT32 ptViewportExt, ptViewportOrg, ptWindowExt, ptWindowOrg;
|
|
HRGN32 hrgn;
|
|
|
|
/* Get pointer to path */
|
|
if(!PATH_GetPathFromHDC(hdc, &pPath))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Check that path is closed */
|
|
if(pPath->state!=PATH_Closed)
|
|
{
|
|
SetLastError(ERROR_CAN_NOT_COMPLETE);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Construct a region from the path and fill it */
|
|
if(PATH_PathToRegion(pPath, GetPolyFillMode32(hdc), &hrgn))
|
|
{
|
|
/* Since PaintRgn interprets the region as being in logical coordinates
|
|
* but the points we store for the path are already in device
|
|
* coordinates, we have to set the mapping mode to MM_TEXT temporarily.
|
|
*/
|
|
|
|
/* Save the information about the old mapping mode */
|
|
mapMode=GetMapMode32(hdc);
|
|
GetViewportExtEx32(hdc, &ptViewportExt);
|
|
GetViewportOrgEx32(hdc, &ptViewportOrg);
|
|
GetWindowExtEx32(hdc, &ptWindowExt);
|
|
GetWindowOrgEx32(hdc, &ptWindowOrg);
|
|
|
|
/* FIXME: Once world transforms become available, we will have to do
|
|
* a GetWorldTransform, too (along with a SetWorldTransform later on).
|
|
* Moral: Perhaps I should have used SaveDC right away. The reason why
|
|
* I didn't is that I wanted to avoid the overhead of a full SaveDC
|
|
* (especially since SaveDC now saves the current path as well).
|
|
*/
|
|
|
|
/* Set MM_TEXT */
|
|
SetMapMode32(hdc, MM_TEXT);
|
|
|
|
/* Paint the region */
|
|
PaintRgn32(hdc, hrgn);
|
|
|
|
/* Restore the old mapping mode */
|
|
SetMapMode32(hdc, mapMode);
|
|
SetViewportExtEx32(hdc, ptViewportExt.x, ptViewportExt.y, NULL);
|
|
SetViewportOrgEx32(hdc, ptViewportOrg.x, ptViewportOrg.y, NULL);
|
|
SetWindowExtEx32(hdc, ptWindowExt.x, ptWindowExt.y, NULL);
|
|
SetWindowOrgEx32(hdc, ptWindowOrg.x, ptWindowOrg.y, NULL);
|
|
|
|
/* Empty the path */
|
|
PATH_EmptyPath(pPath);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
/* FIXME: Should the path be emptied even if conversion failed? */
|
|
/* PATH_EmptyPath(pPath); */
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SelectClipPath32 (GDI32.296)
|
|
*/
|
|
BOOL32 WINAPI SelectClipPath32(HDC32 hdc, int iMode)
|
|
/* FIXME: Check that SetLastError is being called correctly */
|
|
{
|
|
GdiPath *pPath;
|
|
HRGN32 hrgnPath, hrgnClip;
|
|
BOOL32 success = FALSE;
|
|
|
|
/* Get pointer to path */
|
|
if(!PATH_GetPathFromHDC(hdc, &pPath))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Check that path is closed */
|
|
if(pPath->state!=PATH_Closed)
|
|
{
|
|
SetLastError(ERROR_CAN_NOT_COMPLETE);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Construct a region from the path */
|
|
if(PATH_PathToRegion(pPath, GetPolyFillMode32(hdc), &hrgnPath))
|
|
{
|
|
hrgnClip=CreateRectRgn32(0, 0, 0, 0);
|
|
if(hrgnClip!=NULL)
|
|
{
|
|
success=(GetClipRgn32(hdc, hrgnClip)!=-1) &&
|
|
(CombineRgn32(hrgnClip, hrgnClip, hrgnPath, iMode)!=ERROR) &&
|
|
(SelectClipRgn32(hdc, hrgnClip)!=ERROR);
|
|
DeleteObject32(hrgnClip);
|
|
}
|
|
|
|
DeleteObject32(hrgnPath);
|
|
|
|
/* Empty the path */
|
|
if(success)
|
|
PATH_EmptyPath(pPath);
|
|
/* FIXME: Should this function delete the path even if it failed? */
|
|
|
|
return success;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* Exported functions
|
|
*/
|
|
|
|
/* PATH_InitGdiPath
|
|
*
|
|
* Initializes the GdiPath structure.
|
|
*/
|
|
void PATH_InitGdiPath(GdiPath *pPath)
|
|
{
|
|
assert(pPath!=NULL);
|
|
|
|
pPath->state=PATH_Null;
|
|
pPath->pPoints=NULL;
|
|
pPath->pFlags=NULL;
|
|
pPath->numEntriesUsed=0;
|
|
pPath->numEntriesAllocated=0;
|
|
}
|
|
|
|
/* PATH_DestroyGdiPath
|
|
*
|
|
* Destroys a GdiPath structure (frees the memory in the arrays).
|
|
*/
|
|
void PATH_DestroyGdiPath(GdiPath *pPath)
|
|
{
|
|
assert(pPath!=NULL);
|
|
|
|
free(pPath->pPoints);
|
|
free(pPath->pFlags);
|
|
}
|
|
|
|
/* PATH_AssignGdiPath
|
|
*
|
|
* Copies the GdiPath structure "pPathSrc" to "pPathDest". A deep copy is
|
|
* performed, i.e. the contents of the pPoints and pFlags arrays are copied,
|
|
* not just the pointers. Since this means that the arrays in pPathDest may
|
|
* need to be resized, pPathDest should have been initialized using
|
|
* PATH_InitGdiPath (in C++, this function would be an assignment operator,
|
|
* not a copy constructor).
|
|
* Returns TRUE if successful, else FALSE.
|
|
*/
|
|
BOOL32 PATH_AssignGdiPath(GdiPath *pPathDest, const GdiPath *pPathSrc)
|
|
{
|
|
assert(pPathDest!=NULL && pPathSrc!=NULL);
|
|
|
|
/* Make sure destination arrays are big enough */
|
|
if(!PATH_ReserveEntries(pPathDest, pPathSrc->numEntriesUsed))
|
|
return FALSE;
|
|
|
|
/* Perform the copy operation */
|
|
memcpy(pPathDest->pPoints, pPathSrc->pPoints,
|
|
sizeof(POINT32)*pPathSrc->numEntriesUsed);
|
|
memcpy(pPathDest->pFlags, pPathSrc->pFlags,
|
|
sizeof(INT32)*pPathSrc->numEntriesUsed);
|
|
pPathDest->state=pPathSrc->state;
|
|
pPathDest->numEntriesUsed=pPathSrc->numEntriesUsed;
|
|
pPathDest->newStroke=pPathSrc->newStroke;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* PATH_MoveTo
|
|
*
|
|
* Should be called when a MoveTo is performed on a DC that has an
|
|
* open path. This starts a new stroke. Returns TRUE if successful, else
|
|
* FALSE.
|
|
*/
|
|
BOOL32 PATH_MoveTo(HDC32 hdc)
|
|
{
|
|
GdiPath *pPath;
|
|
|
|
/* Get pointer to path */
|
|
if(!PATH_GetPathFromHDC(hdc, &pPath))
|
|
return FALSE;
|
|
|
|
/* Check that path is open */
|
|
if(pPath->state!=PATH_Open)
|
|
/* FIXME: Do we have to call SetLastError? */
|
|
return FALSE;
|
|
|
|
/* Start a new stroke */
|
|
pPath->newStroke=TRUE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* PATH_LineTo
|
|
*
|
|
* Should be called when a LineTo is performed on a DC that has an
|
|
* open path. This adds a PT_LINETO entry to the path (and possibly
|
|
* a PT_MOVETO entry, if this is the first LineTo in a stroke).
|
|
* Returns TRUE if successful, else FALSE.
|
|
*/
|
|
BOOL32 PATH_LineTo(HDC32 hdc, INT32 x, INT32 y)
|
|
{
|
|
GdiPath *pPath;
|
|
POINT32 point, pointCurPos;
|
|
|
|
/* Get pointer to path */
|
|
if(!PATH_GetPathFromHDC(hdc, &pPath))
|
|
return FALSE;
|
|
|
|
/* Check that path is open */
|
|
if(pPath->state!=PATH_Open)
|
|
/* FIXME: Do we have to call SetLastError? */
|
|
return FALSE;
|
|
|
|
/* Convert point to device coordinates */
|
|
point.x=x;
|
|
point.y=y;
|
|
if(!LPtoDP32(hdc, &point, 1))
|
|
return FALSE;
|
|
|
|
/* Add a PT_MOVETO if necessary */
|
|
if(pPath->newStroke)
|
|
{
|
|
pPath->newStroke=FALSE;
|
|
if(!GetCurrentPositionEx32(hdc, &pointCurPos) ||
|
|
!LPtoDP32(hdc, &pointCurPos, 1))
|
|
return FALSE;
|
|
if(!PATH_AddEntry(pPath, pointCurPos, PT_MOVETO))
|
|
return FALSE;
|
|
}
|
|
|
|
/* Add a PT_LINETO entry */
|
|
return PATH_AddEntry(pPath, point, PT_LINETO);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* Internal functions
|
|
*/
|
|
|
|
/* PATH_PathToRegion
|
|
*
|
|
* Creates a region from the specified path using the specified polygon
|
|
* filling mode. The path is left unchanged. A handle to the region that
|
|
* was created is stored in *pHrgn. If successful, TRUE is returned; if an
|
|
* error occurs, SetLastError is called with the appropriate value and
|
|
* FALSE is returned.
|
|
*/
|
|
static BOOL32 PATH_PathToRegion(const GdiPath *pPath, INT32 nPolyFillMode,
|
|
HRGN32 *pHrgn)
|
|
{
|
|
int numStrokes, iStroke, i;
|
|
INT32 *pNumPointsInStroke;
|
|
HRGN32 hrgn;
|
|
|
|
assert(pPath!=NULL);
|
|
assert(pHrgn!=NULL);
|
|
|
|
/* FIXME: What happens when number of points is zero? */
|
|
|
|
/* First pass: Find out how many strokes there are in the path */
|
|
/* FIXME: We could eliminate this with some bookkeeping in GdiPath */
|
|
numStrokes=0;
|
|
for(i=0; i<pPath->numEntriesUsed; i++)
|
|
if((pPath->pFlags[i] & ~PT_CLOSEFIGURE) == PT_MOVETO)
|
|
numStrokes++;
|
|
|
|
/* Allocate memory for number-of-points-in-stroke array */
|
|
pNumPointsInStroke=(int *)malloc(sizeof(int)*numStrokes);
|
|
if(!pNumPointsInStroke)
|
|
{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Second pass: remember number of points in each polygon */
|
|
iStroke=-1; /* Will get incremented to 0 at beginning of first stroke */
|
|
for(i=0; i<pPath->numEntriesUsed; i++)
|
|
{
|
|
/* Is this the beginning of a new stroke? */
|
|
if((pPath->pFlags[i] & ~PT_CLOSEFIGURE) == PT_MOVETO)
|
|
{
|
|
iStroke++;
|
|
pNumPointsInStroke[iStroke]=0;
|
|
}
|
|
|
|
pNumPointsInStroke[iStroke]++;
|
|
}
|
|
|
|
/* Create a region from the strokes */
|
|
hrgn=CreatePolyPolygonRgn32(pPath->pPoints, pNumPointsInStroke,
|
|
numStrokes, nPolyFillMode);
|
|
if(hrgn==NULL)
|
|
{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Free memory for number-of-points-in-stroke array */
|
|
free(pNumPointsInStroke);
|
|
|
|
/* Success! */
|
|
*pHrgn=hrgn;
|
|
return TRUE;
|
|
}
|
|
|
|
/* PATH_EmptyPath
|
|
*
|
|
* Removes all entries from the path and sets the path state to PATH_Null.
|
|
*/
|
|
static void PATH_EmptyPath(GdiPath *pPath)
|
|
{
|
|
assert(pPath!=NULL);
|
|
|
|
pPath->state=PATH_Null;
|
|
pPath->numEntriesUsed=0;
|
|
}
|
|
|
|
/* PATH_AddEntry
|
|
*
|
|
* Adds an entry to the path. For "flags", pass either PT_MOVETO, PT_LINETO
|
|
* or PT_BEZIERTO, optionally ORed with PT_CLOSEFIGURE. Returns TRUE if
|
|
* successful, FALSE otherwise (e.g. if not enough memory was available).
|
|
*/
|
|
BOOL32 PATH_AddEntry(GdiPath *pPath, POINT32 point, BYTE flags)
|
|
{
|
|
assert(pPath!=NULL);
|
|
|
|
/* Check that path is open */
|
|
if(pPath->state!=PATH_Open)
|
|
return FALSE;
|
|
|
|
/* Reserve enough memory for an extra path entry */
|
|
if(!PATH_ReserveEntries(pPath, pPath->numEntriesUsed+1))
|
|
return FALSE;
|
|
|
|
/* Store information in path entry */
|
|
pPath->pPoints[pPath->numEntriesUsed]=point;
|
|
pPath->pFlags[pPath->numEntriesUsed]=flags;
|
|
|
|
/* Increment entry count */
|
|
pPath->numEntriesUsed++;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* PATH_ReserveEntries
|
|
*
|
|
* Ensures that at least "numEntries" entries (for points and flags) have
|
|
* been allocated; allocates larger arrays and copies the existing entries
|
|
* to those arrays, if necessary. Returns TRUE if successful, else FALSE.
|
|
*/
|
|
static BOOL32 PATH_ReserveEntries(GdiPath *pPath, INT32 numEntries)
|
|
{
|
|
INT32 numEntriesToAllocate;
|
|
POINT32 *pPointsNew;
|
|
BYTE *pFlagsNew;
|
|
|
|
assert(pPath!=NULL);
|
|
assert(numEntries>=0);
|
|
|
|
/* Do we have to allocate more memory? */
|
|
if(numEntries > pPath->numEntriesAllocated)
|
|
{
|
|
/* Find number of entries to allocate. We let the size of the array
|
|
* grow exponentially, since that will guarantee linear time
|
|
* complexity. */
|
|
if(pPath->numEntriesAllocated)
|
|
{
|
|
numEntriesToAllocate=pPath->numEntriesAllocated;
|
|
while(numEntriesToAllocate<numEntries)
|
|
numEntriesToAllocate=numEntriesToAllocate*GROW_FACTOR_NUMER/
|
|
GROW_FACTOR_DENOM;
|
|
}
|
|
else
|
|
numEntriesToAllocate=NUM_ENTRIES_INITIAL;
|
|
|
|
/* Allocate new arrays */
|
|
pPointsNew=(POINT32 *)malloc(numEntriesToAllocate * sizeof(POINT32));
|
|
if(!pPointsNew)
|
|
return FALSE;
|
|
pFlagsNew=(BYTE *)malloc(numEntriesToAllocate * sizeof(BYTE));
|
|
if(!pFlagsNew)
|
|
{
|
|
free(pPointsNew);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Copy old arrays to new arrays and discard old arrays */
|
|
if(pPath->pPoints)
|
|
{
|
|
assert(pPath->pFlags);
|
|
|
|
memcpy(pPointsNew, pPath->pPoints,
|
|
sizeof(POINT32)*pPath->numEntriesUsed);
|
|
memcpy(pFlagsNew, pPath->pFlags,
|
|
sizeof(BYTE)*pPath->numEntriesUsed);
|
|
|
|
free(pPath->pPoints);
|
|
free(pPath->pFlags);
|
|
}
|
|
pPath->pPoints=pPointsNew;
|
|
pPath->pFlags=pFlagsNew;
|
|
pPath->numEntriesAllocated=numEntriesToAllocate;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* PATH_GetPathFromHDC
|
|
*
|
|
* Retrieves a pointer to the GdiPath structure contained in an HDC and
|
|
* places it in *ppPath. TRUE is returned if successful, FALSE otherwise.
|
|
*/
|
|
static BOOL32 PATH_GetPathFromHDC(HDC32 hdc, GdiPath **ppPath)
|
|
{
|
|
DC *pDC;
|
|
|
|
pDC=DC_GetDCPtr(hdc);
|
|
if(pDC)
|
|
{
|
|
*ppPath=&pDC->w.path;
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|