git.oblomov.eu Git - wine/blob - dlls/gdi/mfdrv/graphics.c

   1 /*
   2  * Metafile driver graphics functions
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 #include "gdi.h"
  25 #include "mfdrv/metafiledrv.h"
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(metafile);
  29
  30 /**********************************************************************
  31  *           MFDRV_MoveTo
  32  */
  33 BOOL
  34 MFDRV_MoveTo(PHYSDEV dev, INT x, INT y)
  35 {
  36     return MFDRV_MetaParam2(dev,META_MOVETO,x,y);
  37 }
  38
  39 /***********************************************************************
  40  *           MFDRV_LineTo
  41  */
  42 BOOL
  43 MFDRV_LineTo( PHYSDEV dev, INT x, INT y )
  44 {
  45      return MFDRV_MetaParam2(dev, META_LINETO, x, y);
  46 }
  47
  48
  49 /***********************************************************************
  50  *           MFDRV_Arc
  51  */
  52 BOOL
  53 MFDRV_Arc( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
  54            INT xstart, INT ystart, INT xend, INT yend )
  55 {
  56      return MFDRV_MetaParam8(dev, META_ARC, left, top, right, bottom,
  57                              xstart, ystart, xend, yend);
  58 }
  59
  60
  61 /***********************************************************************
  62  *           MFDRV_Pie
  63  */
  64 BOOL
  65 MFDRV_Pie( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
  66            INT xstart, INT ystart, INT xend, INT yend )
  67 {
  68     return MFDRV_MetaParam8(dev, META_PIE, left, top, right, bottom,
  69                             xstart, ystart, xend, yend);
  70 }
  71
  72
  73 /***********************************************************************
  74  *           MFDRV_Chord
  75  */
  76 BOOL
  77 MFDRV_Chord( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
  78              INT xstart, INT ystart, INT xend, INT yend )
  79 {
  80     return MFDRV_MetaParam8(dev, META_CHORD, left, top, right, bottom,
  81                             xstart, ystart, xend, yend);
  82 }
  83
  84 /***********************************************************************
  85  *           MFDRV_Ellipse
  86  */
  87 BOOL
  88 MFDRV_Ellipse( PHYSDEV dev, INT left, INT top, INT right, INT bottom )
  89 {
  90     return MFDRV_MetaParam4(dev, META_ELLIPSE, left, top, right, bottom);
  91 }
  92
  93 /***********************************************************************
  94  *           MFDRV_Rectangle
  95  */
  96 BOOL
  97 MFDRV_Rectangle(PHYSDEV dev, INT left, INT top, INT right, INT bottom)
  98 {
  99     return MFDRV_MetaParam4(dev, META_RECTANGLE, left, top, right, bottom);
 100 }
 101
 102 /***********************************************************************
 103  *           MFDRV_RoundRect
 104  */
 105 BOOL
 106 MFDRV_RoundRect( PHYSDEV dev, INT left, INT top, INT right,
 107                  INT bottom, INT ell_width, INT ell_height )
 108 {
 109     return MFDRV_MetaParam6(dev, META_ROUNDRECT, left, top, right, bottom,
 110                             ell_width, ell_height);
 111 }
 112
 113 /***********************************************************************
 114  *           MFDRV_SetPixel
 115  */
 116 COLORREF
 117 MFDRV_SetPixel( PHYSDEV dev, INT x, INT y, COLORREF color )
 118 {
 119     return MFDRV_MetaParam4(dev, META_SETPIXEL, x, y,HIWORD(color),
 120                             LOWORD(color));
 121 }
 122
 123
 124 /******************************************************************
 125  *         MFDRV_MetaPoly - implements Polygon and Polyline
 126  */
 127 static BOOL MFDRV_MetaPoly(PHYSDEV dev, short func, LPPOINT16 pt, short count)
 128 {
 129     BOOL ret;
 130     DWORD len;
 131     METARECORD *mr;
 132
 133     len = sizeof(METARECORD) + (count * 4);
 134     if (!(mr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, len )))
 135         return FALSE;
 136
 137     mr->rdSize = len / 2;
 138     mr->rdFunction = func;
 139     *(mr->rdParm) = count;
 140     memcpy(mr->rdParm + 1, pt, count * 4);
 141     ret = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 142     HeapFree( GetProcessHeap(), 0, mr);
 143     return ret;
 144 }
 145
 146
 147 /**********************************************************************
 148  *          MFDRV_Polyline
 149  */
 150 BOOL
 151 MFDRV_Polyline( PHYSDEV dev, const POINT* pt, INT count )
 152 {
 153     register int i;
 154     LPPOINT16   pt16;
 155     BOOL16      ret;
 156
 157     pt16 = (LPPOINT16)HeapAlloc( GetProcessHeap(), 0, sizeof(POINT16)*count );
 158     if(!pt16) return FALSE;
 159     for (i=count;i--;) CONV_POINT32TO16(&(pt[i]),&(pt16[i]));
 160     ret = MFDRV_MetaPoly(dev, META_POLYLINE, pt16, count);
 161
 162     HeapFree( GetProcessHeap(), 0, pt16 );
 163     return ret;
 164 }
 165
 166
 167 /**********************************************************************
 168  *          MFDRV_Polygon
 169  */
 170 BOOL
 171 MFDRV_Polygon( PHYSDEV dev, const POINT* pt, INT count )
 172 {
 173     register int i;
 174     LPPOINT16   pt16;
 175     BOOL16      ret;
 176
 177     pt16 = (LPPOINT16) HeapAlloc( GetProcessHeap(), 0, sizeof(POINT16)*count );
 178     if(!pt16) return FALSE;
 179     for (i=count;i--;) CONV_POINT32TO16(&(pt[i]),&(pt16[i]));
 180     ret = MFDRV_MetaPoly(dev, META_POLYGON, pt16, count);
 181
 182     HeapFree( GetProcessHeap(), 0, pt16 );
 183     return ret;
 184 }
 185
 186
 187 /**********************************************************************
 188  *          MFDRV_PolyPolygon
 189  */
 190 BOOL
 191 MFDRV_PolyPolygon( PHYSDEV dev, const POINT* pt, const INT* counts, UINT polygons)
 192 {
 193     BOOL ret;
 194     DWORD len;
 195     METARECORD *mr;
 196     int       i,j;
 197     LPPOINT16 pt16;
 198     INT16 totalpoint16 = 0;
 199     INT16 * pointcounts;
 200
 201     for (i=0;i<polygons;i++) {
 202          totalpoint16 += counts[i];
 203     }
 204
 205     /* allocate space for all points */
 206     pt16=(LPPOINT16)HeapAlloc( GetProcessHeap(), 0,
 207                                      sizeof(POINT16) * totalpoint16 );
 208     pointcounts = (INT16*)HeapAlloc( GetProcessHeap(), 0,
 209                                      sizeof(INT16) * totalpoint16 );
 210
 211     /* copy point counts */
 212     for (i=0;i<polygons;i++) {
 213           pointcounts[i] = counts[i];
 214     }
 215
 216     /* convert all points */
 217     for (j = totalpoint16; j--;){
 218          CONV_POINT32TO16(&(pt[j]),&(pt16[j]));
 219     }
 220
 221     len = sizeof(METARECORD) + sizeof(WORD) + polygons*sizeof(INT16) + totalpoint16*sizeof(POINT16);
 222
 223     if (!(mr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, len ))) {
 224          HeapFree( GetProcessHeap(), 0, pt16 );
 225          HeapFree( GetProcessHeap(), 0, pointcounts );
 226          return FALSE;
 227     }
 228
 229     mr->rdSize = len /2;
 230     mr->rdFunction = META_POLYPOLYGON;
 231     *(mr->rdParm) = polygons;
 232     memcpy(mr->rdParm + 1, pointcounts, polygons*sizeof(INT16));
 233     memcpy(mr->rdParm + 1+polygons, pt16 , totalpoint16*sizeof(POINT16));
 234     ret = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
 235
 236     HeapFree( GetProcessHeap(), 0, pt16 );
 237     HeapFree( GetProcessHeap(), 0, pointcounts );
 238     HeapFree( GetProcessHeap(), 0, mr);
 239     return ret;
 240 }
 241
 242
 243 /**********************************************************************
 244  *          MFDRV_ExtFloodFill
 245  */
 246 BOOL
 247 MFDRV_ExtFloodFill( PHYSDEV dev, INT x, INT y, COLORREF color, UINT fillType )
 248 {
 249     return MFDRV_MetaParam4(dev,META_FLOODFILL,x,y,HIWORD(color),
 250                             LOWORD(color));
 251 }
 252
 253
 254 /******************************************************************
 255  *         MFDRV_CreateRegion
 256  *
 257  * For explanation of the format of the record see MF_Play_MetaCreateRegion in
 258  * objects/metafile.c
 259  */
 260 static INT16 MFDRV_CreateRegion(PHYSDEV dev, HRGN hrgn)
 261 {
 262     DWORD len;
 263     METARECORD *mr;
 264     RGNDATA *rgndata;
 265     RECT *pCurRect, *pEndRect;
 266     WORD Bands = 0, MaxBands = 0;
 267     WORD *Param, *StartBand;
 268     BOOL ret;
 269
 270     if (!(len = GetRegionData( hrgn, 0, NULL ))) return -1;
 271     if( !(rgndata = HeapAlloc( GetProcessHeap(), 0, len )) ) {
 272         WARN("Can't alloc rgndata buffer\n");
 273         return -1;
 274     }
 275     GetRegionData( hrgn, len, rgndata );
 276
 277     /* Overestimate of length:
 278      * Assume every rect is a separate band -> 6 WORDs per rect
 279      */
 280     len = sizeof(METARECORD) + 20 + (rgndata->rdh.nCount * 12);
 281     if( !(mr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, len )) ) {
 282         WARN("Can't alloc METARECORD buffer\n");
 283         HeapFree( GetProcessHeap(), 0, rgndata );
 284         return -1;
 285     }
 286
 287     Param = mr->rdParm + 11;
 288     StartBand = NULL;
 289
 290     pEndRect = (RECT *)rgndata->Buffer + rgndata->rdh.nCount;
 291     for(pCurRect = (RECT *)rgndata->Buffer; pCurRect < pEndRect; pCurRect++)
 292     {
 293         if( StartBand && pCurRect->top == *(StartBand + 1) )
 294         {
 295             *Param++ = pCurRect->left;
 296             *Param++ = pCurRect->right;
 297         }
 298         else
 299         {
 300             if(StartBand)
 301             {
 302                 *StartBand = Param - StartBand - 3;
 303                 *Param++ = *StartBand;
 304                 if(*StartBand > MaxBands)
 305                     MaxBands = *StartBand;
 306                 Bands++;
 307             }
 308             StartBand = Param++;
 309             *Param++ = pCurRect->top;
 310             *Param++ = pCurRect->bottom;
 311             *Param++ = pCurRect->left;
 312             *Param++ = pCurRect->right;
 313         }
 314     }
 315     len = Param - (WORD *)mr;
 316
 317     mr->rdParm[0] = 0;
 318     mr->rdParm[1] = 6;
 319     mr->rdParm[2] = 0x1234;
 320     mr->rdParm[3] = 0;
 321     mr->rdParm[4] = len * 2;
 322     mr->rdParm[5] = Bands;
 323     mr->rdParm[6] = MaxBands;
 324     mr->rdParm[7] = rgndata->rdh.rcBound.left;
 325     mr->rdParm[8] = rgndata->rdh.rcBound.top;
 326     mr->rdParm[9] = rgndata->rdh.rcBound.right;
 327     mr->rdParm[10] = rgndata->rdh.rcBound.bottom;
 328     mr->rdFunction = META_CREATEREGION;
 329     mr->rdSize = len / 2;
 330     ret = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2 );
 331     HeapFree( GetProcessHeap(), 0, mr );
 332     HeapFree( GetProcessHeap(), 0, rgndata );
 333     if(!ret)
 334     {
 335         WARN("MFDRV_WriteRecord failed\n");
 336         return -1;
 337     }
 338     return MFDRV_AddHandleDC( dev );
 339 }
 340
 341
 342 /**********************************************************************
 343  *          MFDRV_PaintRgn
 344  */
 345 BOOL
 346 MFDRV_PaintRgn( PHYSDEV dev, HRGN hrgn )
 347 {
 348     INT16 index;
 349     index = MFDRV_CreateRegion( dev, hrgn );
 350     if(index == -1)
 351         return FALSE;
 352     return MFDRV_MetaParam1( dev, META_PAINTREGION, index );
 353 }
 354
 355
 356 /**********************************************************************
 357  *          MFDRV_InvertRgn
 358  */
 359 BOOL
 360 MFDRV_InvertRgn( PHYSDEV dev, HRGN hrgn )
 361 {
 362     INT16 index;
 363     index = MFDRV_CreateRegion( dev, hrgn );
 364     if(index == -1)
 365         return FALSE;
 366     return MFDRV_MetaParam1( dev, META_INVERTREGION, index );
 367 }
 368
 369
 370 /**********************************************************************
 371  *          MFDRV_FillRgn
 372  */
 373 BOOL
 374 MFDRV_FillRgn( PHYSDEV dev, HRGN hrgn, HBRUSH hbrush )
 375 {
 376     INT16 iRgn, iBrush;
 377     iRgn = MFDRV_CreateRegion( dev, hrgn );
 378     if(iRgn == -1)
 379         return FALSE;
 380     iBrush = MFDRV_CreateBrushIndirect( dev, hbrush );
 381     if(iBrush == -1)
 382         return FALSE;
 383     return MFDRV_MetaParam2( dev, META_FILLREGION, iRgn, iBrush );
 384 }
 385
 386 /**********************************************************************
 387  *          MFDRV_FrameRgn
 388  */
 389 BOOL
 390 MFDRV_FrameRgn( PHYSDEV dev, HRGN hrgn, HBRUSH hbrush, INT x, INT y )
 391 {
 392     INT16 iRgn, iBrush;
 393     iRgn = MFDRV_CreateRegion( dev, hrgn );
 394     if(iRgn == -1)
 395         return FALSE;
 396     iBrush = MFDRV_CreateBrushIndirect( dev, hbrush );
 397     if(iBrush == -1)
 398         return FALSE;
 399     return MFDRV_MetaParam4( dev, META_FRAMEREGION, iRgn, iBrush, x, y );
 400 }
 401
 402
 403 /**********************************************************************
 404  *          MFDRV_ExtSelectClipRgn
 405  */
 406 INT MFDRV_ExtSelectClipRgn( PHYSDEV dev, HRGN hrgn, INT mode )
 407 {
 408     INT16 iRgn;
 409     INT ret;
 410
 411     if (mode != RGN_COPY) return ERROR;
 412     if (!hrgn) return NULLREGION;
 413     iRgn = MFDRV_CreateRegion( dev, hrgn );
 414     if(iRgn == -1) return ERROR;
 415     ret = MFDRV_MetaParam1( dev, META_SELECTCLIPREGION, iRgn ) ? NULLREGION : ERROR;
 416     MFDRV_MetaParam1( dev, META_DELETEOBJECT, iRgn );
 417     return ret;
 418 }
 419
 420
 421 /**********************************************************************
 422  *          MFDRV_SetBkColor
 423  */
 424 COLORREF
 425 MFDRV_SetBkColor( PHYSDEV dev, COLORREF color )
 426 {
 427     return MFDRV_MetaParam2(dev, META_SETBKCOLOR, HIWORD(color),
 428                             LOWORD(color)) ? color : CLR_INVALID;
 429 }
 430
 431
 432 /**********************************************************************
 433  *          MFDRV_SetTextColor
 434  */
 435 COLORREF
 436 MFDRV_SetTextColor( PHYSDEV dev, COLORREF color )
 437 {
 438     return MFDRV_MetaParam2(dev, META_SETTEXTCOLOR, HIWORD(color),
 439                             LOWORD(color)) ? color : CLR_INVALID;
 440 }
 441
 442
 443 /**********************************************************************
 444  *          MFDRV_PolyBezier
 445  * Since MetaFiles don't record Beziers and they don't even record
 446  * approximations to them using lines, we need this stub function.
 447  */
 448 BOOL
 449 MFDRV_PolyBezier( PHYSDEV dev, const POINT *pts, DWORD count )
 450 {
 451     return FALSE;
 452 }
 453
 454 /**********************************************************************
 455  *          MFDRV_PolyBezierTo
 456  * Since MetaFiles don't record Beziers and they don't even record
 457  * approximations to them using lines, we need this stub function.
 458  */
 459 BOOL
 460 MFDRV_PolyBezierTo( PHYSDEV dev, const POINT *pts, DWORD count )
 461 {
 462     return FALSE;
 463 }