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

   1 /*
   2  * Enhanced MetaFile driver graphics functions
   3  *
   4  * Copyright 1999 Huw D M Davies
   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 "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "gdi.h"
  28 #include "enhmfdrv/enhmetafiledrv.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(enhmetafile);
  32
  33 /**********************************************************************
  34  *           EMFDRV_MoveTo
  35  */
  36 BOOL
  37 EMFDRV_MoveTo(PHYSDEV dev, INT x, INT y)
  38 {
  39     EMRMOVETOEX emr;
  40
  41     emr.emr.iType = EMR_MOVETOEX;
  42     emr.emr.nSize = sizeof(emr);
  43     emr.ptl.x = x;
  44     emr.ptl.y = y;
  45
  46     return EMFDRV_WriteRecord( dev, &emr.emr );
  47 }
  48
  49 /***********************************************************************
  50  *           EMFDRV_LineTo
  51  */
  52 BOOL
  53 EMFDRV_LineTo( PHYSDEV dev, INT x, INT y )
  54 {
  55     EMRLINETO emr;
  56     RECTL bounds;
  57     EMFDRV_PDEVICE *physDev = (EMFDRV_PDEVICE *)dev;
  58     DC *dc = physDev->dc;
  59
  60     emr.emr.iType = EMR_LINETO;
  61     emr.emr.nSize = sizeof(emr);
  62     emr.ptl.x = x;
  63     emr.ptl.y = y;
  64
  65     if(!EMFDRV_WriteRecord( dev, &emr.emr ))
  66         return FALSE;
  67
  68     bounds.left   = min(x, dc->CursPosX);
  69     bounds.top    = min(y, dc->CursPosY);
  70     bounds.right  = max(x, dc->CursPosX);
  71     bounds.bottom = max(y, dc->CursPosY);
  72
  73     EMFDRV_UpdateBBox( dev, &bounds );
  74
  75     return TRUE;
  76 }
  77
  78
  79 /***********************************************************************
  80  *           EMFDRV_ArcChordPie
  81  */
  82 static BOOL
  83 EMFDRV_ArcChordPie( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
  84                     INT xstart, INT ystart, INT xend, INT yend, DWORD iType )
  85 {
  86     INT temp, xCentre, yCentre, i;
  87     double angleStart, angleEnd;
  88     double xinterStart, yinterStart, xinterEnd, yinterEnd;
  89     EMRARC emr;
  90     RECTL bounds;
  91     EMFDRV_PDEVICE *physDev = (EMFDRV_PDEVICE *)dev;
  92     DC *dc = physDev->dc;
  93
  94     if(left == right || top == bottom) return FALSE;
  95
  96     if(left > right) {temp = left; left = right; right = temp;}
  97     if(top > bottom) {temp = top; top = bottom; bottom = temp;}
  98
  99     if(dc->GraphicsMode == GM_COMPATIBLE) {
 100         right--;
 101         bottom--;
 102     }
 103
 104     emr.emr.iType     = iType;
 105     emr.emr.nSize     = sizeof(emr);
 106     emr.rclBox.left   = left;
 107     emr.rclBox.top    = top;
 108     emr.rclBox.right  = right;
 109     emr.rclBox.bottom = bottom;
 110     emr.ptlStart.x    = xstart;
 111     emr.ptlStart.y    = ystart;
 112     emr.ptlEnd.x      = xend;
 113     emr.ptlEnd.x      = yend;
 114
 115
 116     /* Now calculate the BBox */
 117     xCentre = (left + right + 1) / 2;
 118     yCentre = (top + bottom + 1) / 2;
 119
 120     xstart -= xCentre;
 121     ystart -= yCentre;
 122     xend   -= xCentre;
 123     yend   -= yCentre;
 124
 125     /* invert y co-ords to get angle anti-clockwise from x-axis */
 126     angleStart = atan2( -(double)ystart, (double)xstart);
 127     angleEnd   = atan2( -(double)yend, (double)xend);
 128
 129     /* These are the intercepts of the start/end lines with the arc */
 130
 131     xinterStart = (right - left + 1)/2 * cos(angleStart) + xCentre;
 132     yinterStart = -(bottom - top + 1)/2 * sin(angleStart) + yCentre;
 133     xinterEnd   = (right - left + 1)/2 * cos(angleEnd) + xCentre;
 134     yinterEnd   = -(bottom - top + 1)/2 * sin(angleEnd) + yCentre;
 135
 136     if(angleStart < 0) angleStart += 2 * M_PI;
 137     if(angleEnd < 0) angleEnd += 2 * M_PI;
 138     if(angleEnd < angleStart) angleEnd += 2 * M_PI;
 139
 140     bounds.left   = min(xinterStart, xinterEnd);
 141     bounds.top    = min(yinterStart, yinterEnd);
 142     bounds.right  = max(xinterStart, xinterEnd);
 143     bounds.bottom = max(yinterStart, yinterEnd);
 144
 145     for(i = 0; i <= 8; i++) {
 146         if(i * M_PI / 2 < angleStart) /* loop until we're past start */
 147             continue;
 148         if(i * M_PI / 2 > angleEnd)   /* if we're past end we're finished */
 149             break;
 150
 151         /* the arc touches the rectangle at the start of quadrant i, so adjust
 152            BBox to reflect this. */
 153
 154         switch(i % 4) {
 155         case 0:
 156             bounds.right = right;
 157             break;
 158         case 1:
 159             bounds.top = top;
 160             break;
 161         case 2:
 162             bounds.left = left;
 163             break;
 164         case 3:
 165             bounds.bottom = bottom;
 166             break;
 167         }
 168     }
 169
 170     /* If we're drawing a pie then make sure we include the centre */
 171     if(iType == EMR_PIE) {
 172         if(bounds.left > xCentre) bounds.left = xCentre;
 173         else if(bounds.right < xCentre) bounds.right = xCentre;
 174         if(bounds.top > yCentre) bounds.top = yCentre;
 175         else if(bounds.bottom < yCentre) bounds.right = yCentre;
 176     }
 177     if(!EMFDRV_WriteRecord( dev, &emr.emr ))
 178         return FALSE;
 179     EMFDRV_UpdateBBox( dev, &bounds );
 180     return TRUE;
 181 }
 182
 183
 184 /***********************************************************************
 185  *           EMFDRV_Arc
 186  */
 187 BOOL
 188 EMFDRV_Arc( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
 189             INT xstart, INT ystart, INT xend, INT yend )
 190 {
 191     return EMFDRV_ArcChordPie( dev, left, top, right, bottom, xstart, ystart,
 192                                xend, yend, EMR_ARC );
 193 }
 194
 195 /***********************************************************************
 196  *           EMFDRV_Pie
 197  */
 198 BOOL
 199 EMFDRV_Pie( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
 200             INT xstart, INT ystart, INT xend, INT yend )
 201 {
 202     return EMFDRV_ArcChordPie( dev, left, top, right, bottom, xstart, ystart,
 203                                xend, yend, EMR_PIE );
 204 }
 205
 206
 207 /***********************************************************************
 208  *           EMFDRV_Chord
 209  */
 210 BOOL
 211 EMFDRV_Chord( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
 212              INT xstart, INT ystart, INT xend, INT yend )
 213 {
 214     return EMFDRV_ArcChordPie( dev, left, top, right, bottom, xstart, ystart,
 215                                xend, yend, EMR_CHORD );
 216 }
 217
 218 /***********************************************************************
 219  *           EMFDRV_Ellipse
 220  */
 221 BOOL
 222 EMFDRV_Ellipse( PHYSDEV dev, INT left, INT top, INT right, INT bottom )
 223 {
 224     EMRELLIPSE emr;
 225     INT temp;
 226     EMFDRV_PDEVICE *physDev = (EMFDRV_PDEVICE *)dev;
 227     DC *dc = physDev->dc;
 228
 229     TRACE("%d,%d - %d,%d\n", left, top, right, bottom);
 230
 231     if(left == right || top == bottom) return FALSE;
 232
 233     if(left > right) {temp = left; left = right; right = temp;}
 234     if(top > bottom) {temp = top; top = bottom; bottom = temp;}
 235
 236     if(dc->GraphicsMode == GM_COMPATIBLE) {
 237         right--;
 238         bottom--;
 239     }
 240
 241     emr.emr.iType     = EMR_ELLIPSE;
 242     emr.emr.nSize     = sizeof(emr);
 243     emr.rclBox.left   = left;
 244     emr.rclBox.top    = top;
 245     emr.rclBox.right  = right;
 246     emr.rclBox.bottom = bottom;
 247
 248     EMFDRV_UpdateBBox( dev, &emr.rclBox );
 249     return EMFDRV_WriteRecord( dev, &emr.emr );
 250 }
 251
 252 /***********************************************************************
 253  *           EMFDRV_Rectangle
 254  */
 255 BOOL
 256 EMFDRV_Rectangle(PHYSDEV dev, INT left, INT top, INT right, INT bottom)
 257 {
 258     EMRRECTANGLE emr;
 259     INT temp;
 260     EMFDRV_PDEVICE *physDev = (EMFDRV_PDEVICE *)dev;
 261     DC *dc = physDev->dc;
 262
 263     TRACE("%d,%d - %d,%d\n", left, top, right, bottom);
 264
 265     if(left == right || top == bottom) return FALSE;
 266
 267     if(left > right) {temp = left; left = right; right = temp;}
 268     if(top > bottom) {temp = top; top = bottom; bottom = temp;}
 269
 270     if(dc->GraphicsMode == GM_COMPATIBLE) {
 271         right--;
 272         bottom--;
 273     }
 274
 275     emr.emr.iType     = EMR_RECTANGLE;
 276     emr.emr.nSize     = sizeof(emr);
 277     emr.rclBox.left   = left;
 278     emr.rclBox.top    = top;
 279     emr.rclBox.right  = right;
 280     emr.rclBox.bottom = bottom;
 281
 282     EMFDRV_UpdateBBox( dev, &emr.rclBox );
 283     return EMFDRV_WriteRecord( dev, &emr.emr );
 284 }
 285
 286 /***********************************************************************
 287  *           EMFDRV_RoundRect
 288  */
 289 BOOL
 290 EMFDRV_RoundRect( PHYSDEV dev, INT left, INT top, INT right,
 291                   INT bottom, INT ell_width, INT ell_height )
 292 {
 293     EMRROUNDRECT emr;
 294     INT temp;
 295     EMFDRV_PDEVICE *physDev = (EMFDRV_PDEVICE *)dev;
 296     DC *dc = physDev->dc;
 297
 298     if(left == right || top == bottom) return FALSE;
 299
 300     if(left > right) {temp = left; left = right; right = temp;}
 301     if(top > bottom) {temp = top; top = bottom; bottom = temp;}
 302
 303     if(dc->GraphicsMode == GM_COMPATIBLE) {
 304         right--;
 305         bottom--;
 306     }
 307
 308     emr.emr.iType     = EMR_ROUNDRECT;
 309     emr.emr.nSize     = sizeof(emr);
 310     emr.rclBox.left   = left;
 311     emr.rclBox.top    = top;
 312     emr.rclBox.right  = right;
 313     emr.rclBox.bottom = bottom;
 314     emr.szlCorner.cx  = ell_width;
 315     emr.szlCorner.cy  = ell_height;
 316
 317     EMFDRV_UpdateBBox( dev, &emr.rclBox );
 318     return EMFDRV_WriteRecord( dev, &emr.emr );
 319 }
 320
 321 /***********************************************************************
 322  *           EMFDRV_SetPixel
 323  */
 324 COLORREF
 325 EMFDRV_SetPixel( PHYSDEV dev, INT x, INT y, COLORREF color )
 326 {
 327     EMRSETPIXELV emr;
 328
 329     emr.emr.iType  = EMR_SETPIXELV;
 330     emr.emr.nSize  = sizeof(emr);
 331     emr.ptlPixel.x = x;
 332     emr.ptlPixel.y = y;
 333     emr.crColor = color;
 334
 335     if (EMFDRV_WriteRecord( dev, &emr.emr )) {
 336         RECTL bounds;
 337         bounds.left = bounds.right = x;
 338         bounds.top = bounds.bottom = y;
 339         EMFDRV_UpdateBBox( dev, &bounds );
 340         return color;
 341     }
 342     return -1;
 343 }
 344
 345 /**********************************************************************
 346  *          EMFDRV_Polylinegon
 347  *
 348  * Helper for EMFDRV_Poly{line|gon}
 349  */
 350 static BOOL
 351 EMFDRV_Polylinegon( PHYSDEV dev, const POINT* pt, INT count, DWORD iType )
 352 {
 353     EMRPOLYLINE *emr;
 354     DWORD size;
 355     INT i;
 356     BOOL ret;
 357
 358     size = sizeof(EMRPOLYLINE) + sizeof(POINTL) * (count - 1);
 359
 360     emr = HeapAlloc( GetProcessHeap(), 0, size );
 361     emr->emr.iType = iType;
 362     emr->emr.nSize = size;
 363
 364     emr->rclBounds.left = emr->rclBounds.right = pt[0].x;
 365     emr->rclBounds.top = emr->rclBounds.bottom = pt[0].y;
 366
 367     for(i = 1; i < count; i++) {
 368         if(pt[i].x < emr->rclBounds.left)
 369             emr->rclBounds.left = pt[i].x;
 370         else if(pt[i].x > emr->rclBounds.right)
 371             emr->rclBounds.right = pt[i].x;
 372         if(pt[i].y < emr->rclBounds.top)
 373             emr->rclBounds.top = pt[i].y;
 374         else if(pt[i].y > emr->rclBounds.bottom)
 375             emr->rclBounds.bottom = pt[i].y;
 376     }
 377
 378     emr->cptl = count;
 379     memcpy(emr->aptl, pt, count * sizeof(POINTL));
 380
 381     ret = EMFDRV_WriteRecord( dev, &emr->emr );
 382     if(ret)
 383         EMFDRV_UpdateBBox( dev, &emr->rclBounds );
 384     HeapFree( GetProcessHeap(), 0, emr );
 385     return ret;
 386 }
 387
 388
 389 /**********************************************************************
 390  *          EMFDRV_Polyline
 391  */
 392 BOOL
 393 EMFDRV_Polyline( PHYSDEV dev, const POINT* pt, INT count )
 394 {
 395     return EMFDRV_Polylinegon( dev, pt, count, EMR_POLYLINE );
 396 }
 397
 398 /**********************************************************************
 399  *          EMFDRV_Polygon
 400  */
 401 BOOL
 402 EMFDRV_Polygon( PHYSDEV dev, const POINT* pt, INT count )
 403 {
 404     if(count < 2) return FALSE;
 405     return EMFDRV_Polylinegon( dev, pt, count, EMR_POLYGON );
 406 }
 407
 408
 409 /**********************************************************************
 410  *          EMFDRV_PolyPolylinegon
 411  *
 412  * Helper for EMFDRV_PolyPoly{line|gon}
 413  */
 414 static BOOL
 415 EMFDRV_PolyPolylinegon( PHYSDEV dev, const POINT* pt, const INT* counts, UINT polys,
 416                         DWORD iType)
 417 {
 418     EMRPOLYPOLYLINE *emr;
 419     DWORD cptl = 0, poly, size, point;
 420     RECTL bounds;
 421     const POINT *pts;
 422     BOOL ret;
 423
 424     bounds.left = bounds.right = pt[0].x;
 425     bounds.top = bounds.bottom = pt[0].y;
 426
 427     pts = pt;
 428     for(poly = 0; poly < polys; poly++) {
 429         cptl += counts[poly];
 430         for(point = 0; point < counts[poly]; point++) {
 431             if(bounds.left > pts->x) bounds.left = pts->x;
 432             else if(bounds.right < pts->x) bounds.right = pts->x;
 433             if(bounds.top > pts->y) bounds.top = pts->y;
 434             else if(bounds.bottom < pts->y) bounds.bottom = pts->y;
 435             pts++;
 436         }
 437     }
 438
 439     size = sizeof(EMRPOLYPOLYLINE) + (polys - 1) * sizeof(DWORD) +
 440       (cptl - 1) * sizeof(POINTL);
 441
 442     emr = HeapAlloc( GetProcessHeap(), 0, size );
 443
 444     emr->emr.iType = iType;
 445     emr->emr.nSize = size;
 446     emr->rclBounds = bounds;
 447     emr->nPolys = polys;
 448     emr->cptl = cptl;
 449     memcpy(emr->aPolyCounts, counts, polys * sizeof(DWORD));
 450     memcpy(emr->aPolyCounts + polys, pt, cptl * sizeof(POINTL));
 451     ret = EMFDRV_WriteRecord( dev, &emr->emr );
 452     if(ret)
 453         EMFDRV_UpdateBBox( dev, &emr->rclBounds );
 454     HeapFree( GetProcessHeap(), 0, emr );
 455     return ret;
 456 }
 457
 458 /**********************************************************************
 459  *          EMFDRV_PolyPolyline
 460  */
 461 BOOL
 462 EMFDRV_PolyPolyline(PHYSDEV dev, const POINT* pt, const DWORD* counts, DWORD polys)
 463 {
 464     return EMFDRV_PolyPolylinegon( dev, pt, (INT *)counts, polys,
 465                                    EMR_POLYPOLYLINE );
 466 }
 467
 468 /**********************************************************************
 469  *          EMFDRV_PolyPolygon
 470  */
 471 BOOL
 472 EMFDRV_PolyPolygon( PHYSDEV dev, const POINT* pt, const INT* counts, UINT polys )
 473 {
 474     return EMFDRV_PolyPolylinegon( dev, pt, counts, polys, EMR_POLYPOLYGON );
 475 }
 476
 477
 478 /**********************************************************************
 479  *          EMFDRV_ExtFloodFill
 480  */
 481 BOOL
 482 EMFDRV_ExtFloodFill( PHYSDEV dev, INT x, INT y, COLORREF color, UINT fillType )
 483 {
 484     EMREXTFLOODFILL emr;
 485
 486     emr.emr.iType = EMR_EXTFLOODFILL;
 487     emr.emr.nSize = sizeof(emr);
 488     emr.ptlStart.x = x;
 489     emr.ptlStart.y = y;
 490     emr.crColor = color;
 491     emr.iMode = fillType;
 492
 493     return EMFDRV_WriteRecord( dev, &emr.emr );
 494 }
 495
 496
 497 /*********************************************************************
 498  *          EMFDRV_FillRgn
 499  */
 500 BOOL EMFDRV_FillRgn( PHYSDEV dev, HRGN hrgn, HBRUSH hbrush )
 501 {
 502     EMRFILLRGN *emr;
 503     DWORD size, rgnsize, index;
 504     BOOL ret;
 505
 506     index = EMFDRV_CreateBrushIndirect( dev, hbrush );
 507     if(!index) return FALSE;
 508
 509     rgnsize = GetRegionData( hrgn, 0, NULL );
 510     size = rgnsize + offsetof(EMRFILLRGN,RgnData);
 511     emr = HeapAlloc( GetProcessHeap(), 0, size );
 512
 513     GetRegionData( hrgn, rgnsize, (RGNDATA *)&emr->RgnData );
 514
 515     emr->emr.iType = EMR_FILLRGN;
 516     emr->emr.nSize = size;
 517     emr->rclBounds.left   = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.left;
 518     emr->rclBounds.top    = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.top;
 519     emr->rclBounds.right  = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.right - 1;
 520     emr->rclBounds.bottom = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.bottom - 1;
 521     emr->cbRgnData = rgnsize;
 522     emr->ihBrush = index;
 523
 524     ret = EMFDRV_WriteRecord( dev, &emr->emr );
 525     if(ret)
 526         EMFDRV_UpdateBBox( dev, &emr->rclBounds );
 527     HeapFree( GetProcessHeap(), 0, emr );
 528     return ret;
 529 }
 530 /*********************************************************************
 531  *          EMFDRV_FrameRgn
 532  */
 533 BOOL EMFDRV_FrameRgn( PHYSDEV dev, HRGN hrgn, HBRUSH hbrush, INT width, INT height )
 534 {
 535     EMRFRAMERGN *emr;
 536     DWORD size, rgnsize, index;
 537     BOOL ret;
 538
 539     index = EMFDRV_CreateBrushIndirect( dev, hbrush );
 540     if(!index) return FALSE;
 541
 542     rgnsize = GetRegionData( hrgn, 0, NULL );
 543     size = rgnsize + offsetof(EMRFRAMERGN,RgnData);
 544     emr = HeapAlloc( GetProcessHeap(), 0, size );
 545
 546     GetRegionData( hrgn, rgnsize, (RGNDATA *)&emr->RgnData );
 547
 548     emr->emr.iType = EMR_FRAMERGN;
 549     emr->emr.nSize = size;
 550     emr->rclBounds.left   = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.left;
 551     emr->rclBounds.top    = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.top;
 552     emr->rclBounds.right  = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.right - 1;
 553     emr->rclBounds.bottom = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.bottom - 1;
 554     emr->cbRgnData = rgnsize;
 555     emr->ihBrush = index;
 556     emr->szlStroke.cx = width;
 557     emr->szlStroke.cy = height;
 558
 559     ret = EMFDRV_WriteRecord( dev, &emr->emr );
 560     if(ret)
 561         EMFDRV_UpdateBBox( dev, &emr->rclBounds );
 562     HeapFree( GetProcessHeap(), 0, emr );
 563     return ret;
 564 }
 565
 566 /*********************************************************************
 567  *          EMFDRV_PaintInvertRgn
 568  *
 569  * Helper for EMFDRV_{Paint|Invert}Rgn
 570  */
 571 static BOOL EMFDRV_PaintInvertRgn( PHYSDEV dev, HRGN hrgn, DWORD iType )
 572 {
 573     EMRINVERTRGN *emr;
 574     DWORD size, rgnsize;
 575     BOOL ret;
 576
 577
 578     rgnsize = GetRegionData( hrgn, 0, NULL );
 579     size = rgnsize + offsetof(EMRINVERTRGN,RgnData);
 580     emr = HeapAlloc( GetProcessHeap(), 0, size );
 581
 582     GetRegionData( hrgn, rgnsize, (RGNDATA *)&emr->RgnData );
 583
 584     emr->emr.iType = iType;
 585     emr->emr.nSize = size;
 586     emr->rclBounds.left   = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.left;
 587     emr->rclBounds.top    = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.top;
 588     emr->rclBounds.right  = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.right - 1;
 589     emr->rclBounds.bottom = ((RGNDATA *)&emr->RgnData)->rdh.rcBound.bottom - 1;
 590     emr->cbRgnData = rgnsize;
 591
 592     ret = EMFDRV_WriteRecord( dev, &emr->emr );
 593     if(ret)
 594         EMFDRV_UpdateBBox( dev, &emr->rclBounds );
 595     HeapFree( GetProcessHeap(), 0, emr );
 596     return ret;
 597 }
 598
 599 /**********************************************************************
 600  *          EMFDRV_PaintRgn
 601  */
 602 BOOL
 603 EMFDRV_PaintRgn( PHYSDEV dev, HRGN hrgn )
 604 {
 605     return EMFDRV_PaintInvertRgn( dev, hrgn, EMR_PAINTRGN );
 606 }
 607
 608 /**********************************************************************
 609  *          EMFDRV_InvertRgn
 610  */
 611 BOOL
 612 EMFDRV_InvertRgn( PHYSDEV dev, HRGN hrgn )
 613 {
 614     return EMFDRV_PaintInvertRgn( dev, hrgn, EMR_INVERTRGN );
 615 }
 616
 617 /**********************************************************************
 618  *          EMFDRV_SetBkColor
 619  */
 620 COLORREF
 621 EMFDRV_SetBkColor( PHYSDEV dev, COLORREF color )
 622 {
 623     EMRSETBKCOLOR emr;
 624
 625     emr.emr.iType = EMR_SETBKCOLOR;
 626     emr.emr.nSize = sizeof(emr);
 627     emr.crColor = color;
 628
 629     return EMFDRV_WriteRecord( dev, &emr.emr ) ? color : CLR_INVALID;
 630 }
 631
 632
 633 /**********************************************************************
 634  *          EMFDRV_SetTextColor
 635  */
 636 COLORREF
 637 EMFDRV_SetTextColor( PHYSDEV dev, COLORREF color )
 638 {
 639     EMRSETTEXTCOLOR emr;
 640
 641     emr.emr.iType = EMR_SETTEXTCOLOR;
 642     emr.emr.nSize = sizeof(emr);
 643     emr.crColor = color;
 644
 645     return EMFDRV_WriteRecord( dev, &emr.emr ) ? color : CLR_INVALID;
 646 }
 647
 648 /**********************************************************************
 649  *          EMFDRV_ExtTextOut
 650  */
 651 BOOL EMFDRV_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags,
 652                         const RECT *lprect, LPCWSTR str, UINT count,
 653                         const INT *lpDx )
 654 {
 655     EMREXTTEXTOUTW *pemr;
 656     DWORD nSize;
 657     BOOL ret;
 658     EMFDRV_PDEVICE *physDev = (EMFDRV_PDEVICE*) dev;
 659     int textHeight = 0;
 660     int textWidth = 0;
 661     const UINT textAlign = GetTextAlign(physDev->hdc);
 662
 663     nSize = sizeof(*pemr) + ((count+1) & ~1) * sizeof(WCHAR) + count * sizeof(INT);
 664
 665     TRACE("%s count %d nSize = %ld\n", debugstr_wn(str, count), count, nSize);
 666     pemr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nSize);
 667
 668     pemr->emr.iType = EMR_EXTTEXTOUTW;
 669     pemr->emr.nSize = nSize;
 670
 671     pemr->iGraphicsMode = GetGraphicsMode(physDev->hdc);
 672     pemr->exScale = pemr->eyScale = 1.0; /* FIXME */
 673
 674     pemr->emrtext.ptlReference.x = x;
 675     pemr->emrtext.ptlReference.y = y;
 676     pemr->emrtext.nChars = count;
 677     pemr->emrtext.offString = sizeof(*pemr);
 678     memcpy((char*)pemr + pemr->emrtext.offString, str, count * sizeof(WCHAR));
 679     pemr->emrtext.fOptions = flags;
 680     if(!lprect) {
 681         pemr->emrtext.rcl.left = pemr->emrtext.rcl.top = 0;
 682         pemr->emrtext.rcl.right = pemr->emrtext.rcl.bottom = -1;
 683     } else {
 684         pemr->emrtext.rcl.left = lprect->left;
 685         pemr->emrtext.rcl.top = lprect->top;
 686         pemr->emrtext.rcl.right = lprect->right;
 687         pemr->emrtext.rcl.bottom = lprect->bottom;
 688     }
 689
 690     pemr->emrtext.offDx = pemr->emrtext.offString + ((count+1) & ~1) * sizeof(WCHAR);
 691     if(lpDx) {
 692         UINT i;
 693         SIZE strSize;
 694         memcpy((char*)pemr + pemr->emrtext.offDx, lpDx, count * sizeof(INT));
 695         for (i = 0; i < count; i++) {
 696             textWidth += lpDx[i];
 697         }
 698         GetTextExtentPoint32W(physDev->hdc, str, count, &strSize);
 699         textHeight = strSize.cy;
 700     }
 701     else {
 702         UINT i;
 703         INT *dx = (INT *)((char*)pemr + pemr->emrtext.offDx);
 704         SIZE charSize;
 705         for (i = 0; i < count; i++) {
 706             GetTextExtentPoint32W(physDev->hdc, str + i, 1, &charSize);
 707             dx[i] = charSize.cx;
 708             textWidth += charSize.cx;
 709             textHeight = max(textHeight, charSize.cy);
 710         }
 711     }
 712
 713     switch (textAlign & (TA_LEFT | TA_RIGHT | TA_CENTER)) {
 714     case TA_CENTER: {
 715         pemr->rclBounds.left  = x - (textWidth / 2) - 1;
 716         pemr->rclBounds.right = x + (textWidth / 2) + 1;
 717         break;
 718     }
 719     case TA_RIGHT: {
 720         pemr->rclBounds.left  = x - textWidth - 1;
 721         pemr->rclBounds.right = x;
 722         break;
 723     }
 724     default: { /* TA_LEFT */
 725         pemr->rclBounds.left  = x;
 726         pemr->rclBounds.right = x + textWidth + 1;
 727     }
 728     }
 729
 730     switch (textAlign & (TA_TOP | TA_BOTTOM | TA_BASELINE)) {
 731     case TA_BASELINE: {
 732         TEXTMETRICW tm;
 733         GetTextMetricsW(physDev->hdc, &tm);
 734         /* Play safe here... it's better to have a bounding box */
 735         /* that is too big than too small. */
 736         pemr->rclBounds.top    = y - textHeight - 1;
 737         pemr->rclBounds.bottom = y + tm.tmDescent + 1;
 738         break;
 739     }
 740     case TA_BOTTOM: {
 741         pemr->rclBounds.top    = y - textHeight - 1;
 742         pemr->rclBounds.bottom = y;
 743         break;
 744     }
 745     default: { /* TA_TOP */
 746         pemr->rclBounds.top    = y;
 747         pemr->rclBounds.bottom = y + textHeight + 1;
 748     }
 749     }
 750
 751     ret = EMFDRV_WriteRecord( dev, &pemr->emr );
 752     if(ret)
 753         EMFDRV_UpdateBBox( dev, &pemr->rclBounds );
 754     HeapFree( GetProcessHeap(), 0, pemr );
 755     return ret;
 756 }
 757
 758 /**********************************************************************
 759  *          EMFDRV_SetArcDirection
 760  */
 761 INT EMFDRV_SetArcDirection(PHYSDEV dev, INT arcDirection)
 762 {
 763     EMRSETARCDIRECTION emr;
 764
 765     emr.emr.iType = EMR_SETARCDIRECTION;
 766     emr.emr.nSize = sizeof(emr);
 767     emr.iArcDirection = arcDirection;
 768
 769     EMFDRV_WriteRecord(dev, &emr.emr);
 770
 771     /* We don't know the old arc direction and we don't care... */
 772     return 0;
 773 }