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