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