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