/* * GDI drawing functions. * * Copyright 1993, 1994 Alexandre Julliard * Copyright 1997 Bertho A. Stultiens * 1999 Huw D M Davies * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include "wine/port.h" #include <stdarg.h> #include <string.h> #include <stdlib.h> #include "windef.h" #include "winbase.h" #include "wingdi.h" #include "winerror.h" #include "gdi_private.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(gdi); /*********************************************************************** * LineTo (GDI32.@) */ BOOL WINAPI LineTo( HDC hdc, INT x, INT y ) { DC * dc = get_dc_ptr( hdc ); BOOL ret; if(!dc) return FALSE; update_dc( dc ); if(PATH_IsPathOpen(dc->path)) ret = PATH_LineTo(dc, x, y); else ret = dc->funcs->pLineTo && dc->funcs->pLineTo(dc->physDev,x,y); if(ret) { dc->CursPosX = x; dc->CursPosY = y; } release_dc_ptr( dc ); return ret; } /*********************************************************************** * MoveToEx (GDI32.@) */ BOOL WINAPI MoveToEx( HDC hdc, INT x, INT y, LPPOINT pt ) { BOOL ret = TRUE; DC * dc = get_dc_ptr( hdc ); if(!dc) return FALSE; if(pt) { pt->x = dc->CursPosX; pt->y = dc->CursPosY; } dc->CursPosX = x; dc->CursPosY = y; if(PATH_IsPathOpen(dc->path)) ret = PATH_MoveTo(dc); else if (dc->funcs->pMoveTo) ret = dc->funcs->pMoveTo(dc->physDev,x,y); release_dc_ptr( dc ); return ret; } /*********************************************************************** * Arc (GDI32.@) */ BOOL WINAPI Arc( HDC hdc, INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); if(PATH_IsPathOpen(dc->path)) ret = PATH_Arc(dc, left, top, right, bottom, xstart, ystart, xend, yend,0); else if (dc->funcs->pArc) ret = dc->funcs->pArc(dc->physDev,left,top,right,bottom,xstart,ystart,xend,yend); release_dc_ptr( dc ); } return ret; } /*********************************************************************** * ArcTo (GDI32.@) */ BOOL WINAPI ArcTo( HDC hdc, INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend ) { double width = fabs(right-left), height = fabs(bottom-top), xradius = width/2, yradius = height/2, xcenter = right > left ? left+xradius : right+xradius, ycenter = bottom > top ? top+yradius : bottom+yradius, angle; BOOL result; DC * dc = get_dc_ptr( hdc ); if(!dc) return FALSE; update_dc( dc ); if(PATH_IsPathOpen(dc->path)) result = PATH_Arc(dc,left,top,right,bottom,xstart,ystart,xend,yend,-1); else if(dc->funcs->pArcTo) result = dc->funcs->pArcTo( dc->physDev, left, top, right, bottom, xstart, ystart, xend, yend ); else /* We'll draw a line from the current position to the starting point of the arc, then draw the arc */ { angle = atan2(((ystart-ycenter)/height), ((xstart-xcenter)/width)); LineTo(hdc, GDI_ROUND(xcenter+(cos(angle)*xradius)), GDI_ROUND(ycenter+(sin(angle)*yradius))); result = Arc(hdc, left, top, right, bottom, xstart, ystart, xend, yend); } if (result) { angle = atan2(((yend-ycenter)/height), ((xend-xcenter)/width)); dc->CursPosX = GDI_ROUND(xcenter+(cos(angle)*xradius)); dc->CursPosY = GDI_ROUND(ycenter+(sin(angle)*yradius)); } release_dc_ptr( dc ); return result; } /*********************************************************************** * Pie (GDI32.@) */ BOOL WINAPI Pie( HDC hdc, INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (!dc) return FALSE; update_dc( dc ); if(PATH_IsPathOpen(dc->path)) ret = PATH_Arc(dc,left,top,right,bottom,xstart,ystart,xend,yend,2); else if(dc->funcs->pPie) ret = dc->funcs->pPie(dc->physDev,left,top,right,bottom,xstart,ystart,xend,yend); release_dc_ptr( dc ); return ret; } /*********************************************************************** * Chord (GDI32.@) */ BOOL WINAPI Chord( HDC hdc, INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (!dc) return FALSE; update_dc( dc ); if(PATH_IsPathOpen(dc->path)) ret = PATH_Arc(dc,left,top,right,bottom,xstart,ystart,xend,yend,1); else if(dc->funcs->pChord) ret = dc->funcs->pChord(dc->physDev,left,top,right,bottom,xstart,ystart,xend,yend); release_dc_ptr( dc ); return ret; } /*********************************************************************** * Ellipse (GDI32.@) */ BOOL WINAPI Ellipse( HDC hdc, INT left, INT top, INT right, INT bottom ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (!dc) return FALSE; update_dc( dc ); if(PATH_IsPathOpen(dc->path)) ret = PATH_Ellipse(dc,left,top,right,bottom); else if (dc->funcs->pEllipse) ret = dc->funcs->pEllipse(dc->physDev,left,top,right,bottom); release_dc_ptr( dc ); return ret; } /*********************************************************************** * Rectangle (GDI32.@) */ BOOL WINAPI Rectangle( HDC hdc, INT left, INT top, INT right, INT bottom ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); if(PATH_IsPathOpen(dc->path)) ret = PATH_Rectangle(dc, left, top, right, bottom); else if (dc->funcs->pRectangle) ret = dc->funcs->pRectangle(dc->physDev,left,top,right,bottom); release_dc_ptr( dc ); } return ret; } /*********************************************************************** * RoundRect (GDI32.@) */ BOOL WINAPI RoundRect( HDC hdc, INT left, INT top, INT right, INT bottom, INT ell_width, INT ell_height ) { BOOL ret = FALSE; DC *dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); if(PATH_IsPathOpen(dc->path)) ret = PATH_RoundRect(dc,left,top,right,bottom,ell_width,ell_height); else if (dc->funcs->pRoundRect) ret = dc->funcs->pRoundRect(dc->physDev,left,top,right,bottom,ell_width,ell_height); release_dc_ptr( dc ); } return ret; } /*********************************************************************** * SetPixel (GDI32.@) */ COLORREF WINAPI SetPixel( HDC hdc, INT x, INT y, COLORREF color ) { COLORREF ret = 0; DC * dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); if (dc->funcs->pSetPixel) ret = dc->funcs->pSetPixel(dc->physDev,x,y,color); release_dc_ptr( dc ); } return ret; } /*********************************************************************** * SetPixelV (GDI32.@) */ BOOL WINAPI SetPixelV( HDC hdc, INT x, INT y, COLORREF color ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); if (dc->funcs->pSetPixel) { dc->funcs->pSetPixel(dc->physDev,x,y,color); ret = TRUE; } release_dc_ptr( dc ); } return ret; } /*********************************************************************** * GetPixel (GDI32.@) */ COLORREF WINAPI GetPixel( HDC hdc, INT x, INT y ) { COLORREF ret = CLR_INVALID; DC * dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); /* FIXME: should this be in the graphics driver? */ if (PtVisible( hdc, x, y )) { if (dc->funcs->pGetPixel) ret = dc->funcs->pGetPixel(dc->physDev,x,y); } release_dc_ptr( dc ); } return ret; } /****************************************************************************** * ChoosePixelFormat [GDI32.@] * Matches a pixel format to given format * * PARAMS * hdc [I] Device context to search for best pixel match * ppfd [I] Pixel format for which a match is sought * * RETURNS * Success: Pixel format index closest to given format * Failure: 0 */ INT WINAPI ChoosePixelFormat( HDC hdc, const PIXELFORMATDESCRIPTOR* ppfd ) { INT ret = 0; DC * dc = get_dc_ptr( hdc ); TRACE("(%p,%p)\n",hdc,ppfd); if (!dc) return 0; if (!dc->funcs->pChoosePixelFormat) FIXME(" :stub\n"); else ret = dc->funcs->pChoosePixelFormat(dc->physDev,ppfd); release_dc_ptr( dc ); return ret; } /****************************************************************************** * SetPixelFormat [GDI32.@] * Sets pixel format of device context * * PARAMS * hdc [I] Device context to search for best pixel match * iPixelFormat [I] Pixel format index * ppfd [I] Pixel format for which a match is sought * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL WINAPI SetPixelFormat( HDC hdc, INT iPixelFormat, const PIXELFORMATDESCRIPTOR *ppfd) { INT bRet = FALSE; DC * dc = get_dc_ptr( hdc ); TRACE("(%p,%d,%p)\n",hdc,iPixelFormat,ppfd); if (!dc) return 0; update_dc( dc ); if (!dc->funcs->pSetPixelFormat) FIXME(" :stub\n"); else bRet = dc->funcs->pSetPixelFormat(dc->physDev,iPixelFormat,ppfd); release_dc_ptr( dc ); return bRet; } /****************************************************************************** * GetPixelFormat [GDI32.@] * Gets index of pixel format of DC * * PARAMETERS * hdc [I] Device context whose pixel format index is sought * * RETURNS * Success: Currently selected pixel format * Failure: 0 */ INT WINAPI GetPixelFormat( HDC hdc ) { INT ret = 0; DC * dc = get_dc_ptr( hdc ); TRACE("(%p)\n",hdc); if (!dc) return 0; update_dc( dc ); if (!dc->funcs->pGetPixelFormat) FIXME(" :stub\n"); else ret = dc->funcs->pGetPixelFormat(dc->physDev); release_dc_ptr( dc ); return ret; } /****************************************************************************** * DescribePixelFormat [GDI32.@] * Gets info about pixel format from DC * * PARAMS * hdc [I] Device context * iPixelFormat [I] Pixel format selector * nBytes [I] Size of buffer * ppfd [O] Pointer to structure to receive pixel format data * * RETURNS * Success: Maximum pixel format index of the device context * Failure: 0 */ INT WINAPI DescribePixelFormat( HDC hdc, INT iPixelFormat, UINT nBytes, LPPIXELFORMATDESCRIPTOR ppfd ) { INT ret = 0; DC * dc = get_dc_ptr( hdc ); TRACE("(%p,%d,%d,%p): stub\n",hdc,iPixelFormat,nBytes,ppfd); if (!dc) return 0; update_dc( dc ); if (!dc->funcs->pDescribePixelFormat) { FIXME(" :stub\n"); ppfd->nSize = nBytes; ppfd->nVersion = 1; ret = 3; } else ret = dc->funcs->pDescribePixelFormat(dc->physDev,iPixelFormat,nBytes,ppfd); release_dc_ptr( dc ); return ret; } /****************************************************************************** * SwapBuffers [GDI32.@] * Exchanges front and back buffers of window * * PARAMS * hdc [I] Device context whose buffers get swapped * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL WINAPI SwapBuffers( HDC hdc ) { INT bRet = FALSE; DC * dc = get_dc_ptr( hdc ); TRACE("(%p)\n",hdc); if (!dc) return TRUE; update_dc( dc ); if (!dc->funcs->pSwapBuffers) { FIXME(" :stub\n"); bRet = TRUE; } else bRet = dc->funcs->pSwapBuffers(dc->physDev); release_dc_ptr( dc ); return bRet; } /*********************************************************************** * PaintRgn (GDI32.@) */ BOOL WINAPI PaintRgn( HDC hdc, HRGN hrgn ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); if (dc->funcs->pPaintRgn) ret = dc->funcs->pPaintRgn(dc->physDev,hrgn); release_dc_ptr( dc ); } return ret; } /*********************************************************************** * FillRgn (GDI32.@) */ BOOL WINAPI FillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush ) { BOOL retval = FALSE; HBRUSH prevBrush; DC * dc = get_dc_ptr( hdc ); if (!dc) return FALSE; if(dc->funcs->pFillRgn) { update_dc( dc ); retval = dc->funcs->pFillRgn(dc->physDev, hrgn, hbrush); } else if ((prevBrush = SelectObject( hdc, hbrush ))) { retval = PaintRgn( hdc, hrgn ); SelectObject( hdc, prevBrush ); } release_dc_ptr( dc ); return retval; } /*********************************************************************** * FrameRgn (GDI32.@) */ BOOL WINAPI FrameRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush, INT nWidth, INT nHeight ) { BOOL ret = FALSE; DC *dc = get_dc_ptr( hdc ); if (!dc) return FALSE; if(dc->funcs->pFrameRgn) { update_dc( dc ); ret = dc->funcs->pFrameRgn( dc->physDev, hrgn, hbrush, nWidth, nHeight ); } else { HRGN tmp = CreateRectRgn( 0, 0, 0, 0 ); if (tmp) { if (REGION_FrameRgn( tmp, hrgn, nWidth, nHeight )) { FillRgn( hdc, tmp, hbrush ); ret = TRUE; } DeleteObject( tmp ); } } release_dc_ptr( dc ); return ret; } /*********************************************************************** * InvertRgn (GDI32.@) */ BOOL WINAPI InvertRgn( HDC hdc, HRGN hrgn ) { HBRUSH prevBrush; INT prevROP; BOOL retval; DC *dc = get_dc_ptr( hdc ); if (!dc) return FALSE; if(dc->funcs->pInvertRgn) { update_dc( dc ); retval = dc->funcs->pInvertRgn( dc->physDev, hrgn ); } else { prevBrush = SelectObject( hdc, GetStockObject(BLACK_BRUSH) ); prevROP = SetROP2( hdc, R2_NOT ); retval = PaintRgn( hdc, hrgn ); SelectObject( hdc, prevBrush ); SetROP2( hdc, prevROP ); } release_dc_ptr( dc ); return retval; } /********************************************************************** * Polyline (GDI32.@) */ BOOL WINAPI Polyline( HDC hdc, const POINT* pt, INT count ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); if (PATH_IsPathOpen(dc->path)) ret = PATH_Polyline(dc, pt, count); else if (dc->funcs->pPolyline) ret = dc->funcs->pPolyline(dc->physDev,pt,count); release_dc_ptr( dc ); } return ret; } /********************************************************************** * PolylineTo (GDI32.@) */ BOOL WINAPI PolylineTo( HDC hdc, const POINT* pt, DWORD cCount ) { DC * dc = get_dc_ptr( hdc ); BOOL ret = FALSE; if(!dc) return FALSE; if(PATH_IsPathOpen(dc->path)) { update_dc( dc ); ret = PATH_PolylineTo(dc, pt, cCount); } else if(dc->funcs->pPolylineTo) { update_dc( dc ); ret = dc->funcs->pPolylineTo(dc->physDev, pt, cCount); } else /* do it using Polyline */ { POINT *pts = HeapAlloc( GetProcessHeap(), 0, sizeof(POINT) * (cCount + 1) ); if (pts) { pts[0].x = dc->CursPosX; pts[0].y = dc->CursPosY; memcpy( pts + 1, pt, sizeof(POINT) * cCount ); ret = Polyline( hdc, pts, cCount + 1 ); HeapFree( GetProcessHeap(), 0, pts ); } } if(ret) { dc->CursPosX = pt[cCount-1].x; dc->CursPosY = pt[cCount-1].y; } release_dc_ptr( dc ); return ret; } /********************************************************************** * Polygon (GDI32.@) */ BOOL WINAPI Polygon( HDC hdc, const POINT* pt, INT count ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); if (PATH_IsPathOpen(dc->path)) ret = PATH_Polygon(dc, pt, count); else if (dc->funcs->pPolygon) ret = dc->funcs->pPolygon(dc->physDev,pt,count); release_dc_ptr( dc ); } return ret; } /********************************************************************** * PolyPolygon (GDI32.@) */ BOOL WINAPI PolyPolygon( HDC hdc, const POINT* pt, const INT* counts, UINT polygons ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); if (PATH_IsPathOpen(dc->path)) ret = PATH_PolyPolygon(dc, pt, counts, polygons); else if (dc->funcs->pPolyPolygon) ret = dc->funcs->pPolyPolygon(dc->physDev,pt,counts,polygons); release_dc_ptr( dc ); } return ret; } /********************************************************************** * PolyPolyline (GDI32.@) */ BOOL WINAPI PolyPolyline( HDC hdc, const POINT* pt, const DWORD* counts, DWORD polylines ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); if (PATH_IsPathOpen(dc->path)) ret = PATH_PolyPolyline(dc, pt, counts, polylines); else if (dc->funcs->pPolyPolyline) ret = dc->funcs->pPolyPolyline(dc->physDev,pt,counts,polylines); release_dc_ptr( dc ); } return ret; } /********************************************************************** * ExtFloodFill (GDI32.@) */ BOOL WINAPI ExtFloodFill( HDC hdc, INT x, INT y, COLORREF color, UINT fillType ) { BOOL ret = FALSE; DC * dc = get_dc_ptr( hdc ); if (dc) { update_dc( dc ); if (dc->funcs->pExtFloodFill) ret = dc->funcs->pExtFloodFill(dc->physDev,x,y,color,fillType); release_dc_ptr( dc ); } return ret; } /********************************************************************** * FloodFill (GDI32.@) */ BOOL WINAPI FloodFill( HDC hdc, INT x, INT y, COLORREF color ) { return ExtFloodFill( hdc, x, y, color, FLOODFILLBORDER ); } /****************************************************************************** * PolyBezier [GDI32.@] * Draws one or more Bezier curves * * PARAMS * hDc [I] Handle to device context * lppt [I] Pointer to endpoints and control points * cPoints [I] Count of endpoints and control points * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL WINAPI PolyBezier( HDC hdc, const POINT* lppt, DWORD cPoints ) { BOOL ret = FALSE; DC * dc; /* cPoints must be 3 * n + 1 (where n>=1) */ if (cPoints == 1 || (cPoints % 3) != 1) return FALSE; dc = get_dc_ptr( hdc ); if(!dc) return FALSE; if(PATH_IsPathOpen(dc->path)) { update_dc( dc ); ret = PATH_PolyBezier(dc, lppt, cPoints); } else if (dc->funcs->pPolyBezier) { update_dc( dc ); ret = dc->funcs->pPolyBezier(dc->physDev, lppt, cPoints); } else /* We'll convert it into line segments and draw them using Polyline */ { POINT *Pts; INT nOut; if ((Pts = GDI_Bezier( lppt, cPoints, &nOut ))) { TRACE("Pts = %p, no = %d\n", Pts, nOut); ret = Polyline( hdc, Pts, nOut ); HeapFree( GetProcessHeap(), 0, Pts ); } } release_dc_ptr( dc ); return ret; } /****************************************************************************** * PolyBezierTo [GDI32.@] * Draws one or more Bezier curves * * PARAMS * hDc [I] Handle to device context * lppt [I] Pointer to endpoints and control points * cPoints [I] Count of endpoints and control points * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL WINAPI PolyBezierTo( HDC hdc, const POINT* lppt, DWORD cPoints ) { DC * dc; BOOL ret = FALSE; /* cbPoints must be 3 * n (where n>=1) */ if (!cPoints || (cPoints % 3) != 0) return FALSE; dc = get_dc_ptr( hdc ); if(!dc) return FALSE; if(PATH_IsPathOpen(dc->path)) { update_dc( dc ); ret = PATH_PolyBezierTo(dc, lppt, cPoints); } else if(dc->funcs->pPolyBezierTo) { update_dc( dc ); ret = dc->funcs->pPolyBezierTo(dc->physDev, lppt, cPoints); } else /* We'll do it using PolyBezier */ { POINT *pt = HeapAlloc( GetProcessHeap(), 0, sizeof(POINT) * (cPoints + 1) ); if(pt) { pt[0].x = dc->CursPosX; pt[0].y = dc->CursPosY; memcpy(pt + 1, lppt, sizeof(POINT) * cPoints); ret = PolyBezier(hdc, pt, cPoints+1); HeapFree( GetProcessHeap(), 0, pt ); } } if(ret) { dc->CursPosX = lppt[cPoints-1].x; dc->CursPosY = lppt[cPoints-1].y; } release_dc_ptr( dc ); return ret; } /*********************************************************************** * AngleArc (GDI32.@) */ BOOL WINAPI AngleArc(HDC hdc, INT x, INT y, DWORD dwRadius, FLOAT eStartAngle, FLOAT eSweepAngle) { INT x1,y1,x2,y2, arcdir; BOOL result; DC *dc; if( (signed int)dwRadius < 0 ) return FALSE; dc = get_dc_ptr( hdc ); if(!dc) return FALSE; /* Calculate the end point */ x2 = x + cos((eStartAngle+eSweepAngle)*M_PI/180) * dwRadius; y2 = y - sin((eStartAngle+eSweepAngle)*M_PI/180) * dwRadius; if(!PATH_IsPathOpen(dc->path) && dc->funcs->pAngleArc) { update_dc( dc ); result = dc->funcs->pAngleArc( dc->physDev, x, y, dwRadius, eStartAngle, eSweepAngle ); } else { /* do it using ArcTo */ x1 = x + cos(eStartAngle*M_PI/180) * dwRadius; y1 = y - sin(eStartAngle*M_PI/180) * dwRadius; arcdir = SetArcDirection( hdc, eSweepAngle >= 0 ? AD_COUNTERCLOCKWISE : AD_CLOCKWISE); result = ArcTo( hdc, x-dwRadius, y-dwRadius, x+dwRadius, y+dwRadius, x1, y1, x2, y2 ); SetArcDirection( hdc, arcdir ); } if (result) { dc->CursPosX = x2; dc->CursPosY = y2; } release_dc_ptr( dc ); return result; } /*********************************************************************** * PolyDraw (GDI32.@) */ BOOL WINAPI PolyDraw(HDC hdc, const POINT *lppt, const BYTE *lpbTypes, DWORD cCount) { DC *dc; BOOL result = FALSE; POINT * line_pts = NULL, * bzr_pts = NULL, bzr[4]; INT i, num_pts, num_bzr_pts, space, size; dc = get_dc_ptr( hdc ); if(!dc) return FALSE; if( PATH_IsPathOpen( dc->path ) ) { update_dc( dc ); result = PATH_PolyDraw(dc, lppt, lpbTypes, cCount); } else if(dc->funcs->pPolyDraw) { update_dc( dc ); result = dc->funcs->pPolyDraw( dc->physDev, lppt, lpbTypes, cCount ); } else { /* check for valid point types */ for(i = 0; i < cCount; i++) { switch(lpbTypes[i]) { case PT_MOVETO: case PT_LINETO | PT_CLOSEFIGURE: case PT_LINETO: break; case PT_BEZIERTO: if((i + 2 < cCount) && (lpbTypes[i + 1] == PT_BEZIERTO) && ((lpbTypes[i + 2] & ~PT_CLOSEFIGURE) == PT_BEZIERTO)){ i += 2; break; } default: goto end; } } space = cCount + 300; line_pts = HeapAlloc(GetProcessHeap(), 0, space * sizeof(POINT)); num_pts = 1; line_pts[0].x = dc->CursPosX; line_pts[0].y = dc->CursPosY; for(i = 0; i < cCount; i++) { switch(lpbTypes[i]) { case PT_MOVETO: if(num_pts >= 2) Polyline(hdc, line_pts, num_pts); num_pts = 0; line_pts[num_pts++] = lppt[i]; break; case PT_LINETO: case (PT_LINETO | PT_CLOSEFIGURE): line_pts[num_pts++] = lppt[i]; break; case PT_BEZIERTO: bzr[0].x = line_pts[num_pts - 1].x; bzr[0].y = line_pts[num_pts - 1].y; memcpy(&bzr[1], &lppt[i], 3 * sizeof(POINT)); bzr_pts = GDI_Bezier(bzr, 4, &num_bzr_pts); size = num_pts + (cCount - i) + num_bzr_pts; if(space < size){ space = size * 2; line_pts = HeapReAlloc(GetProcessHeap(), 0, line_pts, space * sizeof(POINT)); } memcpy(&line_pts[num_pts], &bzr_pts[1], (num_bzr_pts - 1) * sizeof(POINT)); num_pts += num_bzr_pts - 1; HeapFree(GetProcessHeap(), 0, bzr_pts); i += 2; break; default: goto end; } if(lpbTypes[i] & PT_CLOSEFIGURE) line_pts[num_pts++] = line_pts[0]; } if(num_pts >= 2) Polyline(hdc, line_pts, num_pts); MoveToEx(hdc, line_pts[num_pts - 1].x, line_pts[num_pts - 1].y, NULL); HeapFree(GetProcessHeap(), 0, line_pts); result = TRUE; } end: release_dc_ptr( dc ); return result; } /********************************************************************** * LineDDA (GDI32.@) */ BOOL WINAPI LineDDA(INT nXStart, INT nYStart, INT nXEnd, INT nYEnd, LINEDDAPROC callback, LPARAM lParam ) { INT xadd = 1, yadd = 1; INT err,erradd; INT cnt; INT dx = nXEnd - nXStart; INT dy = nYEnd - nYStart; if (dx < 0) { dx = -dx; xadd = -1; } if (dy < 0) { dy = -dy; yadd = -1; } if (dx > dy) /* line is "more horizontal" */ { err = 2*dy - dx; erradd = 2*dy - 2*dx; for(cnt = 0;cnt < dx; cnt++) { callback(nXStart,nYStart,lParam); if (err > 0) { nYStart += yadd; err += erradd; } else err += 2*dy; nXStart += xadd; } } else /* line is "more vertical" */ { err = 2*dx - dy; erradd = 2*dx - 2*dy; for(cnt = 0;cnt < dy; cnt++) { callback(nXStart,nYStart,lParam); if (err > 0) { nXStart += xadd; err += erradd; } else err += 2*dx; nYStart += yadd; } } return TRUE; } /****************************************************************** * * *Very* simple bezier drawing code, * * It uses a recursive algorithm to divide the curve in a series * of straight line segments. Not ideal but sufficient for me. * If you are in need for something better look for some incremental * algorithm. * * 7 July 1998 Rein Klazes */ /* * some macro definitions for bezier drawing * * to avoid truncation errors the coordinates are * shifted upwards. When used in drawing they are * shifted down again, including correct rounding * and avoiding floating point arithmetic * 4 bits should allow 27 bits coordinates which I saw * somewhere in the win32 doc's * */ #define BEZIERSHIFTBITS 4 #define BEZIERSHIFTUP(x) ((x)<<BEZIERSHIFTBITS) #define BEZIERPIXEL BEZIERSHIFTUP(1) #define BEZIERSHIFTDOWN(x) (((x)+(1<<(BEZIERSHIFTBITS-1)))>>BEZIERSHIFTBITS) /* maximum depth of recursion */ #define BEZIERMAXDEPTH 8 /* size of array to store points on */ /* enough for one curve */ #define BEZIER_INITBUFSIZE (150) /* calculate Bezier average, in this case the middle * correctly rounded... * */ #define BEZIERMIDDLE(Mid, P1, P2) \ (Mid).x=((P1).x+(P2).x + 1)/2;\ (Mid).y=((P1).y+(P2).y + 1)/2; /********************************************************** * BezierCheck helper function to check * that recursion can be terminated * Points[0] and Points[3] are begin and endpoint * Points[1] and Points[2] are control points * level is the recursion depth * returns true if the recursion can be terminated */ static BOOL BezierCheck( int level, POINT *Points) { INT dx, dy; dx=Points[3].x-Points[0].x; dy=Points[3].y-Points[0].y; if(abs(dy)<=abs(dx)){/* shallow line */ /* check that control points are between begin and end */ if(Points[1].x < Points[0].x){ if(Points[1].x < Points[3].x) return FALSE; }else if(Points[1].x > Points[3].x) return FALSE; if(Points[2].x < Points[0].x){ if(Points[2].x < Points[3].x) return FALSE; }else if(Points[2].x > Points[3].x) return FALSE; dx=BEZIERSHIFTDOWN(dx); if(!dx) return TRUE; if(abs(Points[1].y-Points[0].y-(dy/dx)* BEZIERSHIFTDOWN(Points[1].x-Points[0].x)) > BEZIERPIXEL || abs(Points[2].y-Points[0].y-(dy/dx)* BEZIERSHIFTDOWN(Points[2].x-Points[0].x)) > BEZIERPIXEL ) return FALSE; else return TRUE; }else{ /* steep line */ /* check that control points are between begin and end */ if(Points[1].y < Points[0].y){ if(Points[1].y < Points[3].y) return FALSE; }else if(Points[1].y > Points[3].y) return FALSE; if(Points[2].y < Points[0].y){ if(Points[2].y < Points[3].y) return FALSE; }else if(Points[2].y > Points[3].y) return FALSE; dy=BEZIERSHIFTDOWN(dy); if(!dy) return TRUE; if(abs(Points[1].x-Points[0].x-(dx/dy)* BEZIERSHIFTDOWN(Points[1].y-Points[0].y)) > BEZIERPIXEL || abs(Points[2].x-Points[0].x-(dx/dy)* BEZIERSHIFTDOWN(Points[2].y-Points[0].y)) > BEZIERPIXEL ) return FALSE; else return TRUE; } } /* Helper for GDI_Bezier. * Just handles one Bezier, so Points should point to four POINTs */ static void GDI_InternalBezier( POINT *Points, POINT **PtsOut, INT *dwOut, INT *nPtsOut, INT level ) { if(*nPtsOut == *dwOut) { *dwOut *= 2; *PtsOut = HeapReAlloc( GetProcessHeap(), 0, *PtsOut, *dwOut * sizeof(POINT) ); } if(!level || BezierCheck(level, Points)) { if(*nPtsOut == 0) { (*PtsOut)[0].x = BEZIERSHIFTDOWN(Points[0].x); (*PtsOut)[0].y = BEZIERSHIFTDOWN(Points[0].y); *nPtsOut = 1; } (*PtsOut)[*nPtsOut].x = BEZIERSHIFTDOWN(Points[3].x); (*PtsOut)[*nPtsOut].y = BEZIERSHIFTDOWN(Points[3].y); (*nPtsOut) ++; } else { POINT Points2[4]; /* for the second recursive call */ Points2[3]=Points[3]; BEZIERMIDDLE(Points2[2], Points[2], Points[3]); BEZIERMIDDLE(Points2[0], Points[1], Points[2]); BEZIERMIDDLE(Points2[1],Points2[0],Points2[2]); BEZIERMIDDLE(Points[1], Points[0], Points[1]); BEZIERMIDDLE(Points[2], Points[1], Points2[0]); BEZIERMIDDLE(Points[3], Points[2], Points2[1]); Points2[0]=Points[3]; /* do the two halves */ GDI_InternalBezier(Points, PtsOut, dwOut, nPtsOut, level-1); GDI_InternalBezier(Points2, PtsOut, dwOut, nPtsOut, level-1); } } /*********************************************************************** * GDI_Bezier [INTERNAL] * Calculate line segments that approximate -what microsoft calls- a bezier * curve. * The routine recursively divides the curve in two parts until a straight * line can be drawn * * PARAMS * * Points [I] Ptr to count POINTs which are the end and control points * of the set of Bezier curves to flatten. * count [I] Number of Points. Must be 3n+1. * nPtsOut [O] Will contain no of points that have been produced (i.e. no. of * lines+1). * * RETURNS * * Ptr to an array of POINTs that contain the lines that approximate the * Beziers. The array is allocated on the process heap and it is the caller's * responsibility to HeapFree it. [this is not a particularly nice interface * but since we can't know in advance how many points we will generate, the * alternative would be to call the function twice, once to determine the size * and a second time to do the work - I decided this was too much of a pain]. */ POINT *GDI_Bezier( const POINT *Points, INT count, INT *nPtsOut ) { POINT *out; INT Bezier, dwOut = BEZIER_INITBUFSIZE, i; if (count == 1 || (count - 1) % 3 != 0) { ERR("Invalid no. of points %d\n", count); return NULL; } *nPtsOut = 0; out = HeapAlloc( GetProcessHeap(), 0, dwOut * sizeof(POINT)); for(Bezier = 0; Bezier < (count-1)/3; Bezier++) { POINT ptBuf[4]; memcpy(ptBuf, Points + Bezier * 3, sizeof(POINT) * 4); for(i = 0; i < 4; i++) { ptBuf[i].x = BEZIERSHIFTUP(ptBuf[i].x); ptBuf[i].y = BEZIERSHIFTUP(ptBuf[i].y); } GDI_InternalBezier( ptBuf, &out, &dwOut, nPtsOut, BEZIERMAXDEPTH ); } TRACE("Produced %d points\n", *nPtsOut); return out; } /****************************************************************************** * GdiGradientFill (GDI32.@) * * FIXME: we don't support the Alpha channel properly */ BOOL WINAPI GdiGradientFill( HDC hdc, TRIVERTEX *vert_array, ULONG nvert, void * grad_array, ULONG ngrad, ULONG mode ) { unsigned int i; TRACE("vert_array:0x%08lx nvert:%d grad_array:0x%08lx ngrad:%d\n", (long)vert_array, nvert, (long)grad_array, ngrad); switch(mode) { case GRADIENT_FILL_RECT_H: for(i = 0; i < ngrad; i++) { GRADIENT_RECT *rect = ((GRADIENT_RECT *)grad_array) + i; TRIVERTEX *v1 = vert_array + rect->UpperLeft; TRIVERTEX *v2 = vert_array + rect->LowerRight; int y1 = v1->y < v2->y ? v1->y : v2->y; int y2 = v2->y > v1->y ? v2->y : v1->y; int x, dx; if (v1->x > v2->x) { TRIVERTEX *t = v2; v2 = v1; v1 = t; } dx = v2->x - v1->x; for (x = 0; x < dx; x++) { POINT pts[2]; HPEN hPen, hOldPen; hPen = CreatePen( PS_SOLID, 1, RGB( (v1->Red * (dx - x) + v2->Red * x) / dx >> 8, (v1->Green * (dx - x) + v2->Green * x) / dx >> 8, (v1->Blue * (dx - x) + v2->Blue * x) / dx >> 8)); hOldPen = SelectObject( hdc, hPen ); pts[0].x = v1->x + x; pts[0].y = y1; pts[1].x = v1->x + x; pts[1].y = y2; Polyline( hdc, &pts[0], 2 ); DeleteObject( SelectObject(hdc, hOldPen ) ); } } break; case GRADIENT_FILL_RECT_V: for(i = 0; i < ngrad; i++) { GRADIENT_RECT *rect = ((GRADIENT_RECT *)grad_array) + i; TRIVERTEX *v1 = vert_array + rect->UpperLeft; TRIVERTEX *v2 = vert_array + rect->LowerRight; int x1 = v1->x < v2->x ? v1->x : v2->x; int x2 = v2->x > v1->x ? v2->x : v1->x; int y, dy; if (v1->y > v2->y) { TRIVERTEX *t = v2; v2 = v1; v1 = t; } dy = v2->y - v1->y; for (y = 0; y < dy; y++) { POINT pts[2]; HPEN hPen, hOldPen; hPen = CreatePen( PS_SOLID, 1, RGB( (v1->Red * (dy - y) + v2->Red * y) / dy >> 8, (v1->Green * (dy - y) + v2->Green * y) / dy >> 8, (v1->Blue * (dy - y) + v2->Blue * y) / dy >> 8)); hOldPen = SelectObject( hdc, hPen ); pts[0].x = x1; pts[0].y = v1->y + y; pts[1].x = x2; pts[1].y = v1->y + y; Polyline( hdc, &pts[0], 2 ); DeleteObject( SelectObject(hdc, hOldPen ) ); } } break; case GRADIENT_FILL_TRIANGLE: for (i = 0; i < ngrad; i++) { GRADIENT_TRIANGLE *tri = ((GRADIENT_TRIANGLE *)grad_array) + i; TRIVERTEX *v1 = vert_array + tri->Vertex1; TRIVERTEX *v2 = vert_array + tri->Vertex2; TRIVERTEX *v3 = vert_array + tri->Vertex3; int y, dy; if (v1->y > v2->y) { TRIVERTEX *t = v1; v1 = v2; v2 = t; } if (v2->y > v3->y) { TRIVERTEX *t = v2; v2 = v3; v3 = t; if (v1->y > v2->y) { t = v1; v1 = v2; v2 = t; } } /* v1->y <= v2->y <= v3->y */ dy = v3->y - v1->y; for (y = 0; y < dy; y++) { /* v1->y <= y < v3->y */ TRIVERTEX *v = y < (v2->y - v1->y) ? v1 : v3; /* (v->y <= y < v2->y) || (v2->y <= y < v->y) */ int dy2 = v2->y - v->y; int y2 = y + v1->y - v->y; int x1 = (v3->x * y + v1->x * (dy - y )) / dy; int x2 = (v2->x * y2 + v-> x * (dy2 - y2)) / dy2; int r1 = (v3->Red * y + v1->Red * (dy - y )) / dy; int r2 = (v2->Red * y2 + v-> Red * (dy2 - y2)) / dy2; int g1 = (v3->Green * y + v1->Green * (dy - y )) / dy; int g2 = (v2->Green * y2 + v-> Green * (dy2 - y2)) / dy2; int b1 = (v3->Blue * y + v1->Blue * (dy - y )) / dy; int b2 = (v2->Blue * y2 + v-> Blue * (dy2 - y2)) / dy2; int x; if (x1 < x2) { int dx = x2 - x1; for (x = 0; x < dx; x++) SetPixel (hdc, x + x1, y + v1->y, RGB( (r1 * (dx - x) + r2 * x) / dx >> 8, (g1 * (dx - x) + g2 * x) / dx >> 8, (b1 * (dx - x) + b2 * x) / dx >> 8)); } else { int dx = x1 - x2; for (x = 0; x < dx; x++) SetPixel (hdc, x + x2, y + v1->y, RGB( (r2 * (dx - x) + r1 * x) / dx >> 8, (g2 * (dx - x) + g1 * x) / dx >> 8, (b2 * (dx - x) + b1 * x) / dx >> 8)); } } } break; default: return FALSE; } return TRUE; }