git.oblomov.eu Git - wine/blob - graphics/x11drv/graphics.c

   1 /*
   2  * X11 graphics driver graphics functions
   3  *
   4  * Copyright 1993,1994 Alexandre Julliard
   5  */
   6
   7
   8 /*
   9  * FIXME: none of these functions obey the GM_ADVANCED
  10  * graphics mode
  11  */
  12
  13 #include <math.h>
  14 #ifdef HAVE_FLOAT_H
  15 # include <float.h>
  16 #endif
  17 #include <stdlib.h>
  18 #include "ts_xlib.h"
  19 #include "ts_xutil.h"
  20 #include <X11/Intrinsic.h>
  21 #ifndef PI
  22 #define PI M_PI
  23 #endif
  24 #include <string.h>
  25
  26 #include "x11drv.h"
  27 #include "x11font.h"
  28 #include "bitmap.h"
  29 #include "gdi.h"
  30 #include "graphics.h"
  31 #include "dc.h"
  32 #include "bitmap.h"
  33 #include "callback.h"
  34 #include "metafile.h"
  35 #include "palette.h"
  36 #include "color.h"
  37 #include "region.h"
  38 #include "struct32.h"
  39 #include "debug.h"
  40 #include "xmalloc.h"
  41
  42 #define ABS(x)    ((x)<0?(-(x)):(x))
  43
  44   /* ROP code to GC function conversion */
  45 const int X11DRV_XROPfunction[16] =
  46 {
  47     GXclear,        /* R2_BLACK */
  48     GXnor,          /* R2_NOTMERGEPEN */
  49     GXandInverted,  /* R2_MASKNOTPEN */
  50     GXcopyInverted, /* R2_NOTCOPYPEN */
  51     GXandReverse,   /* R2_MASKPENNOT */
  52     GXinvert,       /* R2_NOT */
  53     GXxor,          /* R2_XORPEN */
  54     GXnand,         /* R2_NOTMASKPEN */
  55     GXand,          /* R2_MASKPEN */
  56     GXequiv,        /* R2_NOTXORPEN */
  57     GXnoop,         /* R2_NOP */
  58     GXorInverted,   /* R2_MERGENOTPEN */
  59     GXcopy,         /* R2_COPYPEN */
  60     GXorReverse,    /* R2_MERGEPENNOT */
  61     GXor,           /* R2_MERGEPEN */
  62     GXset           /* R2_WHITE */
  63 };
  64
  65
  66 /***********************************************************************
  67  *           X11DRV_SetupGCForPatBlt
  68  *
  69  * Setup the GC for a PatBlt operation using current brush.
  70  * If fMapColors is TRUE, X pixels are mapped to Windows colors.
  71  * Return FALSE if brush is BS_NULL, TRUE otherwise.
  72  */
  73 BOOL32 X11DRV_SetupGCForPatBlt( DC * dc, GC gc, BOOL32 fMapColors )
  74 {
  75     XGCValues val;
  76     unsigned long mask;
  77     Pixmap pixmap = 0;
  78
  79     if (dc->u.x.brush.style == BS_NULL) return FALSE;
  80     if (dc->u.x.brush.pixel == -1)
  81     {
  82         /* Special case used for monochrome pattern brushes.
  83          * We need to swap foreground and background because
  84          * Windows does it the wrong way...
  85          */
  86         val.foreground = dc->u.x.backgroundPixel;
  87         val.background = dc->u.x.textPixel;
  88     }
  89     else
  90     {
  91         val.foreground = dc->u.x.brush.pixel;
  92         val.background = dc->u.x.backgroundPixel;
  93     }
  94     if (fMapColors && COLOR_PixelToPalette)
  95     {
  96         val.foreground = COLOR_PixelToPalette[val.foreground];
  97         val.background = COLOR_PixelToPalette[val.background];
  98     }
  99
 100     if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
 101
 102     val.function = X11DRV_XROPfunction[dc->w.ROPmode-1];
 103     /*
 104     ** Let's replace GXinvert by GXxor with (black xor white)
 105     ** This solves the selection color and leak problems in excel
 106     ** FIXME : Let's do that only if we work with X-pixels, not with Win-pixels
 107     */
 108     if (val.function == GXinvert)
 109         {
 110         val.foreground = BlackPixelOfScreen(screen) ^ WhitePixelOfScreen(screen);
 111         val.function = GXxor;
 112         }
 113     val.fill_style = dc->u.x.brush.fillStyle;
 114     switch(val.fill_style)
 115     {
 116     case FillStippled:
 117     case FillOpaqueStippled:
 118         if (dc->w.backgroundMode==OPAQUE) val.fill_style = FillOpaqueStippled;
 119         val.stipple = dc->u.x.brush.pixmap;
 120         mask = GCStipple;
 121         break;
 122
 123     case FillTiled:
 124         if (fMapColors && COLOR_PixelToPalette)
 125         {
 126             register int x, y;
 127             XImage *image;
 128             EnterCriticalSection( &X11DRV_CritSection );
 129             pixmap = XCreatePixmap( display, rootWindow, 8, 8, screenDepth );
 130             image = XGetImage( display, dc->u.x.brush.pixmap, 0, 0, 8, 8,
 131                                AllPlanes, ZPixmap );
 132             for (y = 0; y < 8; y++)
 133                 for (x = 0; x < 8; x++)
 134                     XPutPixel( image, x, y,
 135                                COLOR_PixelToPalette[XGetPixel( image, x, y)] );
 136             XPutImage( display, pixmap, gc, image, 0, 0, 0, 0, 8, 8 );
 137             XDestroyImage( image );
 138             LeaveCriticalSection( &X11DRV_CritSection );
 139             val.tile = pixmap;
 140         }
 141         else val.tile = dc->u.x.brush.pixmap;
 142         mask = GCTile;
 143         break;
 144
 145     default:
 146         mask = 0;
 147         break;
 148     }
 149     val.ts_x_origin = dc->w.DCOrgX + dc->w.brushOrgX;
 150     val.ts_y_origin = dc->w.DCOrgY + dc->w.brushOrgY;
 151     val.fill_rule = (dc->w.polyFillMode==WINDING) ? WindingRule : EvenOddRule;
 152     TSXChangeGC( display, gc,
 153                GCFunction | GCForeground | GCBackground | GCFillStyle |
 154                GCFillRule | GCTileStipXOrigin | GCTileStipYOrigin | mask,
 155                &val );
 156     if (pixmap) TSXFreePixmap( display, pixmap );
 157     return TRUE;
 158 }
 159
 160
 161 /***********************************************************************
 162  *           X11DRV_SetupGCForBrush
 163  *
 164  * Setup dc->u.x.gc for drawing operations using current brush.
 165  * Return FALSE if brush is BS_NULL, TRUE otherwise.
 166  */
 167 BOOL32 X11DRV_SetupGCForBrush( DC * dc )
 168 {
 169     return X11DRV_SetupGCForPatBlt( dc, dc->u.x.gc, FALSE );
 170 }
 171
 172
 173 /***********************************************************************
 174  *           X11DRV_SetupGCForPen
 175  *
 176  * Setup dc->u.x.gc for drawing operations using current pen.
 177  * Return FALSE if pen is PS_NULL, TRUE otherwise.
 178  */
 179 BOOL32 X11DRV_SetupGCForPen( DC * dc )
 180 {
 181     XGCValues val;
 182
 183     if (dc->u.x.pen.style == PS_NULL) return FALSE;
 184
 185     if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
 186
 187     switch (dc->w.ROPmode)
 188     {
 189     case R2_BLACK :
 190         val.foreground = BlackPixelOfScreen( screen );
 191         val.function = GXcopy;
 192         break;
 193     case R2_WHITE :
 194         val.foreground = WhitePixelOfScreen( screen );
 195         val.function = GXcopy;
 196         break;
 197     case R2_XORPEN :
 198         val.foreground = dc->u.x.pen.pixel;
 199         /* It is very unlikely someone wants to XOR with 0 */
 200         /* This fixes the rubber-drawings in paintbrush */
 201         if (val.foreground == 0)
 202             val.foreground = BlackPixelOfScreen( screen )
 203                             ^ WhitePixelOfScreen( screen );
 204         val.function = GXxor;
 205         break;
 206     default :
 207         val.foreground = dc->u.x.pen.pixel;
 208         val.function   = X11DRV_XROPfunction[dc->w.ROPmode-1];
 209     }
 210     val.background = dc->u.x.backgroundPixel;
 211     val.fill_style = FillSolid;
 212     if ((dc->u.x.pen.style!=PS_SOLID) && (dc->u.x.pen.style!=PS_INSIDEFRAME))
 213     {
 214         TSXSetDashes( display, dc->u.x.gc, 0,
 215                     dc->u.x.pen.dashes, dc->u.x.pen.dash_len );
 216         val.line_style = (dc->w.backgroundMode == OPAQUE) ?
 217                               LineDoubleDash : LineOnOffDash;
 218     }
 219     else val.line_style = LineSolid;
 220     val.line_width = dc->u.x.pen.width;
 221     if (val.line_width <= 1) {
 222         val.cap_style = CapNotLast;
 223     } else {
 224         switch (dc->u.x.pen.endcap)
 225         {
 226         case PS_ENDCAP_SQUARE:
 227             val.cap_style = CapProjecting;
 228             break;
 229         case PS_ENDCAP_FLAT:
 230             val.cap_style = CapButt;
 231             break;
 232         case PS_ENDCAP_ROUND:
 233         default:
 234             val.cap_style = CapRound;
 235         }
 236     }
 237     switch (dc->u.x.pen.linejoin)
 238     {
 239     case PS_JOIN_BEVEL:
 240         val.join_style = JoinBevel;
 241         break;
 242     case PS_JOIN_MITER:
 243         val.join_style = JoinMiter;
 244         break;
 245     case PS_JOIN_ROUND:
 246     default:
 247         val.join_style = JoinRound;
 248     }
 249     TSXChangeGC( display, dc->u.x.gc,
 250                GCFunction | GCForeground | GCBackground | GCLineWidth |
 251                GCLineStyle | GCCapStyle | GCJoinStyle | GCFillStyle, &val );
 252     return TRUE;
 253 }
 254
 255
 256 /***********************************************************************
 257  *           X11DRV_SetupGCForText
 258  *
 259  * Setup dc->u.x.gc for text drawing operations.
 260  * Return FALSE if the font is null, TRUE otherwise.
 261  */
 262 BOOL32 X11DRV_SetupGCForText( DC * dc )
 263 {
 264     XFontStruct* xfs = XFONT_GetFontStruct( dc->u.x.font );
 265
 266     if( xfs )
 267     {
 268         XGCValues val;
 269
 270         if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc);
 271
 272         val.function   = GXcopy;  /* Text is always GXcopy */
 273         val.foreground = dc->u.x.textPixel;
 274         val.background = dc->u.x.backgroundPixel;
 275         val.fill_style = FillSolid;
 276         val.font       = xfs->fid;
 277
 278         TSXChangeGC( display, dc->u.x.gc,
 279                    GCFunction | GCForeground | GCBackground | GCFillStyle |
 280                    GCFont, &val );
 281         return TRUE;
 282     }
 283     WARN(dc, "Physical font failure\n" );
 284     return FALSE;
 285 }
 286
 287
 288
 289
 290
 291 /**********************************************************************
 292  *           X11DRV_MoveToEx
 293  */
 294 BOOL32
 295 X11DRV_MoveToEx(DC *dc,INT32 x,INT32 y,LPPOINT32 pt) {
 296     if (pt)
 297     {
 298         pt->x = dc->w.CursPosX;
 299         pt->y = dc->w.CursPosY;
 300     }
 301     dc->w.CursPosX = x;
 302     dc->w.CursPosY = y;
 303     return TRUE;
 304 }
 305
 306 /***********************************************************************
 307  *           X11DRV_LineTo
 308  */
 309 BOOL32
 310 X11DRV_LineTo( DC *dc, INT32 x, INT32 y )
 311 {
 312     if (X11DRV_SetupGCForPen( dc ))
 313         TSXDrawLine(display, dc->u.x.drawable, dc->u.x.gc,
 314                   dc->w.DCOrgX + XLPTODP( dc, dc->w.CursPosX ),
 315                   dc->w.DCOrgY + YLPTODP( dc, dc->w.CursPosY ),
 316                   dc->w.DCOrgX + XLPTODP( dc, x ),
 317                   dc->w.DCOrgY + YLPTODP( dc, y ) );
 318     dc->w.CursPosX = x;
 319     dc->w.CursPosY = y;
 320     return TRUE;
 321 }
 322
 323
 324
 325 /***********************************************************************
 326  *           GRAPH_DrawArc
 327  *
 328  * Helper functions for Arc(), Chord() and Pie().
 329  * 'lines' is the number of lines to draw: 0 for Arc, 1 for Chord, 2 for Pie.
 330  *
 331  */
 332 static BOOL32
 333 X11DRV_DrawArc( DC *dc, INT32 left, INT32 top, INT32 right,
 334                 INT32 bottom, INT32 xstart, INT32 ystart,
 335                 INT32 xend, INT32 yend, INT32 lines )
 336 {
 337     INT32 xcenter, ycenter, istart_angle, idiff_angle;
 338     INT32 width, oldwidth, oldendcap;
 339     double start_angle, end_angle;
 340     XPoint points[4];
 341
 342     left   = XLPTODP( dc, left );
 343     top    = YLPTODP( dc, top );
 344     right  = XLPTODP( dc, right );
 345     bottom = YLPTODP( dc, bottom );
 346     xstart = XLPTODP( dc, xstart );
 347     ystart = YLPTODP( dc, ystart );
 348     xend   = XLPTODP( dc, xend );
 349     yend   = YLPTODP( dc, yend );
 350
 351     if (right < left) { INT32 tmp = right; right = left; left = tmp; }
 352     if (bottom < top) { INT32 tmp = bottom; bottom = top; top = tmp; }
 353     if ((left == right) || (top == bottom)
 354             ||(lines && ((right-left==1)||(bottom-top==1)))) return TRUE;
 355
 356     oldwidth = width = dc->u.x.pen.width;
 357     oldendcap= dc->u.x.pen.endcap;
 358     if (!width) width = 1;
 359     if(dc->u.x.pen.style == PS_NULL) width = 0;
 360
 361     if ((dc->u.x.pen.style == PS_INSIDEFRAME))
 362     {
 363         if (2*width > (right-left)) width=(right-left + 1)/2;
 364         if (2*width > (bottom-top)) width=(bottom-top + 1)/2;
 365         left   += width / 2;
 366         right  -= (width - 1) / 2;
 367         top    += width / 2;
 368         bottom -= (width - 1) / 2;
 369     }
 370     if(width == 0) width=1; /* more accurate */
 371     dc->u.x.pen.width=width;
 372     dc->u.x.pen.endcap=PS_ENDCAP_SQUARE;
 373
 374     xcenter = (right + left) / 2;
 375     ycenter = (bottom + top) / 2;
 376     start_angle = atan2( (double)(ycenter-ystart)*(right-left),
 377                          (double)(xstart-xcenter)*(bottom-top) );
 378     end_angle   = atan2( (double)(ycenter-yend)*(right-left),
 379                          (double)(xend-xcenter)*(bottom-top) );
 380     if ((xstart==xend)&&(ystart==yend))
 381       { /* A lazy program delivers xstart=xend=ystart=yend=0) */
 382         start_angle = 0;
 383         end_angle = 2* PI;
 384       }
 385     else /* notorious cases */
 386       if ((start_angle == PI)&&( end_angle <0))
 387         start_angle = - PI;
 388     else
 389       if ((end_angle == PI)&&( start_angle <0))
 390         end_angle = - PI;
 391     istart_angle = (INT32)(start_angle * 180 * 64 / PI + 0.5);
 392     idiff_angle  = (INT32)((end_angle - start_angle) * 180 * 64 / PI + 0.5);
 393     if (idiff_angle <= 0) idiff_angle += 360 * 64;
 394
 395       /* Fill arc with brush if Chord() or Pie() */
 396
 397     if ((lines > 0) && X11DRV_SetupGCForBrush( dc )) {
 398         TSXSetArcMode( display, dc->u.x.gc, (lines==1) ? ArcChord : ArcPieSlice);
 399         TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 400                  dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 401                  right-left-1, bottom-top-1, istart_angle, idiff_angle );
 402     }
 403
 404       /* Draw arc and lines */
 405
 406     if (X11DRV_SetupGCForPen( dc )){
 407     TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 408               dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 409               right-left-1, bottom-top-1, istart_angle, idiff_angle );
 410         if (lines) {
 411             /* use the truncated values */
 412             start_angle=(double)istart_angle*PI/64./180.;
 413             end_angle=(double)(istart_angle+idiff_angle)*PI/64./180.;
 414             /* calculate the endpoints and round correctly */
 415             points[0].x = (int) floor(dc->w.DCOrgX + (right+left)/2.0 +
 416                     cos(start_angle) * (right-left-width*2+2) / 2. + 0.5);
 417             points[0].y = (int) floor(dc->w.DCOrgY + (top+bottom)/2.0 -
 418                     sin(start_angle) * (bottom-top-width*2+2) / 2. + 0.5);
 419             points[1].x = (int) floor(dc->w.DCOrgX + (right+left)/2.0 +
 420                     cos(end_angle) * (right-left-width*2+2) / 2. + 0.5);
 421             points[1].y = (int) floor(dc->w.DCOrgY + (top+bottom)/2.0 -
 422                     sin(end_angle) * (bottom-top-width*2+2) / 2. + 0.5);
 423
 424             /* OK this stuff is optimized for Xfree86
 425              * which is probably the most used server by
 426              * wine users. Other X servers will not
 427              * display correctly. (eXceed for instance)
 428              * so if you feel you must change make sure that
 429              * you either use Xfree86 or seperate your changes
 430              * from these (compile switch or whatever)
 431              */
 432             if (lines == 2) {
 433                 INT32 dx1,dy1;
 434                 points[3] = points[1];
 435         points[1].x = dc->w.DCOrgX + xcenter;
 436         points[1].y = dc->w.DCOrgY + ycenter;
 437                 points[2] = points[1];
 438                 dx1=points[1].x-points[0].x;
 439                 dy1=points[1].y-points[0].y;
 440                 if(((top-bottom) | -2) == -2)
 441                     if(dy1>0) points[1].y--;
 442                 if(dx1<0) {
 443                     if (((-dx1)*64)<=ABS(dy1)*37) points[0].x--;
 444                     if(((-dx1*9))<(dy1*16)) points[0].y--;
 445                     if( dy1<0 && ((dx1*9)) < (dy1*16)) points[0].y--;
 446                 } else {
 447                     if(dy1 < 0)  points[0].y--;
 448                     if(((right-left) | -2) == -2) points[1].x--;
 449                 }
 450                 dx1=points[3].x-points[2].x;
 451                 dy1=points[3].y-points[2].y;
 452                 if(((top-bottom) | -2 ) == -2)
 453                     if(dy1 < 0) points[2].y--;
 454                 if( dx1<0){
 455                     if( dy1>0) points[3].y--;
 456                     if(((right-left) | -2) == -2 ) points[2].x--;
 457                 }else {
 458                     points[3].y--;
 459                     if( dx1 * 64 < dy1 * -37 ) points[3].x--;
 460                 }
 461                 lines++;
 462     }
 463     TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
 464                 points, lines+1, CoordModeOrigin );
 465         }
 466     }
 467     dc->u.x.pen.width=oldwidth;
 468     dc->u.x.pen.endcap=oldendcap;
 469     return TRUE;
 470 }
 471
 472
 473 /***********************************************************************
 474  *           X11DRV_Arc
 475  */
 476 BOOL32
 477 X11DRV_Arc( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom,
 478             INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
 479 {
 480     return X11DRV_DrawArc( dc, left, top, right, bottom,
 481                            xstart, ystart, xend, yend, 0 );
 482 }
 483
 484
 485 /***********************************************************************
 486  *           X11DRV_Pie
 487  */
 488 BOOL32
 489 X11DRV_Pie( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom,
 490             INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
 491 {
 492     return X11DRV_DrawArc( dc, left, top, right, bottom,
 493                            xstart, ystart, xend, yend, 2 );
 494 }
 495
 496 /***********************************************************************
 497  *           X11DRV_Chord
 498  */
 499 BOOL32
 500 X11DRV_Chord( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom,
 501               INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
 502 {
 503     return X11DRV_DrawArc( dc, left, top, right, bottom,
 504                            xstart, ystart, xend, yend, 1 );
 505 }
 506
 507
 508 /***********************************************************************
 509  *           X11DRV_Ellipse
 510  */
 511 BOOL32
 512 X11DRV_Ellipse( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom )
 513 {
 514     INT32 width, oldwidth;
 515     left   = XLPTODP( dc, left );
 516     top    = YLPTODP( dc, top );
 517     right  = XLPTODP( dc, right );
 518     bottom = YLPTODP( dc, bottom );
 519     if ((left == right) || (top == bottom)) return TRUE;
 520
 521     if (right < left) { INT32 tmp = right; right = left; left = tmp; }
 522     if (bottom < top) { INT32 tmp = bottom; bottom = top; top = tmp; }
 523
 524     oldwidth = width = dc->u.x.pen.width;
 525     if (!width) width = 1;
 526     if(dc->u.x.pen.style == PS_NULL) width = 0;
 527
 528     if ((dc->u.x.pen.style == PS_INSIDEFRAME))
 529     {
 530         if (2*width > (right-left)) width=(right-left + 1)/2;
 531         if (2*width > (bottom-top)) width=(bottom-top + 1)/2;
 532         left   += width / 2;
 533         right  -= (width - 1) / 2;
 534         top    += width / 2;
 535         bottom -= (width - 1) / 2;
 536     }
 537     if(width == 0) width=1; /* more accurate */
 538     dc->u.x.pen.width=width;
 539
 540     if (X11DRV_SetupGCForBrush( dc ))
 541         TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 542                   dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 543                   right-left-1, bottom-top-1, 0, 360*64 );
 544     if (X11DRV_SetupGCForPen( dc ))
 545         TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 546                   dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 547                   right-left-1, bottom-top-1, 0, 360*64 );
 548     dc->u.x.pen.width=oldwidth;
 549     return TRUE;
 550 }
 551
 552
 553 /***********************************************************************
 554  *           X11DRV_Rectangle
 555  */
 556 BOOL32
 557 X11DRV_Rectangle(DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom)
 558 {
 559     INT32 width, oldwidth, oldjoinstyle;
 560
 561     TRACE(graphics, "(%d %d %d %d)\n",
 562         left, top, right, bottom);
 563
 564     left   = XLPTODP( dc, left );
 565     top    = YLPTODP( dc, top );
 566     right  = XLPTODP( dc, right );
 567     bottom = YLPTODP( dc, bottom );
 568
 569     if ((left == right) || (top == bottom)) return TRUE;
 570
 571     if (right < left) { INT32 tmp = right; right = left; left = tmp; }
 572     if (bottom < top) { INT32 tmp = bottom; bottom = top; top = tmp; }
 573
 574     oldwidth = width = dc->u.x.pen.width;
 575     if (!width) width = 1;
 576     if(dc->u.x.pen.style == PS_NULL) width = 0;
 577
 578     if ((dc->u.x.pen.style == PS_INSIDEFRAME))
 579     {
 580         if (2*width > (right-left)) width=(right-left + 1)/2;
 581         if (2*width > (bottom-top)) width=(bottom-top + 1)/2;
 582         left   += width / 2;
 583         right  -= (width - 1) / 2;
 584         top    += width / 2;
 585         bottom -= (width - 1) / 2;
 586     }
 587     if(width == 1) width=0;
 588     dc->u.x.pen.width=width;
 589     oldjoinstyle=dc->u.x.pen.linejoin;
 590     if(dc->u.x.pen.type!=PS_GEOMETRIC)
 591             dc->u.x.pen.linejoin=PS_JOIN_MITER;
 592
 593     if ((right > left + width) && (bottom > top + width))
 594     {
 595         if (X11DRV_SetupGCForBrush( dc ))
 596             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 597                             dc->w.DCOrgX + left + (width + 1) / 2,
 598                             dc->w.DCOrgY + top + (width + 1) / 2,
 599                             right-left-width-1, bottom-top-width-1);
 600     }
 601     if (X11DRV_SetupGCForPen( dc ))
 602         TSXDrawRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 603                         dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 604                         right-left-1, bottom-top-1 );
 605
 606     dc->u.x.pen.width=oldwidth;
 607     dc->u.x.pen.linejoin=oldjoinstyle;
 608     return TRUE;
 609 }
 610
 611 /***********************************************************************
 612  *           X11DRV_RoundRect
 613  */
 614 BOOL32
 615 X11DRV_RoundRect( DC *dc, INT32 left, INT32 top, INT32 right,
 616                   INT32 bottom, INT32 ell_width, INT32 ell_height )
 617 {
 618     INT32 width, oldwidth, oldendcap;
 619
 620     TRACE(graphics, "(%d %d %d %d  %d %d\n",
 621         left, top, right, bottom, ell_width, ell_height);
 622
 623     left   = XLPTODP( dc, left );
 624     top    = YLPTODP( dc, top );
 625     right  = XLPTODP( dc, right );
 626     bottom = YLPTODP( dc, bottom );
 627
 628     if ((left == right) || (top == bottom))
 629         return TRUE;
 630
 631     /* Make sure ell_width and ell_height are >= 1 otherwise XDrawArc gets
 632        called with width/height < 0 */
 633     ell_width  = MAX(abs( ell_width * dc->vportExtX / dc->wndExtX ), 1);
 634     ell_height = MAX(abs( ell_height * dc->vportExtY / dc->wndExtY ), 1);
 635
 636     /* Fix the coordinates */
 637
 638     if (right < left) { INT32 tmp = right; right = left; left = tmp; }
 639     if (bottom < top) { INT32 tmp = bottom; bottom = top; top = tmp; }
 640
 641     oldwidth=width = dc->u.x.pen.width;
 642     oldendcap = dc->u.x.pen.endcap;
 643     if (!width) width = 1;
 644     if(dc->u.x.pen.style == PS_NULL) width = 0;
 645
 646     if ((dc->u.x.pen.style == PS_INSIDEFRAME))
 647     {
 648         if (2*width > (right-left)) width=(right-left + 1)/2;
 649         if (2*width > (bottom-top)) width=(bottom-top + 1)/2;
 650         left   += width / 2;
 651         right  -= (width - 1) / 2;
 652         top    += width / 2;
 653         bottom -= (width - 1) / 2;
 654     }
 655     if(width == 0) width=1;
 656     dc->u.x.pen.width=width;
 657     dc->u.x.pen.endcap=PS_ENDCAP_SQUARE;
 658
 659     if (X11DRV_SetupGCForBrush( dc ))
 660     {
 661         if (ell_width > (right-left) )
 662             if (ell_height > (bottom-top) )
 663                     TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 664                               dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 665                               right - left - 1, bottom - top - 1,
 666                               0, 360 * 64 );
 667             else{
 668                     TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 669                               dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 670                               right - left - 1, ell_height, 0, 180 * 64 );
 671                     TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 672                               dc->w.DCOrgX + left,
 673                               dc->w.DCOrgY + bottom - ell_height - 1,
 674                               right - left - 1, ell_height, 180 * 64, 180 * 64 );
 675            }
 676         else if (ell_height > (bottom-top) ){
 677                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 678                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 679                       ell_width, bottom - top - 1, 90 * 64, 180 * 64 );
 680                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 681                       dc->w.DCOrgX + right - ell_width -1, dc->w.DCOrgY + top,
 682                       ell_width, bottom - top - 1, 270 * 64, 180 * 64 );
 683         }else{
 684                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 685                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 686                       ell_width, ell_height, 90 * 64, 90 * 64 );
 687                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 688                       dc->w.DCOrgX + left,
 689                       dc->w.DCOrgY + bottom - ell_height - 1,
 690                       ell_width, ell_height, 180 * 64, 90 * 64 );
 691                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 692                       dc->w.DCOrgX + right - ell_width - 1,
 693                       dc->w.DCOrgY + bottom - ell_height - 1,
 694                       ell_width, ell_height, 270 * 64, 90 * 64 );
 695                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 696                       dc->w.DCOrgX + right - ell_width - 1,
 697                       dc->w.DCOrgY + top,
 698                       ell_width, ell_height, 0, 90 * 64 );
 699         }
 700         if (ell_width < right - left)
 701         {
 702             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 703                             dc->w.DCOrgX + left + (ell_width + 1) / 2,
 704                             dc->w.DCOrgY + top + 1,
 705                             right - left - ell_width - 1,
 706                             (ell_height + 1) / 2 - 1);
 707             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 708                             dc->w.DCOrgX + left + (ell_width + 1) / 2,
 709                             dc->w.DCOrgY + bottom - (ell_height) / 2 - 1,
 710                             right - left - ell_width - 1,
 711                             (ell_height) / 2 );
 712         }
 713         if  (ell_height < bottom - top)
 714         {
 715             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 716                             dc->w.DCOrgX + left + 1,
 717                             dc->w.DCOrgY + top + (ell_height + 1) / 2,
 718                             right - left - 2,
 719                             bottom - top - ell_height - 1);
 720         }
 721     }
 722     /* FIXME: this could be done with on X call
 723      * more efficient and probably more correct
 724      * on any X server: XDrawArcs will draw
 725      * straight horizontal and vertical lines
 726      * if width or height are zero.
 727      *
 728      * BTW this stuff is optimized for an Xfree86 server
 729      * read the comments inside the X11DRV_DrawArc function
 730      */
 731     if (X11DRV_SetupGCForPen(dc)) {
 732         if (ell_width > (right-left) )
 733             if (ell_height > (bottom-top) )
 734                 TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 735                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 736                       right - left - 1, bottom -top - 1, 0 , 360 * 64 );
 737             else{
 738                 TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 739                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 740                       right - left - 1, ell_height - 1, 0 , 180 * 64 );
 741                 TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 742                       dc->w.DCOrgX + left,
 743                       dc->w.DCOrgY + bottom - ell_height,
 744                       right - left - 1, ell_height - 1, 180 * 64 , 180 * 64 );
 745             }
 746         else if (ell_height > (bottom-top) ){
 747                 TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 748                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 749                       ell_width - 1 , bottom - top - 1, 90 * 64 , 180 * 64 );
 750                 TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 751                       dc->w.DCOrgX + right - ell_width,
 752                       dc->w.DCOrgY + top,
 753                       ell_width - 1 , bottom - top - 1, 270 * 64 , 180 * 64 );
 754         }else{
 755             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 756                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 757                       ell_width - 1, ell_height - 1, 90 * 64, 90 * 64 );
 758             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 759                       dc->w.DCOrgX + left, dc->w.DCOrgY + bottom - ell_height,
 760                       ell_width - 1, ell_height - 1, 180 * 64, 90 * 64 );
 761             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 762                       dc->w.DCOrgX + right - ell_width,
 763                       dc->w.DCOrgY + bottom - ell_height,
 764                       ell_width - 1, ell_height - 1, 270 * 64, 90 * 64 );
 765             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 766                       dc->w.DCOrgX + right - ell_width, dc->w.DCOrgY + top,
 767                       ell_width - 1, ell_height - 1, 0, 90 * 64 );
 768         }
 769         if (ell_width < right - left)
 770         {
 771             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc,
 772                dc->w.DCOrgX + left + ell_width / 2,
 773                        dc->w.DCOrgY + top,
 774                dc->w.DCOrgX + right - (ell_width+1) / 2,
 775                        dc->w.DCOrgY + top);
 776             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc,
 777                dc->w.DCOrgX + left + ell_width / 2 ,
 778                        dc->w.DCOrgY + bottom - 1,
 779                dc->w.DCOrgX + right - (ell_width+1)/ 2,
 780                        dc->w.DCOrgY + bottom - 1);
 781         }
 782         if (ell_height < bottom - top)
 783         {
 784             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc,
 785                        dc->w.DCOrgX + right - 1,
 786                dc->w.DCOrgY + top + ell_height / 2,
 787                        dc->w.DCOrgX + right - 1,
 788                dc->w.DCOrgY + bottom - (ell_height+1) / 2);
 789             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc,
 790                        dc->w.DCOrgX + left,
 791                dc->w.DCOrgY + top + ell_height / 2,
 792                        dc->w.DCOrgX + left,
 793                dc->w.DCOrgY + bottom - (ell_height+1) / 2);
 794         }
 795     }
 796     dc->u.x.pen.width=oldwidth;
 797     dc->u.x.pen.endcap=oldendcap;
 798     return TRUE;
 799 }
 800
 801
 802 /***********************************************************************
 803  *           X11DRV_SetPixel
 804  */
 805 COLORREF
 806 X11DRV_SetPixel( DC *dc, INT32 x, INT32 y, COLORREF color )
 807 {
 808     Pixel pixel;
 809
 810     x = dc->w.DCOrgX + XLPTODP( dc, x );
 811     y = dc->w.DCOrgY + YLPTODP( dc, y );
 812     pixel = COLOR_ToPhysical( dc, color );
 813
 814     TSXSetForeground( display, dc->u.x.gc, pixel );
 815     TSXSetFunction( display, dc->u.x.gc, GXcopy );
 816     TSXDrawPoint( display, dc->u.x.drawable, dc->u.x.gc, x, y );
 817
 818     /* inefficient but simple... */
 819
 820     return COLOR_ToLogical(pixel);
 821 }
 822
 823
 824 /***********************************************************************
 825  *           X11DRV_GetPixel
 826  */
 827 COLORREF
 828 X11DRV_GetPixel( DC *dc, INT32 x, INT32 y )
 829 {
 830     static Pixmap pixmap = 0;
 831     XImage * image;
 832     int pixel;
 833
 834     x = dc->w.DCOrgX + XLPTODP( dc, x );
 835     y = dc->w.DCOrgY + YLPTODP( dc, y );
 836     EnterCriticalSection( &X11DRV_CritSection );
 837     if (dc->w.flags & DC_MEMORY)
 838     {
 839         image = XGetImage( display, dc->u.x.drawable, x, y, 1, 1,
 840                            AllPlanes, ZPixmap );
 841     }
 842     else
 843     {
 844         /* If we are reading from the screen, use a temporary copy */
 845         /* to avoid a BadMatch error */
 846         if (!pixmap) pixmap = XCreatePixmap( display, rootWindow,
 847                                              1, 1, dc->w.bitsPerPixel );
 848         XCopyArea( display, dc->u.x.drawable, pixmap, BITMAP_colorGC,
 849                    x, y, 1, 1, 0, 0 );
 850         image = XGetImage( display, pixmap, 0, 0, 1, 1, AllPlanes, ZPixmap );
 851     }
 852     pixel = XGetPixel( image, 0, 0 );
 853     XDestroyImage( image );
 854     LeaveCriticalSection( &X11DRV_CritSection );
 855
 856     return COLOR_ToLogical(pixel);
 857 }
 858
 859
 860 /***********************************************************************
 861  *           X11DRV_PaintRgn
 862  */
 863 BOOL32
 864 X11DRV_PaintRgn( DC *dc, HRGN32 hrgn )
 865 {
 866     RECT32 box;
 867     HRGN32 tmpVisRgn, prevVisRgn;
 868     HDC32  hdc = dc->hSelf; /* FIXME: should not mix dc/hdc this way */
 869
 870     if (!(tmpVisRgn = CreateRectRgn32( 0, 0, 0, 0 ))) return FALSE;
 871
 872       /* Transform region into device co-ords */
 873     if (  !REGION_LPTODP( hdc, tmpVisRgn, hrgn )
 874         || OffsetRgn32( tmpVisRgn, dc->w.DCOrgX, dc->w.DCOrgY ) == ERROR) {
 875         DeleteObject32( tmpVisRgn );
 876         return FALSE;
 877     }
 878
 879       /* Modify visible region */
 880     if (!(prevVisRgn = SaveVisRgn( hdc ))) {
 881         DeleteObject32( tmpVisRgn );
 882         return FALSE;
 883     }
 884     CombineRgn32( tmpVisRgn, prevVisRgn, tmpVisRgn, RGN_AND );
 885     SelectVisRgn( hdc, tmpVisRgn );
 886     DeleteObject32( tmpVisRgn );
 887
 888       /* Fill the region */
 889
 890     GetRgnBox32( dc->w.hGCClipRgn, &box );
 891     if (X11DRV_SetupGCForBrush( dc ))
 892         TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 893                           box.left, box.top,
 894                           box.right-box.left, box.bottom-box.top );
 895
 896       /* Restore the visible region */
 897
 898     RestoreVisRgn( hdc );
 899     return TRUE;
 900 }
 901
 902 /**********************************************************************
 903  *          X11DRV_Polyline
 904  */
 905 BOOL32
 906 X11DRV_Polyline( DC *dc, const POINT32* pt, INT32 count )
 907 {
 908     INT32 oldwidth;
 909     register int i;
 910     XPoint *points;
 911     if((oldwidth=dc->u.x.pen.width)==0) dc->u.x.pen.width=1;
 912
 913     points = (XPoint *) xmalloc (sizeof (XPoint) * (count));
 914     for (i = 0; i < count; i++)
 915     {
 916     points[i].x = dc->w.DCOrgX + XLPTODP( dc, pt[i].x );
 917     points[i].y = dc->w.DCOrgY + YLPTODP( dc, pt[i].y );
 918     }
 919
 920     if (X11DRV_SetupGCForPen ( dc ))
 921     TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
 922            points, count, CoordModeOrigin );
 923
 924     free( points );
 925     dc->u.x.pen.width=oldwidth;
 926     return TRUE;
 927 }
 928
 929
 930 /**********************************************************************
 931  *          X11DRV_Polygon
 932  */
 933 BOOL32
 934 X11DRV_Polygon( DC *dc, const POINT32* pt, INT32 count )
 935 {
 936     register int i;
 937     XPoint *points;
 938
 939     points = (XPoint *) xmalloc (sizeof (XPoint) * (count+1));
 940     for (i = 0; i < count; i++)
 941     {
 942         points[i].x = dc->w.DCOrgX + XLPTODP( dc, pt[i].x );
 943         points[i].y = dc->w.DCOrgY + YLPTODP( dc, pt[i].y );
 944     }
 945     points[count] = points[0];
 946
 947     if (X11DRV_SetupGCForBrush( dc ))
 948         TSXFillPolygon( display, dc->u.x.drawable, dc->u.x.gc,
 949                      points, count+1, Complex, CoordModeOrigin);
 950
 951     if (X11DRV_SetupGCForPen ( dc ))
 952         TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
 953                    points, count+1, CoordModeOrigin );
 954
 955     free( points );
 956     return TRUE;
 957 }
 958
 959
 960 /**********************************************************************
 961  *          X11DRV_PolyPolygon
 962  */
 963 BOOL32
 964 X11DRV_PolyPolygon( DC *dc, const POINT32* pt, const INT32* counts, UINT32 polygons)
 965 {
 966     HRGN32 hrgn;
 967
 968       /* FIXME: The points should be converted to device coords before */
 969       /* creating the region. But as CreatePolyPolygonRgn is not */
 970       /* really correct either, it doesn't matter much... */
 971       /* At least the outline will be correct :-) */
 972     hrgn = CreatePolyPolygonRgn32( pt, counts, polygons, dc->w.polyFillMode );
 973     X11DRV_PaintRgn( dc, hrgn );
 974     DeleteObject32( hrgn );
 975
 976       /* Draw the outline of the polygons */
 977
 978     if (X11DRV_SetupGCForPen ( dc ))
 979     {
 980         int i, j, max = 0;
 981         XPoint *points;
 982
 983         for (i = 0; i < polygons; i++) if (counts[i] > max) max = counts[i];
 984         points = (XPoint *) xmalloc( sizeof(XPoint) * (max+1) );
 985
 986         for (i = 0; i < polygons; i++)
 987         {
 988             for (j = 0; j < counts[i]; j++)
 989             {
 990                 points[j].x = dc->w.DCOrgX + XLPTODP( dc, pt->x );
 991                 points[j].y = dc->w.DCOrgY + YLPTODP( dc, pt->y );
 992                 pt++;
 993             }
 994             points[j] = points[0];
 995             TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
 996                         points, j + 1, CoordModeOrigin );
 997         }
 998         free( points );
 999     }
