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 "bitmap.h"
  28 #include "gdi.h"
  29 #include "graphics.h"
  30 #include "dc.h"
  31 #include "bitmap.h"
  32 #include "callback.h"
  33 #include "metafile.h"
  34 #include "palette.h"
  35 #include "color.h"
  36 #include "region.h"
  37 #include "struct32.h"
  38 #include "debug.h"
  39 #include "xmalloc.h"
  40
  41 #define ABS(x)    ((x)<0?(-(x)):(x))
  42 /**********************************************************************
  43  *           X11DRV_MoveToEx
  44  */
  45 BOOL32
  46 X11DRV_MoveToEx(DC *dc,INT32 x,INT32 y,LPPOINT32 pt) {
  47     if (pt)
  48     {
  49         pt->x = dc->w.CursPosX;
  50         pt->y = dc->w.CursPosY;
  51     }
  52     dc->w.CursPosX = x;
  53     dc->w.CursPosY = y;
  54     return TRUE;
  55 }
  56
  57 /***********************************************************************
  58  *           X11DRV_LineTo
  59  */
  60 BOOL32
  61 X11DRV_LineTo( DC *dc, INT32 x, INT32 y )
  62 {
  63     if (DC_SetupGCForPen( dc ))
  64         TSXDrawLine(display, dc->u.x.drawable, dc->u.x.gc,
  65                   dc->w.DCOrgX + XLPTODP( dc, dc->w.CursPosX ),
  66                   dc->w.DCOrgY + YLPTODP( dc, dc->w.CursPosY ),
  67                   dc->w.DCOrgX + XLPTODP( dc, x ),
  68                   dc->w.DCOrgY + YLPTODP( dc, y ) );
  69     dc->w.CursPosX = x;
  70     dc->w.CursPosY = y;
  71     return TRUE;
  72 }
  73
  74
  75
  76 /***********************************************************************
  77  *           GRAPH_DrawArc
  78  *
  79  * Helper functions for Arc(), Chord() and Pie().
  80  * 'lines' is the number of lines to draw: 0 for Arc, 1 for Chord, 2 for Pie.
  81  *
  82  */
  83 static BOOL32
  84 X11DRV_DrawArc( DC *dc, INT32 left, INT32 top, INT32 right,
  85                 INT32 bottom, INT32 xstart, INT32 ystart,
  86                 INT32 xend, INT32 yend, INT32 lines )
  87 {
  88     INT32 xcenter, ycenter, istart_angle, idiff_angle;
  89     INT32 width, oldwidth, oldendcap;
  90     double start_angle, end_angle;
  91     XPoint points[4];
  92
  93     left   = XLPTODP( dc, left );
  94     top    = YLPTODP( dc, top );
  95     right  = XLPTODP( dc, right );
  96     bottom = YLPTODP( dc, bottom );
  97     xstart = XLPTODP( dc, xstart );
  98     ystart = YLPTODP( dc, ystart );
  99     xend   = XLPTODP( dc, xend );
 100     yend   = YLPTODP( dc, yend );
 101
 102     if (right < left) { INT32 tmp = right; right = left; left = tmp; }
 103     if (bottom < top) { INT32 tmp = bottom; bottom = top; top = tmp; }
 104     if ((left == right) || (top == bottom)
 105             ||(lines && ((right-left==1)||(bottom-top==1)))) return TRUE;
 106
 107     oldwidth = width = dc->u.x.pen.width;
 108     oldendcap= dc->u.x.pen.endcap;
 109     if (!width) width = 1;
 110     if(dc->u.x.pen.style == PS_NULL) width = 0;
 111
 112     if ((dc->u.x.pen.style == PS_INSIDEFRAME))
 113     {
 114         if (2*width > (right-left)) width=(right-left + 1)/2;
 115         if (2*width > (bottom-top)) width=(bottom-top + 1)/2;
 116         left   += width / 2;
 117         right  -= (width - 1) / 2;
 118         top    += width / 2;
 119         bottom -= (width - 1) / 2;
 120     }
 121     if(width == 0) width=1; /* more accurate */
 122     dc->u.x.pen.width=width;
 123     dc->u.x.pen.endcap=PS_ENDCAP_SQUARE;
 124
 125     xcenter = (right + left) / 2;
 126     ycenter = (bottom + top) / 2;
 127     start_angle = atan2( (double)(ycenter-ystart)*(right-left),
 128                          (double)(xstart-xcenter)*(bottom-top) );
 129     end_angle   = atan2( (double)(ycenter-yend)*(right-left),
 130                          (double)(xend-xcenter)*(bottom-top) );
 131     if ((xstart==xend)&&(ystart==yend))
 132       { /* A lazy program delivers xstart=xend=ystart=yend=0) */
 133         start_angle = 0;
 134         end_angle = 2* PI;
 135       }
 136     else /* notorious cases */
 137       if ((start_angle == PI)&&( end_angle <0))
 138         start_angle = - PI;
 139     else
 140       if ((end_angle == PI)&&( start_angle <0))
 141         end_angle = - PI;
 142     istart_angle = (INT32)(start_angle * 180 * 64 / PI + 0.5);
 143     idiff_angle  = (INT32)((end_angle - start_angle) * 180 * 64 / PI + 0.5);
 144     if (idiff_angle <= 0) idiff_angle += 360 * 64;
 145
 146       /* Fill arc with brush if Chord() or Pie() */
 147
 148     if ((lines > 0) && DC_SetupGCForBrush( dc )) {
 149         TSXSetArcMode( display, dc->u.x.gc, (lines==1) ? ArcChord : ArcPieSlice);
 150         TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 151                  dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 152                  right-left-1, bottom-top-1, istart_angle, idiff_angle );
 153     }
 154
 155       /* Draw arc and lines */
 156
 157     if (DC_SetupGCForPen( dc )){
 158     TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 159               dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 160               right-left-1, bottom-top-1, istart_angle, idiff_angle );
 161         if (lines) {
 162             /* use the truncated values */
 163             start_angle=(double)istart_angle*PI/64./180.;
 164             end_angle=(double)(istart_angle+idiff_angle)*PI/64./180.;
 165             /* calculate the endpoints and round correctly */
 166             points[0].x = (int) floor(dc->w.DCOrgX + (right+left)/2.0 +
 167                     cos(start_angle) * (right-left-width*2+2) / 2. + 0.5);
 168             points[0].y = (int) floor(dc->w.DCOrgY + (top+bottom)/2.0 -
 169                     sin(start_angle) * (bottom-top-width*2+2) / 2. + 0.5);
 170             points[1].x = (int) floor(dc->w.DCOrgX + (right+left)/2.0 +
 171                     cos(end_angle) * (right-left-width*2+2) / 2. + 0.5);
 172             points[1].y = (int) floor(dc->w.DCOrgY + (top+bottom)/2.0 -
 173                     sin(end_angle) * (bottom-top-width*2+2) / 2. + 0.5);
 174
 175             /* OK this stuff is optimized for Xfree86
 176              * which is probably the most used server by
 177              * wine users. Other X servers will not
 178              * display correctly. (eXceed for instance)
 179              * so if you feel you must change make sure that
 180              * you either use Xfree86 or seperate your changes
 181              * from these (compile switch or whatever)
 182              */
 183             if (lines == 2) {
 184                 INT32 dx1,dy1;
 185                 points[3] = points[1];
 186         points[1].x = dc->w.DCOrgX + xcenter;
 187         points[1].y = dc->w.DCOrgY + ycenter;
 188                 points[2] = points[1];
 189                 dx1=points[1].x-points[0].x;
 190                 dy1=points[1].y-points[0].y;
 191                 if(((top-bottom) | -2) == -2)
 192                     if(dy1>0) points[1].y--;
 193                 if(dx1<0) {
 194                     if (((-dx1)*64)<=ABS(dy1)*37) points[0].x--;
 195                     if(((-dx1*9))<(dy1*16)) points[0].y--;
 196                     if( dy1<0 && ((dx1*9)) < (dy1*16)) points[0].y--;
 197                 } else {
 198                     if(dy1 < 0)  points[0].y--;
 199                     if(((right-left) | -2) == -2) points[1].x--;
 200                 }
 201                 dx1=points[3].x-points[2].x;
 202                 dy1=points[3].y-points[2].y;
 203                 if(((top-bottom) | -2 ) == -2)
 204                     if(dy1 < 0) points[2].y--;
 205                 if( dx1<0){
 206                     if( dy1>0) points[3].y--;
 207                     if(((right-left) | -2) == -2 ) points[2].x--;
 208                 }else {
 209                     points[3].y--;
 210                     if( dx1 * 64 < dy1 * -37 ) points[3].x--;
 211                 }
 212                 lines++;
 213     }
 214     TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
 215                 points, lines+1, CoordModeOrigin );
 216         }
 217     }
 218     dc->u.x.pen.width=oldwidth;
 219     dc->u.x.pen.endcap=oldendcap;
 220     return TRUE;
 221 }
 222
 223
 224 /***********************************************************************
 225  *           X11DRV_Arc
 226  */
 227 BOOL32
 228 X11DRV_Arc( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom,
 229             INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
 230 {
 231     return X11DRV_DrawArc( dc, left, top, right, bottom,
 232                            xstart, ystart, xend, yend, 0 );
 233 }
 234
 235
 236 /***********************************************************************
 237  *           X11DRV_Pie
 238  */
 239 BOOL32
 240 X11DRV_Pie( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom,
 241             INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
 242 {
 243     return X11DRV_DrawArc( dc, left, top, right, bottom,
 244                            xstart, ystart, xend, yend, 2 );
 245 }
 246
 247 /***********************************************************************
 248  *           X11DRV_Chord
 249  */
 250 BOOL32
 251 X11DRV_Chord( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom,
 252               INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
 253 {
 254     return X11DRV_DrawArc( dc, left, top, right, bottom,
 255                            xstart, ystart, xend, yend, 1 );
 256 }
 257
 258
 259 /***********************************************************************
 260  *           X11DRV_Ellipse
 261  */
 262 BOOL32
 263 X11DRV_Ellipse( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom )
 264 {
 265     INT32 width, oldwidth;
 266     left   = XLPTODP( dc, left );
 267     top    = YLPTODP( dc, top );
 268     right  = XLPTODP( dc, right );
 269     bottom = YLPTODP( dc, bottom );
 270     if ((left == right) || (top == bottom)) return TRUE;
 271
 272     if (right < left) { INT32 tmp = right; right = left; left = tmp; }
 273     if (bottom < top) { INT32 tmp = bottom; bottom = top; top = tmp; }
 274
 275     oldwidth = width = dc->u.x.pen.width;
 276     if (!width) width = 1;
 277     if(dc->u.x.pen.style == PS_NULL) width = 0;
 278
 279     if ((dc->u.x.pen.style == PS_INSIDEFRAME))
 280     {
 281         if (2*width > (right-left)) width=(right-left + 1)/2;
 282         if (2*width > (bottom-top)) width=(bottom-top + 1)/2;
 283         left   += width / 2;
 284         right  -= (width - 1) / 2;
 285         top    += width / 2;
 286         bottom -= (width - 1) / 2;
 287     }
 288     if(width == 0) width=1; /* more accurate */
 289     dc->u.x.pen.width=width;
 290
 291     if (DC_SetupGCForBrush( dc ))
 292         TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 293                   dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 294                   right-left-1, bottom-top-1, 0, 360*64 );
 295     if (DC_SetupGCForPen( dc ))
 296         TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 297                   dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 298                   right-left-1, bottom-top-1, 0, 360*64 );
 299     dc->u.x.pen.width=oldwidth;
 300     return TRUE;
 301 }
 302
 303
 304 /***********************************************************************
 305  *           X11DRV_Rectangle
 306  */
 307 BOOL32
 308 X11DRV_Rectangle(DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom)
 309 {
 310     INT32 width, oldwidth, oldjoinstyle;
 311
 312     TRACE(graphics, "(%d %d %d %d)\n",
 313         left, top, right, bottom);
 314
 315     left   = XLPTODP( dc, left );
 316     top    = YLPTODP( dc, top );
 317     right  = XLPTODP( dc, right );
 318     bottom = YLPTODP( dc, bottom );
 319
 320     if ((left == right) || (top == bottom)) return TRUE;
 321
 322     if (right < left) { INT32 tmp = right; right = left; left = tmp; }
 323     if (bottom < top) { INT32 tmp = bottom; bottom = top; top = tmp; }
 324
 325     oldwidth = width = dc->u.x.pen.width;
 326     if (!width) width = 1;
 327     if(dc->u.x.pen.style == PS_NULL) width = 0;
 328
 329     if ((dc->u.x.pen.style == PS_INSIDEFRAME))
 330     {
 331         if (2*width > (right-left)) width=(right-left + 1)/2;
 332         if (2*width > (bottom-top)) width=(bottom-top + 1)/2;
 333         left   += width / 2;
 334         right  -= (width - 1) / 2;
 335         top    += width / 2;
 336         bottom -= (width - 1) / 2;
 337     }
 338     if(width == 1) width=0;
 339     dc->u.x.pen.width=width;
 340     oldjoinstyle=dc->u.x.pen.linejoin;
 341     if(dc->u.x.pen.type!=PS_GEOMETRIC)
 342             dc->u.x.pen.linejoin=PS_JOIN_MITER;
 343
 344     if ((right > left + width) && (bottom > top + width))
 345     {
 346         if (DC_SetupGCForBrush( dc ))
 347             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 348                             dc->w.DCOrgX + left + (width + 1) / 2,
 349                             dc->w.DCOrgY + top + (width + 1) / 2,
 350                             right-left-width-1, bottom-top-width-1);
 351     }
 352     if (DC_SetupGCForPen( dc ))
 353         TSXDrawRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 354                         dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 355                         right-left-1, bottom-top-1 );
 356
 357     dc->u.x.pen.width=oldwidth;
 358     dc->u.x.pen.linejoin=oldjoinstyle;
 359     return TRUE;
 360 }
 361
 362 /***********************************************************************
 363  *           X11DRV_RoundRect
 364  */
 365 BOOL32
 366 X11DRV_RoundRect( DC *dc, INT32 left, INT32 top, INT32 right,
 367                   INT32 bottom, INT32 ell_width, INT32 ell_height )
 368 {
 369     INT32 width, oldwidth, oldendcap;
 370
 371     TRACE(graphics, "(%d %d %d %d  %d %d\n",
 372         left, top, right, bottom, ell_width, ell_height);
 373
 374     left   = XLPTODP( dc, left );
 375     top    = YLPTODP( dc, top );
 376     right  = XLPTODP( dc, right );
 377     bottom = YLPTODP( dc, bottom );
 378
 379     if ((left == right) || (top == bottom))
 380         return TRUE;
 381
 382     ell_width  = abs( ell_width * dc->vportExtX / dc->wndExtX );
 383     ell_height = abs( ell_height * dc->vportExtY / dc->wndExtY );
 384
 385     /* Fix the coordinates */
 386
 387     if (right < left) { INT32 tmp = right; right = left; left = tmp; }
 388     if (bottom < top) { INT32 tmp = bottom; bottom = top; top = tmp; }
 389
 390     oldwidth=width = dc->u.x.pen.width;
 391     oldendcap = dc->u.x.pen.endcap;
 392     if (!width) width = 1;
 393     if(dc->u.x.pen.style == PS_NULL) width = 0;
 394
 395     if ((dc->u.x.pen.style == PS_INSIDEFRAME))
 396     {
 397         if (2*width > (right-left)) width=(right-left + 1)/2;
 398         if (2*width > (bottom-top)) width=(bottom-top + 1)/2;
 399         left   += width / 2;
 400         right  -= (width - 1) / 2;
 401         top    += width / 2;
 402         bottom -= (width - 1) / 2;
 403     }
 404     if(width == 0) width=1;
 405     dc->u.x.pen.width=width;
 406     dc->u.x.pen.endcap=PS_ENDCAP_SQUARE;
 407
 408     if (DC_SetupGCForBrush( dc ))
 409     {
 410         if (ell_width > (right-left) )
 411             if (ell_height > (bottom-top) )
 412                     TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 413                               dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 414                               right - left - 1, bottom - top - 1,
 415                               0, 360 * 64 );
 416             else{
 417                     TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 418                               dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 419                               right - left - 1, ell_height, 0, 180 * 64 );
 420                     TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 421                               dc->w.DCOrgX + left,
 422                               dc->w.DCOrgY + bottom - ell_height - 1,
 423                               right - left - 1, ell_height, 180 * 64, 180 * 64 );
 424            }
 425         else if (ell_height > (bottom-top) ){
 426                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 427                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 428                       ell_width, bottom - top - 1, 90 * 64, 180 * 64 );
 429                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 430                       dc->w.DCOrgX + right - ell_width -1, dc->w.DCOrgY + top,
 431                       ell_width, bottom - top - 1, 270 * 64, 180 * 64 );
 432         }else{
 433                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 434                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 435                       ell_width, ell_height, 90 * 64, 90 * 64 );
 436                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 437                       dc->w.DCOrgX + left,
 438                       dc->w.DCOrgY + bottom - ell_height - 1,
 439                       ell_width, ell_height, 180 * 64, 90 * 64 );
 440                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 441                       dc->w.DCOrgX + right - ell_width - 1,
 442                       dc->w.DCOrgY + bottom - ell_height - 1,
 443                       ell_width, ell_height, 270 * 64, 90 * 64 );
 444                 TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
 445                       dc->w.DCOrgX + right - ell_width - 1,
 446                       dc->w.DCOrgY + top,
 447                       ell_width, ell_height, 0, 90 * 64 );
 448         }
 449         if (ell_width < right - left)
 450         {
 451             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 452                             dc->w.DCOrgX + left + (ell_width + 1) / 2,
 453                             dc->w.DCOrgY + top + 1,
 454                             right - left - ell_width - 1,
 455                             (ell_height + 1) / 2 - 1);
 456             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 457                             dc->w.DCOrgX + left + (ell_width + 1) / 2,
 458                             dc->w.DCOrgY + bottom - (ell_height) / 2 - 1,
 459                             right - left - ell_width - 1,
 460                             (ell_height) / 2 );
 461         }
 462         if  (ell_height < bottom - top)
 463         {
 464             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 465                             dc->w.DCOrgX + left + 1,
 466                             dc->w.DCOrgY + top + (ell_height + 1) / 2,
 467                             right - left - 2,
 468                             bottom - top - ell_height - 1);
 469         }
 470     }
 471     /* FIXME: this could be done with on X call
 472      * more efficient and probably more correct
 473      * on any X server: XDrawArcs will draw
 474      * straight horizontal and vertical lines
 475      * if width or height are zero.
 476      *
 477      * BTW this stuff is optimized for an Xfree86 server
 478      * read the comments inside the X11DRV_DrawArc function
 479      */
 480     if (DC_SetupGCForPen(dc)) {
 481         if (ell_width > (right-left) )
 482             if (ell_height > (bottom-top) )
 483                 TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 484                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 485                       right - left - 1, bottom -top - 1, 0 , 360 * 64 );
 486             else{
 487                 TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 488                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 489                       right - left - 1, ell_height - 1, 0 , 180 * 64 );
 490                 TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 491                       dc->w.DCOrgX + left,
 492                       dc->w.DCOrgY + bottom - ell_height,
 493                       right - left - 1, ell_height - 1, 180 * 64 , 180 * 64 );
 494             }
 495         else if (ell_height > (bottom-top) ){
 496                 TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 497                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 498                       ell_width - 1 , bottom - top - 1, 90 * 64 , 180 * 64 );
 499                 TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 500                       dc->w.DCOrgX + right - ell_width,
 501                       dc->w.DCOrgY + top,
 502                       ell_width - 1 , bottom - top - 1, 270 * 64 , 180 * 64 );
 503         }else{
 504             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 505                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
 506                       ell_width - 1, ell_height - 1, 90 * 64, 90 * 64 );
 507             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 508                       dc->w.DCOrgX + left, dc->w.DCOrgY + bottom - ell_height,
 509                       ell_width - 1, ell_height - 1, 180 * 64, 90 * 64 );
 510             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 511                       dc->w.DCOrgX + right - ell_width,
 512                       dc->w.DCOrgY + bottom - ell_height,
 513                       ell_width - 1, ell_height - 1, 270 * 64, 90 * 64 );
 514             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
 515                       dc->w.DCOrgX + right - ell_width, dc->w.DCOrgY + top,
 516                       ell_width - 1, ell_height - 1, 0, 90 * 64 );
 517         }
 518         if (ell_width < right - left)
 519         {
 520             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc,
 521                dc->w.DCOrgX + left + ell_width / 2,
 522                        dc->w.DCOrgY + top,
 523                dc->w.DCOrgX + right - (ell_width+1) / 2,
 524                        dc->w.DCOrgY + top);
 525             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc,
 526                dc->w.DCOrgX + left + ell_width / 2 ,
 527                        dc->w.DCOrgY + bottom - 1,
 528                dc->w.DCOrgX + right - (ell_width+1)/ 2,
 529                        dc->w.DCOrgY + bottom - 1);
 530         }
 531         if (ell_height < bottom - top)
 532         {
 533             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc,
 534                        dc->w.DCOrgX + right - 1,
 535                dc->w.DCOrgY + top + ell_height / 2,
 536                        dc->w.DCOrgX + right - 1,
 537                dc->w.DCOrgY + bottom - (ell_height+1) / 2);
 538             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc,
 539                        dc->w.DCOrgX + left,
 540                dc->w.DCOrgY + top + ell_height / 2,
 541                        dc->w.DCOrgX + left,
 542                dc->w.DCOrgY + bottom - (ell_height+1) / 2);
 543         }
 544     }
 545     dc->u.x.pen.width=oldwidth;
 546     dc->u.x.pen.endcap=oldendcap;
 547     return TRUE;
 548 }
 549
 550
 551 /***********************************************************************
 552  *           X11DRV_SetPixel
 553  */
 554 COLORREF
 555 X11DRV_SetPixel( DC *dc, INT32 x, INT32 y, COLORREF color )
 556 {
 557     Pixel pixel;
 558
 559     x = dc->w.DCOrgX + XLPTODP( dc, x );
 560     y = dc->w.DCOrgY + YLPTODP( dc, y );
 561     pixel = COLOR_ToPhysical( dc, color );
 562
 563     TSXSetForeground( display, dc->u.x.gc, pixel );
 564     TSXSetFunction( display, dc->u.x.gc, GXcopy );
 565     TSXDrawPoint( display, dc->u.x.drawable, dc->u.x.gc, x, y );
 566
 567     /* inefficient but simple... */
 568
 569     return COLOR_ToLogical(pixel);
 570 }
 571
 572
 573 /***********************************************************************
 574  *           X11DRV_GetPixel
 575  */
 576 COLORREF
 577 X11DRV_GetPixel( DC *dc, INT32 x, INT32 y )
 578 {
 579     static Pixmap pixmap = 0;
 580     XImage * image;
 581     int pixel;
 582
 583     x = dc->w.DCOrgX + XLPTODP( dc, x );
 584     y = dc->w.DCOrgY + YLPTODP( dc, y );
 585     EnterCriticalSection( &X11DRV_CritSection );
 586     if (dc->w.flags & DC_MEMORY)
 587     {
 588         image = XGetImage( display, dc->u.x.drawable, x, y, 1, 1,
 589                            AllPlanes, ZPixmap );
 590     }
 591     else
 592     {
 593         /* If we are reading from the screen, use a temporary copy */
 594         /* to avoid a BadMatch error */
 595         if (!pixmap) pixmap = XCreatePixmap( display, rootWindow,
 596                                              1, 1, dc->w.bitsPerPixel );
 597         XCopyArea( display, dc->u.x.drawable, pixmap, BITMAP_colorGC,
 598                    x, y, 1, 1, 0, 0 );
 599         image = XGetImage( display, pixmap, 0, 0, 1, 1, AllPlanes, ZPixmap );
 600     }
 601     pixel = XGetPixel( image, 0, 0 );
 602     XDestroyImage( image );
 603     LeaveCriticalSection( &X11DRV_CritSection );
 604
 605     return COLOR_ToLogical(pixel);
 606 }
 607
 608
 609 /***********************************************************************
 610  *           X11DRV_PaintRgn
 611  */
 612 BOOL32
 613 X11DRV_PaintRgn( DC *dc, HRGN32 hrgn )
 614 {
 615     RECT32 box;
 616     HRGN32 tmpVisRgn, prevVisRgn;
 617     HDC32  hdc = dc->hSelf; /* FIXME: should not mix dc/hdc this way */
 618
 619     if (!(tmpVisRgn = CreateRectRgn32( 0, 0, 0, 0 ))) return FALSE;
 620
 621       /* Transform region into device co-ords */
 622     if (!REGION_LPTODP( hdc, tmpVisRgn, hrgn )) {
 623         DeleteObject32( tmpVisRgn );
 624         return FALSE;
 625     }
 626
 627       /* Modify visible region */
 628     if (!(prevVisRgn = SaveVisRgn( hdc ))) {
 629         DeleteObject32( tmpVisRgn );
 630         return FALSE;
 631     }
 632     CombineRgn32( tmpVisRgn, prevVisRgn, tmpVisRgn, RGN_AND );
 633     SelectVisRgn( hdc, tmpVisRgn );
 634     DeleteObject32( tmpVisRgn );
 635
 636       /* Fill the region */
 637
 638     GetRgnBox32( dc->w.hGCClipRgn, &box );
 639     if (DC_SetupGCForBrush( dc ))
 640         TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 641                         dc->w.DCOrgX + box.left, dc->w.DCOrgY + box.top,
 642                         box.right-box.left, box.bottom-box.top );
 643
 644       /* Restore the visible region */
 645
 646     RestoreVisRgn( hdc );
 647     return TRUE;
 648 }
 649
 650 /**********************************************************************
 651  *          X11DRV_Polyline
 652  */
 653 BOOL32
 654 X11DRV_Polyline( DC *dc, LPPOINT32 pt, INT32 count )
 655 {
 656     INT32 oldwidth;
 657     register int i;
 658     XPoint *points;
 659     if((oldwidth=dc->u.x.pen.width)==0) dc->u.x.pen.width=1;
 660
 661     points = (XPoint *) xmalloc (sizeof (XPoint) * (count));
 662     for (i = 0; i < count; i++)
 663     {
 664     points[i].x = dc->w.DCOrgX + XLPTODP( dc, pt[i].x );
 665     points[i].y = dc->w.DCOrgY + YLPTODP( dc, pt[i].y );
 666     }
 667
 668     if (DC_SetupGCForPen ( dc ))
 669     TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
 670            points, count, CoordModeOrigin );
 671
 672     free( points );
 673     dc->u.x.pen.width=oldwidth;
 674     return TRUE;
 675 }
 676
 677
 678 /**********************************************************************
 679  *          X11DRV_Polygon
 680  */
 681 BOOL32
 682 X11DRV_Polygon( DC *dc, LPPOINT32 pt, INT32 count )
 683 {
 684     register int i;
 685     XPoint *points;
 686
 687     points = (XPoint *) xmalloc (sizeof (XPoint) * (count+1));
 688     for (i = 0; i < count; i++)
 689     {
 690         points[i].x = dc->w.DCOrgX + XLPTODP( dc, pt[i].x );
 691         points[i].y = dc->w.DCOrgY + YLPTODP( dc, pt[i].y );
 692     }
 693     points[count] = points[0];
 694
 695     if (DC_SetupGCForBrush( dc ))
 696         TSXFillPolygon( display, dc->u.x.drawable, dc->u.x.gc,
 697                      points, count+1, Complex, CoordModeOrigin);
 698
 699     if (DC_SetupGCForPen ( dc ))
 700         TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
 701                    points, count+1, CoordModeOrigin );
 702
 703     free( points );
 704     return TRUE;
 705 }
 706
 707
 708 /**********************************************************************
 709  *          X11DRV_PolyPolygon
 710  */
 711 BOOL32
 712 X11DRV_PolyPolygon( DC *dc, LPPOINT32 pt, LPINT32 counts, UINT32 polygons)
 713 {
 714     HRGN32 hrgn;
 715
 716       /* FIXME: The points should be converted to device coords before */
 717       /* creating the region. But as CreatePolyPolygonRgn is not */
 718       /* really correct either, it doesn't matter much... */
 719       /* At least the outline will be correct :-) */
 720     hrgn = CreatePolyPolygonRgn32( pt, counts, polygons, dc->w.polyFillMode );
 721     X11DRV_PaintRgn( dc, hrgn );
 722     DeleteObject32( hrgn );
 723
 724       /* Draw the outline of the polygons */
 725
 726     if (DC_SetupGCForPen ( dc ))
 727     {
 728         int i, j, max = 0;
 729         XPoint *points;
 730
 731         for (i = 0; i < polygons; i++) if (counts[i] > max) max = counts[i];
 732         points = (XPoint *) xmalloc( sizeof(XPoint) * (max+1) );
 733
 734         for (i = 0; i < polygons; i++)
 735         {
 736             for (j = 0; j < counts[i]; j++)
 737             {
 738                 points[j].x = dc->w.DCOrgX + XLPTODP( dc, pt->x );
 739                 points[j].y = dc->w.DCOrgY + YLPTODP( dc, pt->y );
 740                 pt++;
 741             }
 742             points[j] = points[0];
 743             TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
 744                         points, j + 1, CoordModeOrigin );
 745         }
 746         free( points );
 747     }
 748     return TRUE;
 749 }
 750
 751
 752 /**********************************************************************
 753  *          X11DRV_PolyPolyline
 754  */
 755 BOOL32
 756 X11DRV_PolyPolyline( DC *dc, LPPOINT32 pt, LPDWORD counts, DWORD polylines )
 757 {
 758     if (DC_SetupGCForPen ( dc ))
 759     {
 760         int i, j, max = 0;
 761         XPoint *points;
 762
 763         for (i = 0; i < polylines; i++) if (counts[i] > max) max = counts[i];
 764         points = (XPoint *) xmalloc( sizeof(XPoint) * (max+1) );
 765
 766         for (i = 0; i < polylines; i++)
 767         {
 768             for (j = 0; j < counts[i]; j++)
 769             {
 770                 points[j].x = dc->w.DCOrgX + XLPTODP( dc, pt->x );
 771                 points[j].y = dc->w.DCOrgY + YLPTODP( dc, pt->y );
 772                 pt++;
 773             }
 774             points[j] = points[0];
 775             TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
 776                         points, j + 1, CoordModeOrigin );
 777         }
 778         free( points );
 779     }
 780     return TRUE;
 781 }
 782
 783
 784 /**********************************************************************
 785  *          X11DRV_InternalFloodFill
 786  *
 787  * Internal helper function for flood fill.
 788  * (xorg,yorg) is the origin of the X image relative to the drawable.
 789  * (x,y) is relative to the origin of the X image.
 790  */
 791 static void X11DRV_InternalFloodFill(XImage *image, DC *dc,
 792                                      int x, int y,
 793                                      int xOrg, int yOrg,
 794                                      Pixel pixel, WORD fillType )
 795 {
 796     int left, right;
 797
 798 #define TO_FLOOD(x,y)  ((fillType == FLOODFILLBORDER) ? \
 799                         (XGetPixel(image,x,y) != pixel) : \
 800                         (XGetPixel(image,x,y) == pixel))
 801
 802     if (!TO_FLOOD(x,y)) return;
 803
 804       /* Find left and right boundaries */
 805
 806     left = right = x;
 807     while ((left > 0) && TO_FLOOD( left-1, y )) left--;
 808     while ((right < image->width) && TO_FLOOD( right, y )) right++;
 809     XFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
 810                     xOrg + left, yOrg + y, right-left, 1 );
 811
 812       /* Set the pixels of this line so we don't fill it again */
 813
 814     for (x = left; x < right; x++)
 815     {
 816         if (fillType == FLOODFILLBORDER) XPutPixel( image, x, y, pixel );
 817         else XPutPixel( image, x, y, ~pixel );
 818     }
 819
 820       /* Fill the line above */
 821
 822     if (--y >= 0)
 823     {
 824         x = left;
 825         while (x < right)
 826         {
 827             while ((x < right) && !TO_FLOOD(x,y)) x++;
 828             if (x >= right) break;
 829             while ((x < right) && TO_FLOOD(x,y)) x++;
 830             X11DRV_InternalFloodFill(image, dc, x-1, y,
 831                                      xOrg, yOrg, pixel, fillType );
 832         }
 833     }
 834
 835       /* Fill the line below */
 836
 837     if ((y += 2) < image->height)
 838     {
 839         x = left;
 840         while (x < right)
 841         {
 842             while ((x < right) && !TO_FLOOD(x,y)) x++;
 843             if (x >= right) break;
 844             while ((x < right) && TO_FLOOD(x,y)) x++;
 845             X11DRV_InternalFloodFill(image, dc, x-1, y,
 846                                      xOrg, yOrg, pixel, fillType );
 847         }
 848     }
 849 #undef TO_FLOOD
 850 }
 851
 852
 853 /**********************************************************************
 854  *          X11DRV_DoFloodFill
 855  *
 856  * Main flood-fill routine.
 857  *
 858  * The Xlib critical section must be entered before calling this function.
 859  */
 860
 861 struct FloodFill_params
 862 {
 863     DC      *dc;
 864     INT32    x;
 865     INT32    y;
 866     COLORREF color;
 867     UINT32   fillType;
 868 };
 869
 870 static BOOL32 X11DRV_DoFloodFill( const struct FloodFill_params *params )
 871 {
 872     XImage *image;
 873     RECT32 rect;
 874     DC *dc = params->dc;
 875
 876     if (GetRgnBox32( dc->w.hGCClipRgn, &rect ) == ERROR) return FALSE;
 877
 878     if (!(image = XGetImage( display, dc->u.x.drawable,
 879                              dc->w.DCOrgX + rect.left,
 880                              dc->w.DCOrgY + rect.top,
 881                              rect.right - rect.left,
 882                              rect.bottom - rect.top,
 883                              AllPlanes, ZPixmap ))) return FALSE;
 884
 885     if (DC_SetupGCForBrush( dc ))
 886     {
 887           /* ROP mode is always GXcopy for flood-fill */
 888         XSetFunction( display, dc->u.x.gc, GXcopy );
 889         X11DRV_InternalFloodFill(image, dc,
 890                                  XLPTODP(dc,params->x) - rect.left,
 891                                  YLPTODP(dc,params->y) - rect.top,
 892                                  dc->w.DCOrgX + rect.left,
 893                                  dc->w.DCOrgY + rect.top,
 894                                  COLOR_ToPhysical( dc, params->color ),
 895                                  params->fillType );
 896     }
 897
 898     XDestroyImage( image );
 899     return TRUE;
 900 }
 901
 902
 903 /**********************************************************************
 904  *          X11DRV_ExtFloodFill
 905  */
 906 BOOL32
 907 X11DRV_ExtFloodFill( DC *dc, INT32 x, INT32 y, COLORREF color,
 908                      UINT32 fillType )
 909 {
 910     BOOL32 result;
 911     struct FloodFill_params params = { dc, x, y, color, fillType };
 912
 913     TRACE(graphics, "X11DRV_ExtFloodFill %d,%d %06lx %d\n",
 914                       x, y, color, fillType );
 915
 916     if (!PtVisible32( dc->hSelf, x, y )) return FALSE;
 917     EnterCriticalSection( &X11DRV_CritSection );
 918     result = CALL_LARGE_STACK( X11DRV_DoFloodFill, &params );
 919     LeaveCriticalSection( &X11DRV_CritSection );
 920     return result;
 921 }
 922
 923 /******************************************************************
 924  *
 925  *   *Very* simple bezier drawing code,
 926  *
 927  *   It uses a recursive algorithm to divide the curve in a series
 928  *   of straight line segements. Not ideal but for me sufficient.
 929  *   If you are in need for something better look for some incremental
 930  *   algorithm.
 931  *
 932  *   7 July 1998 Rein Klazes
 933  */
 934
 935  /*
 936   * some macro definitions for bezier drawing
 937   *
 938   * to avoid trucation errors the coordinates are
 939   * shifted upwards. When used in drawing they are
 940   * shifted down again, including correct rounding
 941   * and avoiding floating point arithmatic
 942   * 4 bits should allow 27 bits coordinates which I saw
 943   * somewere in the win32 doc's
 944   *
 945   */
 946
 947 #define BEZIERSHIFTBITS 4
 948 #define BEZIERSHIFTUP(x)    ((x)<<BEZIERSHIFTBITS)
 949 #define BEZIERPIXEL        BEZIERSHIFTUP(1)
 950 #define BEZIERSHIFTDOWN(x)  (((x)+(1<<(BEZIERSHIFTBITS-1)))>>BEZIERSHIFTBITS)
 951 /* maximum depth of recursion */
 952 #define BEZIERMAXDEPTH  8
 953
 954 /* size of array to store points on */
 955 /* enough for one curve */
 956 #define BEZMAXPOINTS    (150)
 957
 958 /* calculate Bezier average, in this case the middle
 959  * correctly rounded...
 960  * */
 961
 962 #define BEZIERMIDDLE(Mid, P1, P2) \
 963     (Mid).x=((P1).x+(P2).x + 1)/2;\
 964     (Mid).y=((P1).y+(P2).y + 1)/2;
 965
 966 /**********************************************************
 967 * BezierCheck helper function to check
 968 * that recursion can be terminated
 969 *       Points[0] and Points[3] are begin and endpoint
 970 *       Points[1] and Points[2] are control points
 971 *       level is the recursion depth
 972 *       returns true if the recusion can be terminated
 973 */
 974 static BOOL32 BezierCheck( int level, POINT32 *Points)
 975 {
 976     INT32 dx, dy;
 977     dx=Points[3].x-Points[0].x;
 978     dy=Points[3].y-Points[0].y;
 979     if(ABS(dy)<ABS(dx)){/* shallow line */
 980         /* check that control points are between begin and end */
 981         if( (Points[1].x-Points[0].x)*dx < 0 ||
 982             (Points[2].x-Points[0].x)*dx < 0 ) return FALSE;
 983         dx=BEZIERSHIFTDOWN(dx);
 984         if(!dx) return TRUE;
 985         if(abs(Points[1].y-Points[0].y-(dy/dx)*
 986                 BEZIERSHIFTDOWN(Points[1].x-Points[0].x)) > BEZIERPIXEL ||
 987            abs(Points[2].y-Points[0].y-(dy/dx)*
 988                    BEZIERSHIFTDOWN(Points[2].x-Points[0].x)) > BEZIERPIXEL )
 989             return FALSE;
 990         else
 991             return TRUE;
 992     }else{ /* steep line */
 993         /* check that control points are between begin and end */
 994         if( (Points[1].y-Points[0].y)*dy < 0 ||
 995             (Points[2].y-Points[0].y)*dy < 0 ) return FALSE;
 996         dy=BEZIERSHIFTDOWN(dy);
 997         if(!dy) return TRUE;
 998         if(abs(Points[1].x-Points[0].x-(dx/dy)*
 999                 BEZIERSHIFTDOWN(Points[1].y-Points[0].y)) > BEZIERPIXEL ||
1000            abs(Points[2].x-Points[0].x-(dx/dy)*
1001                    BEZIERSHIFTDOWN(Points[2].y-Points[0].y)) > BEZIERPIXEL )
1002             return FALSE;
1003         else
1004             return TRUE;
1005     }
1006 }
1007
1008 /***********************************************************************
1009  *           X11DRV_Bezier
1010  *   Draw a -what microsoft calls- bezier curve
1011  *   The routine recursively devides the curve
1012  *   in two parts until a straight line can be drawn
1013  *
1014  *   level      recusion depth counted backwards
1015  *   dc         device context
1016  *   Points     array of begin(0), end(3) and control points(1 and 2)
1017  *   XPoints    array with points calculated sofar
1018  *   *pIx       nr points calculated sofar
1019  *
1020  */
1021 static void X11DRV_Bezier(int level, DC * dc, POINT32 *Points,
1022                           XPoint* xpoints, unsigned int* pIx)
1023 {
1024     if(*pIx == BEZMAXPOINTS){
1025         TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
1026                     xpoints, *pIx, CoordModeOrigin );
1027         *pIx=0;
1028     }
1029     if(!level || BezierCheck(level, Points)) {
1030         if(*pIx == 0){
1031             xpoints[*pIx].x= dc->w.DCOrgX + BEZIERSHIFTDOWN(Points[0].x);
1032             xpoints[*pIx].y= dc->w.DCOrgY + BEZIERSHIFTDOWN(Points[0].y);
1033             *pIx=1;
1034         }
1035         xpoints[*pIx].x= dc->w.DCOrgX + BEZIERSHIFTDOWN(Points[3].x);
1036         xpoints[*pIx].y= dc->w.DCOrgY + BEZIERSHIFTDOWN(Points[3].y);
1037         (*pIx) ++;
1038     } else {
1039         POINT32 Points2[4]; /* for the second recursive call */
1040         Points2[3]=Points[3];
1041         BEZIERMIDDLE(Points2[2], Points[2], Points[3]);
1042         BEZIERMIDDLE(Points2[0], Points[1], Points[2]);
1043         BEZIERMIDDLE(Points2[1],Points2[0],Points2[2]);
1044
1045         BEZIERMIDDLE(Points[1], Points[0],  Points[1]);
1046         BEZIERMIDDLE(Points[2], Points[1], Points2[0]);
1047         BEZIERMIDDLE(Points[3], Points[2], Points2[1]);
1048
1049         Points2[0]=Points[3];
1050
1051         /* do the two halves */
1052         X11DRV_Bezier(level-1, dc, Points, xpoints, pIx);
1053         X11DRV_Bezier(level-1, dc, Points2, xpoints, pIx);
1054     }
1055 }
1056
1057 /***********************************************************************
1058  *           X11DRV_PolyBezier
1059  *      Implement functionality for PolyBezier and PolyBezierTo
1060  *      calls.
1061  *      [i] dc pointer to device context
1062  *      [i] start, first point in curve
1063  *      [i] BezierPoints , array of point filled with rest of the points
1064  *      [i] count, number of points in BezierPoints, must be a
1065  *          multiple of 3.
1066  */
1067 BOOL32
1068 X11DRV_PolyBezier(DC *dc, POINT32 start, POINT32 *BezierPoints, DWORD count)
1069 {
1070     POINT32 Points[4];
1071     int i;
1072     unsigned int ix=0;
1073     XPoint* xpoints;
1074     TRACE(graphics, "dc=%04x count=%ld %d,%d - %d,%d - %d,%d -%d,%d \n",
1075             (int)dc, count,
1076             start.x, start.y,
1077             (Points+0)->x, (Points+0)->y,
1078             (Points+1)->x, (Points+1)->y,
1079             (Points+2)->x, (Points+2)->y);
1080     if(!count || count % 3){/* paranoid */
1081         WARN(graphics," bad value for count : %ld\n", count);
1082         return FALSE;
1083     }
1084     xpoints=(XPoint*) xmalloc( sizeof(XPoint)*BEZMAXPOINTS);
1085     Points[3].x=BEZIERSHIFTUP(XLPTODP(dc,start.x));
1086     Points[3].y=BEZIERSHIFTUP(YLPTODP(dc,start.y));
1087     while(count){
1088         Points[0]=Points[3];
1089         for(i=1;i<4;i++) {
1090             Points[i].x= BEZIERSHIFTUP(XLPTODP(dc,BezierPoints->x));
1091             Points[i].y= BEZIERSHIFTUP(YLPTODP(dc,BezierPoints->y));
1092             BezierPoints++;
1093         }
1094         X11DRV_Bezier(BEZIERMAXDEPTH , dc, Points, xpoints, &ix );
1095         count -=3;
1096     }
1097     if( ix) TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
1098                 xpoints, ix, CoordModeOrigin );
1099     free(xpoints);
1100     return TRUE;
1101 }