/***********************************************************************
* PSDRV_RoundRect
*/
BOOL PSDRV_RoundRect( PHYSDEV dev, INT left, INT top, INT right,
INT bottom, INT ell_width, INT ell_height )
{
RECT rect[2];
rect[0].left = left;
rect[0].top = top;
rect[0].right = right;
rect[0].bottom = bottom;
rect[1].left = 0;
rect[1].top = 0;
rect[1].right = ell_width;
rect[1].bottom = ell_height;
LPtoDP( dev->hdc, (POINT *)rect, 4 );
left = rect[0].left;
top = rect[0].top;
right = rect[0].right;
bottom = rect[0].bottom;
if (left > right) { INT tmp = left; left = right; right = tmp; }
if (top > bottom) { INT tmp = top; top = bottom; bottom = tmp; }
ell_width = rect[1].right - rect[1].left;
ell_height = rect[1].bottom - rect[1].top;
if (ell_width > right - left) ell_width = right - left;
if (ell_height > bottom - top) ell_height = bottom - top;
PSDRV_WriteSpool(dev, "%RoundRect\n",11);
PSDRV_SetPen(dev);
PSDRV_SetClip(dev);
PSDRV_WriteMoveTo( dev, left, top + ell_height/2 );
PSDRV_WriteArc( dev, left + ell_width/2, top + ell_height/2, ell_width,
ell_height, 90.0, 180.0);
PSDRV_WriteLineTo( dev, right - ell_width/2, top );
PSDRV_WriteArc( dev, right - ell_width/2, top + ell_height/2, ell_width,
ell_height, 0.0, 90.0);
PSDRV_WriteLineTo( dev, right, bottom - ell_height/2 );
PSDRV_WriteArc( dev, right - ell_width/2, bottom - ell_height/2, ell_width,
ell_height, -90.0, 0.0);
PSDRV_WriteLineTo( dev, right - ell_width/2, bottom);
PSDRV_WriteArc( dev, left + ell_width/2, bottom - ell_height/2, ell_width,
ell_height, 180.0, -90.0);
PSDRV_WriteClosePath( dev );
PSDRV_Brush(dev,0);
PSDRV_DrawLine(dev);
PSDRV_ResetClip(dev);
return TRUE;
}
/***********************************************************************
* PSDRV_PolyPolyline
*/
BOOL PSDRV_PolyPolyline( PHYSDEV dev, const POINT* pts, const DWORD* counts, DWORD polylines )
{
DWORD polyline, line, total;
POINT *dev_pts, *pt;
TRACE("\n");
for (polyline = total = 0; polyline < polylines; polyline++) total += counts[polyline];
if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, total * sizeof(*dev_pts) ))) return FALSE;
memcpy( dev_pts, pts, total * sizeof(*dev_pts) );
LPtoDP( dev->hdc, dev_pts, total );
pt = dev_pts;
PSDRV_WriteSpool(dev, "%PolyPolyline\n",14);
PSDRV_SetPen(dev);
PSDRV_SetClip(dev);
for(polyline = 0; polyline < polylines; polyline++) {
PSDRV_WriteMoveTo(dev, pt->x, pt->y);
pt++;
for(line = 1; line < counts[polyline]; line++, pt++)
PSDRV_WriteLineTo(dev, pt->x, pt->y);
}
HeapFree( GetProcessHeap(), 0, dev_pts );
PSDRV_DrawLine(dev);
PSDRV_ResetClip(dev);
return TRUE;
}
static BOOL paint_path( PHYSDEV dev, BOOL stroke, BOOL fill )
{
POINT *points;
BYTE *types;
BOOL ret = FALSE;
int i, size = GetPath( dev->hdc, NULL, NULL, 0 );
if (size == -1) return FALSE;
if (!size) return TRUE;
points = HeapAlloc( GetProcessHeap(), 0, size * sizeof(*points) );
types = HeapAlloc( GetProcessHeap(), 0, size * sizeof(*types) );
if (!points || !types) goto done;
if (GetPath( dev->hdc, points, types, size ) == -1) goto done;
if (stroke) PSDRV_SetPen(dev);
PSDRV_SetClip(dev);
for (i = 0; i < size; i++)
{
switch (types[i])
{
case PT_MOVETO:
PSDRV_WriteMoveTo( dev, points[i].x, points[i].y );
break;
case PT_LINETO:
case PT_LINETO | PT_CLOSEFIGURE:
PSDRV_WriteLineTo( dev, points[i].x, points[i].y );
if (types[i] & PT_CLOSEFIGURE) PSDRV_WriteClosePath( dev );
break;
case PT_BEZIERTO:
case PT_BEZIERTO | PT_CLOSEFIGURE:
PSDRV_WriteCurveTo( dev, points + i );
if (types[i] & PT_CLOSEFIGURE) PSDRV_WriteClosePath( dev );
i += 2;
break;
}
}
if (fill) PSDRV_Brush( dev, GetPolyFillMode(dev->hdc) == ALTERNATE );
if (stroke) PSDRV_DrawLine(dev);
else PSDRV_WriteNewPath(dev);
PSDRV_ResetClip(dev);
done:
HeapFree( GetProcessHeap(), 0, points );
HeapFree( GetProcessHeap(), 0, types );
return ret;
}
/***********************************************************************
* PSDRV_LineTo
*/
BOOL PSDRV_LineTo(PHYSDEV dev, INT x, INT y)
{
POINT pt[2];
TRACE("%d %d\n", x, y);
GetCurrentPositionEx( dev->hdc, pt );
pt[1].x = x;
pt[1].y = y;
LPtoDP( dev->hdc, pt, 2 );
PSDRV_SetPen(dev);
PSDRV_SetClip(dev);
PSDRV_WriteMoveTo(dev, pt[0].x, pt[0].y );
PSDRV_WriteLineTo(dev, pt[1].x, pt[1].y );
PSDRV_DrawLine(dev);
PSDRV_ResetClip(dev);
return TRUE;
}
/***********************************************************************
* PSDRV_PolyPolygon
*/
BOOL PSDRV_PolyPolygon( PHYSDEV dev, const POINT* pts, const INT* counts, UINT polygons )
{
DWORD polygon, total;
INT line;
POINT *dev_pts, *pt;
TRACE("\n");
for (polygon = total = 0; polygon < polygons; polygon++) total += counts[polygon];
if (!(dev_pts = HeapAlloc( GetProcessHeap(), 0, total * sizeof(*dev_pts) ))) return FALSE;
memcpy( dev_pts, pts, total * sizeof(*dev_pts) );
LPtoDP( dev->hdc, dev_pts, total );
pt = dev_pts;
PSDRV_WriteSpool(dev, "%PolyPolygon\n",13);
PSDRV_SetPen(dev);
PSDRV_SetClip(dev);
for(polygon = 0; polygon < polygons; polygon++) {
PSDRV_WriteMoveTo(dev, pt->x, pt->y);
pt++;
for(line = 1; line < counts[polygon]; line++, pt++)
PSDRV_WriteLineTo(dev, pt->x, pt->y);
PSDRV_WriteClosePath(dev);
}
HeapFree( GetProcessHeap(), 0, dev_pts );
if(GetPolyFillMode( dev->hdc ) == ALTERNATE)
PSDRV_Brush(dev, 1);
else /* WINDING */
PSDRV_Brush(dev, 0);
PSDRV_DrawLine(dev);
PSDRV_ResetClip(dev);
return TRUE;
}