1000     return TRUE;
1001 }
1002
1003
1004 /**********************************************************************
1005  *          X11DRV_PolyPolyline
1006  */
1007 BOOL32
1008 X11DRV_PolyPolyline( DC *dc, const POINT32* pt, const DWORD* counts, DWORD polylines )
1009 {
1010     if (X11DRV_SetupGCForPen ( dc ))
1011     {
1012         int i, j, max = 0;
1013         XPoint *points;
1014
1015         for (i = 0; i < polylines; i++) if (counts[i] > max) max = counts[i];
1016         points = (XPoint *) xmalloc( sizeof(XPoint) * (max+1) );
1017
1018         for (i = 0; i < polylines; i++)
1019         {
1020             for (j = 0; j < counts[i]; j++)
1021             {
1022                 points[j].x = dc->w.DCOrgX + XLPTODP( dc, pt->x );
1023                 points[j].y = dc->w.DCOrgY + YLPTODP( dc, pt->y );
1024                 pt++;
1025             }
1026             points[j] = points[0];
1027             TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
1028                         points, j + 1, CoordModeOrigin );
1029         }
1030         free( points );
1031     }
1032     return TRUE;
1033 }
1034
1035
1036 /**********************************************************************
1037  *          X11DRV_InternalFloodFill
1038  *
1039  * Internal helper function for flood fill.
1040  * (xorg,yorg) is the origin of the X image relative to the drawable.
1041  * (x,y) is relative to the origin of the X image.
1042  */
1043 static void X11DRV_InternalFloodFill(XImage *image, DC *dc,
1044                                      int x, int y,
1045                                      int xOrg, int yOrg,
1046                                      Pixel pixel, WORD fillType )
1047 {
1048     int left, right;
1049
1050 #define TO_FLOOD(x,y)  ((fillType == FLOODFILLBORDER) ? \
1051                         (XGetPixel(image,x,y) != pixel) : \
1052                         (XGetPixel(image,x,y) == pixel))
1053
1054     if (!TO_FLOOD(x,y)) return;
1055
1056       /* Find left and right boundaries */
1057
1058     left = right = x;
1059     while ((left > 0) && TO_FLOOD( left-1, y )) left--;
1060     while ((right < image->width) && TO_FLOOD( right, y )) right++;
1061     XFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
1062                     xOrg + left, yOrg + y, right-left, 1 );
1063
1064       /* Set the pixels of this line so we don't fill it again */
1065
1066     for (x = left; x < right; x++)
1067     {
1068         if (fillType == FLOODFILLBORDER) XPutPixel( image, x, y, pixel );
1069         else XPutPixel( image, x, y, ~pixel );
1070     }
1071
1072       /* Fill the line above */
1073
1074     if (--y >= 0)
1075     {
1076         x = left;
1077         while (x < right)
1078         {
1079             while ((x < right) && !TO_FLOOD(x,y)) x++;
1080             if (x >= right) break;
1081             while ((x < right) && TO_FLOOD(x,y)) x++;
1082             X11DRV_InternalFloodFill(image, dc, x-1, y,
1083                                      xOrg, yOrg, pixel, fillType );
1084         }
1085     }
1086
1087       /* Fill the line below */
1088
1089     if ((y += 2) < image->height)
1090     {
1091         x = left;
1092         while (x < right)
1093         {
1094             while ((x < right) && !TO_FLOOD(x,y)) x++;
1095             if (x >= right) break;
1096             while ((x < right) && TO_FLOOD(x,y)) x++;
1097             X11DRV_InternalFloodFill(image, dc, x-1, y,
1098                                      xOrg, yOrg, pixel, fillType );
1099         }
1100     }
1101 #undef TO_FLOOD
1102 }
1103
1104
1105 /**********************************************************************
1106  *          X11DRV_DoFloodFill
1107  *
1108  * Main flood-fill routine.
1109  *
1110  * The Xlib critical section must be entered before calling this function.
1111  */
1112
1113 struct FloodFill_params
1114 {
1115     DC      *dc;
1116     INT32    x;
1117     INT32    y;
1118     COLORREF color;
1119     UINT32   fillType;
1120 };
1121
1122 static BOOL32 X11DRV_DoFloodFill( const struct FloodFill_params *params )
1123 {
1124     XImage *image;
1125     RECT32 rect;
1126     DC *dc = params->dc;
1127
1128     if (GetRgnBox32( dc->w.hGCClipRgn, &rect ) == ERROR) return FALSE;
1129
1130     if (!(image = XGetImage( display, dc->u.x.drawable,
1131                              rect.left,
1132                              rect.top,
1133                              rect.right - rect.left,
1134                              rect.bottom - rect.top,
1135                              AllPlanes, ZPixmap ))) return FALSE;
1136
1137     if (X11DRV_SetupGCForBrush( dc ))
1138     {
1139           /* ROP mode is always GXcopy for flood-fill */
1140         XSetFunction( display, dc->u.x.gc, GXcopy );
1141         X11DRV_InternalFloodFill(image, dc,
1142                                  XLPTODP(dc,params->x) + dc->w.DCOrgX - rect.left,
1143                                  YLPTODP(dc,params->y) + dc->w.DCOrgY - rect.top,
1144                                  rect.left,
1145                                  rect.top,
1146                                  COLOR_ToPhysical( dc, params->color ),
1147                                  params->fillType );
1148     }
1149
1150     XDestroyImage( image );
1151     return TRUE;
1152 }
1153
1154
1155 /**********************************************************************
1156  *          X11DRV_ExtFloodFill
1157  */
1158 BOOL32
1159 X11DRV_ExtFloodFill( DC *dc, INT32 x, INT32 y, COLORREF color,
1160                      UINT32 fillType )
1161 {
1162     BOOL32 result;
1163     struct FloodFill_params params = { dc, x, y, color, fillType };
1164
1165     TRACE(graphics, "X11DRV_ExtFloodFill %d,%d %06lx %d\n",
1166                       x, y, color, fillType );
1167
1168     if (!PtVisible32( dc->hSelf, x, y )) return FALSE;
1169     EnterCriticalSection( &X11DRV_CritSection );
1170     result = CALL_LARGE_STACK( X11DRV_DoFloodFill, &params );
1171     LeaveCriticalSection( &X11DRV_CritSection );
1172     return result;
1173 }
1174
1175 /******************************************************************
1176  *
1177  *   *Very* simple bezier drawing code,
1178  *
1179  *   It uses a recursive algorithm to divide the curve in a series
1180  *   of straight line segements. Not ideal but for me sufficient.
1181  *   If you are in need for something better look for some incremental
1182  *   algorithm.
1183  *
1184  *   7 July 1998 Rein Klazes
1185  */
1186
1187  /*
1188   * some macro definitions for bezier drawing
1189   *
1190   * to avoid trucation errors the coordinates are
1191   * shifted upwards. When used in drawing they are
1192   * shifted down again, including correct rounding
1193   * and avoiding floating point arithmatic
1194   * 4 bits should allow 27 bits coordinates which I saw
1195   * somewere in the win32 doc's
1196   *
1197   */
1198
1199 #define BEZIERSHIFTBITS 4
1200 #define BEZIERSHIFTUP(x)    ((x)<<BEZIERSHIFTBITS)
1201 #define BEZIERPIXEL        BEZIERSHIFTUP(1)
1202 #define BEZIERSHIFTDOWN(x)  (((x)+(1<<(BEZIERSHIFTBITS-1)))>>BEZIERSHIFTBITS)
1203 /* maximum depth of recursion */
1204 #define BEZIERMAXDEPTH  8
1205
1206 /* size of array to store points on */
1207 /* enough for one curve */
1208 #define BEZMAXPOINTS    (150)
1209
1210 /* calculate Bezier average, in this case the middle
1211  * correctly rounded...
1212  * */
1213
1214 #define BEZIERMIDDLE(Mid, P1, P2) \
1215     (Mid).x=((P1).x+(P2).x + 1)/2;\
1216     (Mid).y=((P1).y+(P2).y + 1)/2;
1217
1218 /**********************************************************
1219 * BezierCheck helper function to check
1220 * that recursion can be terminated
1221 *       Points[0] and Points[3] are begin and endpoint
1222 *       Points[1] and Points[2] are control points
1223 *       level is the recursion depth
1224 *       returns true if the recusion can be terminated
1225 */
1226 static BOOL32 BezierCheck( int level, POINT32 *Points)
1227 {
1228     INT32 dx, dy;
1229     dx=Points[3].x-Points[0].x;
1230     dy=Points[3].y-Points[0].y;
1231     if(ABS(dy)<=ABS(dx)){/* shallow line */
1232         /* check that control points are between begin and end */
1233         if(Points[1].x < Points[0].x){
1234             if(Points[1].x < Points[3].x)
1235                 return FALSE;
1236         }else
1237             if(Points[1].x > Points[3].x)
1238                 return FALSE;
1239         if(Points[2].x < Points[0].x){
1240             if(Points[2].x < Points[3].x)
1241                 return FALSE;
1242         }else
1243             if(Points[2].x > Points[3].x)
1244                 return FALSE;
1245         dx=BEZIERSHIFTDOWN(dx);
1246         if(!dx) return TRUE;
1247         if(abs(Points[1].y-Points[0].y-(dy/dx)*
1248                 BEZIERSHIFTDOWN(Points[1].x-Points[0].x)) > BEZIERPIXEL ||
1249            abs(Points[2].y-Points[0].y-(dy/dx)*
1250                    BEZIERSHIFTDOWN(Points[2].x-Points[0].x)) > BEZIERPIXEL )
1251             return FALSE;
1252         else
1253             return TRUE;
1254     }else{ /* steep line */
1255         /* check that control points are between begin and end */
1256         if(Points[1].y < Points[0].y){
1257             if(Points[1].y < Points[3].y)
1258                 return FALSE;
1259         }else
1260             if(Points[1].y > Points[3].y)
1261                 return FALSE;
1262         if(Points[2].y < Points[0].y){
1263             if(Points[2].y < Points[3].y)
1264                 return FALSE;
1265         }else
1266             if(Points[2].y > Points[3].y)
1267                 return FALSE;
1268         dy=BEZIERSHIFTDOWN(dy);
1269         if(!dy) return TRUE;
1270         if(abs(Points[1].x-Points[0].x-(dx/dy)*
1271                 BEZIERSHIFTDOWN(Points[1].y-Points[0].y)) > BEZIERPIXEL ||
1272            abs(Points[2].x-Points[0].x-(dx/dy)*
1273                    BEZIERSHIFTDOWN(Points[2].y-Points[0].y)) > BEZIERPIXEL )
1274             return FALSE;
1275         else
1276             return TRUE;
1277     }
1278 }
1279
1280 /***********************************************************************
1281  *           X11DRV_Bezier
1282  *   Draw a -what microsoft calls- bezier curve
1283  *   The routine recursively devides the curve
1284  *   in two parts until a straight line can be drawn
1285  *
1286  *   level      recusion depth counted backwards
1287  *   dc         device context
1288  *   Points     array of begin(0), end(3) and control points(1 and 2)
1289  *   XPoints    array with points calculated sofar
1290  *   *pIx       nr points calculated sofar
1291  *
1292  */
1293 static void X11DRV_Bezier(int level, DC * dc, POINT32 *Points,
1294                           XPoint* xpoints, unsigned int* pIx)
1295 {
1296     if(*pIx == BEZMAXPOINTS){
1297         TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
1298                     xpoints, *pIx, CoordModeOrigin );
1299         *pIx=0;
1300     }
1301     if(!level || BezierCheck(level, Points)) {
1302         if(*pIx == 0){
1303             xpoints[*pIx].x= dc->w.DCOrgX + BEZIERSHIFTDOWN(Points[0].x);
1304             xpoints[*pIx].y= dc->w.DCOrgY + BEZIERSHIFTDOWN(Points[0].y);
1305             *pIx=1;
1306         }
1307         xpoints[*pIx].x= dc->w.DCOrgX + BEZIERSHIFTDOWN(Points[3].x);
1308         xpoints[*pIx].y= dc->w.DCOrgY + BEZIERSHIFTDOWN(Points[3].y);
1309         (*pIx) ++;
1310     } else {
1311         POINT32 Points2[4]; /* for the second recursive call */
1312         Points2[3]=Points[3];
1313         BEZIERMIDDLE(Points2[2], Points[2], Points[3]);
1314         BEZIERMIDDLE(Points2[0], Points[1], Points[2]);
1315         BEZIERMIDDLE(Points2[1],Points2[0],Points2[2]);
1316
1317         BEZIERMIDDLE(Points[1], Points[0],  Points[1]);
1318         BEZIERMIDDLE(Points[2], Points[1], Points2[0]);
1319         BEZIERMIDDLE(Points[3], Points[2], Points2[1]);
1320
1321         Points2[0]=Points[3];
1322
1323         /* do the two halves */
1324         X11DRV_Bezier(level-1, dc, Points, xpoints, pIx);
1325         X11DRV_Bezier(level-1, dc, Points2, xpoints, pIx);
1326     }
1327 }
1328
1329 /***********************************************************************
1330  *           X11DRV_PolyBezier
1331  *      Implement functionality for PolyBezier and PolyBezierTo
1332  *      calls.
1333  *      [i] dc pointer to device context
1334  *      [i] start, first point in curve
1335  *      [i] BezierPoints , array of point filled with rest of the points
1336  *      [i] count, number of points in BezierPoints, must be a
1337  *          multiple of 3.
1338  */
1339 BOOL32
1340 X11DRV_PolyBezier(DC *dc, POINT32 start, const POINT32* BezierPoints, DWORD count)
1341 {
1342     POINT32 Points[4];
1343     int i;
1344     unsigned int ix=0;
1345     XPoint* xpoints;
1346     TRACE(graphics, "dc=%04x count=%ld %d,%d - %d,%d - %d,%d -%d,%d \n",
1347             (int)dc, count,
1348             start.x, start.y,
1349             (Points+0)->x, (Points+0)->y,
1350             (Points+1)->x, (Points+1)->y,
1351             (Points+2)->x, (Points+2)->y);
1352     if(!count || count % 3){/* paranoid */
1353         WARN(graphics," bad value for count : %ld\n", count);
1354         return FALSE;
1355     }
1356     xpoints=(XPoint*) xmalloc( sizeof(XPoint)*BEZMAXPOINTS);
1357     Points[3].x=BEZIERSHIFTUP(XLPTODP(dc,start.x));
1358     Points[3].y=BEZIERSHIFTUP(YLPTODP(dc,start.y));
1359     while(count){
1360         Points[0]=Points[3];
1361         for(i=1;i<4;i++) {
1362             Points[i].x= BEZIERSHIFTUP(XLPTODP(dc,BezierPoints->x));
1363             Points[i].y= BEZIERSHIFTUP(YLPTODP(dc,BezierPoints->y));
1364             BezierPoints++;
1365         }
1366         X11DRV_Bezier(BEZIERMAXDEPTH , dc, Points, xpoints, &ix );
1367         count -=3;
1368     }
1369     if( ix) TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
1370                 xpoints, ix, CoordModeOrigin );
1371     free(xpoints);
1372     return TRUE;
1373 }
1374
1375 /**********************************************************************
1376  *          X11DRV_SetBkColor
1377  */
1378 COLORREF
1379 X11DRV_SetBkColor( DC *dc, COLORREF color )
1380 {
1381     X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
1382     COLORREF oldColor;
1383
1384     oldColor = dc->w.backgroundColor;
1385     dc->w.backgroundColor = color;
1386
1387     physDev->backgroundPixel = COLOR_ToPhysical( dc, color );
1388
1389     return oldColor;
1390 }
1391
1392 /**********************************************************************
1393  *          X11DRV_SetTextColor
1394  */
1395 COLORREF
1396 X11DRV_SetTextColor( DC *dc, COLORREF color )
1397 {
1398     X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
1399     COLORREF oldColor;
1400
1401     oldColor = dc->w.textColor;
1402     dc->w.textColor = color;
1403
1404     physDev->textPixel = COLOR_ToPhysical( dc, color );
1405
1406     return oldColor;
1407 }