Release 980201
[wine] / graphics / x11drv / graphics.c
1 /*
2  * X11 graphics driver graphics functions
3  *
4  * Copyright 1993,1994 Alexandre Julliard
5  */
6
7 #include <math.h>
8 #if defined(__EMX__)
9 #include <float.h>
10 #endif
11 #include <stdlib.h>
12 #include "ts_xlib.h"
13 #include "ts_xutil.h"
14 #include <X11/Intrinsic.h>
15 #ifndef PI
16 #define PI M_PI
17 #endif
18 #include <string.h>
19
20 #include "x11drv.h"
21 #include "bitmap.h"
22 #include "gdi.h"
23 #include "graphics.h"
24 #include "dc.h"
25 #include "bitmap.h"
26 #include "callback.h"
27 #include "metafile.h"
28 #include "stddebug.h"
29 #include "palette.h"
30 #include "color.h"
31 #include "region.h"
32 #include "struct32.h"
33 #include "debug.h"
34 #include "xmalloc.h"
35
36
37 /**********************************************************************
38  *           X11DRV_MoveToEx
39  */
40 BOOL32
41 X11DRV_MoveToEx(DC *dc,INT32 x,INT32 y,LPPOINT32 pt) {
42     if (pt)
43     {
44         pt->x = dc->w.CursPosX;
45         pt->y = dc->w.CursPosY;
46     }
47     dc->w.CursPosX = x;
48     dc->w.CursPosY = y;
49     return TRUE;
50 }
51
52 /***********************************************************************
53  *           X11DRV_LineTo
54  */
55 BOOL32
56 X11DRV_LineTo( DC *dc, INT32 x, INT32 y )
57 {
58     if (DC_SetupGCForPen( dc ))
59         TSXDrawLine(display, dc->u.x.drawable, dc->u.x.gc, 
60                   dc->w.DCOrgX + XLPTODP( dc, dc->w.CursPosX ),
61                   dc->w.DCOrgY + YLPTODP( dc, dc->w.CursPosY ),
62                   dc->w.DCOrgX + XLPTODP( dc, x ),
63                   dc->w.DCOrgY + YLPTODP( dc, y ) );
64     dc->w.CursPosX = x;
65     dc->w.CursPosY = y;
66     return TRUE;
67 }
68
69
70
71 /***********************************************************************
72  *           GRAPH_DrawArc
73  *
74  * Helper functions for Arc(), Chord() and Pie().
75  * 'lines' is the number of lines to draw: 0 for Arc, 1 for Chord, 2 for Pie.
76  */
77 static BOOL32
78 X11DRV_DrawArc( DC *dc, INT32 left, INT32 top, INT32 right,
79                 INT32 bottom, INT32 xstart, INT32 ystart,
80                 INT32 xend, INT32 yend, INT32 lines )
81 {
82     INT32 xcenter, ycenter, istart_angle, idiff_angle, tmp;
83     double start_angle, end_angle;
84     XPoint points[3];
85
86     left   = XLPTODP( dc, left );
87     top    = YLPTODP( dc, top );
88     right  = XLPTODP( dc, right );
89     bottom = YLPTODP( dc, bottom );
90     xstart = XLPTODP( dc, xstart );
91     ystart = YLPTODP( dc, ystart );
92     xend   = XLPTODP( dc, xend );
93     yend   = YLPTODP( dc, yend );
94     if ((left == right) || (top == bottom)) return FALSE;
95
96     xcenter = (right + left) / 2;
97     ycenter = (bottom + top) / 2;
98     start_angle = atan2( (double)(ycenter-ystart)*(right-left),
99                          (double)(xstart-xcenter)*(bottom-top) );
100     end_angle   = atan2( (double)(ycenter-yend)*(right-left),
101                          (double)(xend-xcenter)*(bottom-top) );
102     istart_angle = (INT32)(start_angle * 180 * 64 / PI);
103     idiff_angle  = (INT32)((end_angle - start_angle) * 180 * 64 / PI );
104     if (idiff_angle <= 0) idiff_angle += 360 * 64;
105     if (left > right) { tmp=left; left=right; right=tmp; }
106     if (top > bottom) { tmp=top; top=bottom; bottom=tmp; }
107
108       /* Fill arc with brush if Chord() or Pie() */
109
110     if ((lines > 0) && DC_SetupGCForBrush( dc ))
111     {
112         TSXSetArcMode( display, dc->u.x.gc, (lines==1) ? ArcChord : ArcPieSlice);
113         TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
114                  dc->w.DCOrgX + left, dc->w.DCOrgY + top,
115                  right-left-1, bottom-top-1, istart_angle, idiff_angle );
116     }
117
118       /* Draw arc and lines */
119
120     if (!DC_SetupGCForPen( dc )) return TRUE;
121     TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
122               dc->w.DCOrgX + left, dc->w.DCOrgY + top,
123               right-left-1, bottom-top-1, istart_angle, idiff_angle );
124     if (!lines) return TRUE;
125
126     points[0].x = dc->w.DCOrgX + xcenter + (int)(cos(start_angle) * (right-left) / 2);
127     points[0].y = dc->w.DCOrgY + ycenter - (int)(sin(start_angle) * (bottom-top) / 2);
128     points[1].x = dc->w.DCOrgX + xcenter + (int)(cos(end_angle) * (right-left) / 2);
129     points[1].y = dc->w.DCOrgY + ycenter - (int)(sin(end_angle) * (bottom-top) / 2);
130     if (lines == 2)
131     {
132         points[2] = points[1];
133         points[1].x = dc->w.DCOrgX + xcenter;
134         points[1].y = dc->w.DCOrgY + ycenter;
135     }
136     TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
137                 points, lines+1, CoordModeOrigin );
138     return TRUE;
139 }
140
141
142 /***********************************************************************
143  *           X11DRV_Arc
144  */
145 BOOL32
146 X11DRV_Arc( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom,
147             INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
148 {
149     return X11DRV_DrawArc( dc, left, top, right, bottom,
150                            xstart, ystart, xend, yend, 0 );
151 }
152
153
154 /***********************************************************************
155  *           X11DRV_Pie
156  */
157 BOOL32
158 X11DRV_Pie( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom,
159             INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
160 {
161     return X11DRV_DrawArc( dc, left, top, right, bottom,
162                            xstart, ystart, xend, yend, 2 );
163 }
164
165 /***********************************************************************
166  *           X11DRV_Chord
167  */
168 BOOL32
169 X11DRV_Chord( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom,
170               INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
171 {
172     return X11DRV_DrawArc( dc, left, top, right, bottom,
173                            xstart, ystart, xend, yend, 1 );
174 }
175
176
177 /***********************************************************************
178  *           X11DRV_Ellipse
179  */
180 BOOL32
181 X11DRV_Ellipse( DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom )
182 {
183     left   = XLPTODP( dc, left );
184     top    = YLPTODP( dc, top );
185     right  = XLPTODP( dc, right );
186     bottom = YLPTODP( dc, bottom );
187     if ((left == right) || (top == bottom)) return FALSE;
188
189     if (right < left) { INT32 tmp = right; right = left; left = tmp; }
190     if (bottom < top) { INT32 tmp = bottom; bottom = top; top = tmp; }
191     
192     if ((dc->u.x.pen.style == PS_INSIDEFRAME) &&
193         (dc->u.x.pen.width < right-left-1) &&
194         (dc->u.x.pen.width < bottom-top-1))
195     {
196         left   += dc->u.x.pen.width / 2;
197         right  -= (dc->u.x.pen.width + 1) / 2;
198         top    += dc->u.x.pen.width / 2;
199         bottom -= (dc->u.x.pen.width + 1) / 2;
200     }
201
202     if (DC_SetupGCForBrush( dc ))
203         TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
204                   dc->w.DCOrgX + left, dc->w.DCOrgY + top,
205                   right-left-1, bottom-top-1, 0, 360*64 );
206     if (DC_SetupGCForPen( dc ))
207         TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
208                   dc->w.DCOrgX + left, dc->w.DCOrgY + top,
209                   right-left-1, bottom-top-1, 0, 360*64 );
210     return TRUE;
211 }
212
213
214 /***********************************************************************
215  *           X11DRV_Rectangle
216  */
217 BOOL32
218 X11DRV_Rectangle(DC *dc, INT32 left, INT32 top, INT32 right, INT32 bottom)
219 {
220     INT32 width;
221     left   = XLPTODP( dc, left );
222     top    = YLPTODP( dc, top );
223     right  = XLPTODP( dc, right );
224     bottom = YLPTODP( dc, bottom );
225
226     if (right < left) { INT32 tmp = right; right = left; left = tmp; }
227     if (bottom < top) { INT32 tmp = bottom; bottom = top; top = tmp; }
228
229     if ((left == right) || (top == bottom))
230     {
231         if (DC_SetupGCForPen( dc ))
232             TSXDrawLine(display, dc->u.x.drawable, dc->u.x.gc, 
233                   dc->w.DCOrgX + left,
234                   dc->w.DCOrgY + top,
235                   dc->w.DCOrgX + right,
236                   dc->w.DCOrgY + bottom);
237         return TRUE;
238     }
239     width = dc->u.x.pen.width;
240     if (!width) width = 1;
241     if(dc->u.x.pen.style == PS_NULL) width = 0;
242
243     if ((dc->u.x.pen.style == PS_INSIDEFRAME) &&
244         (width < right-left) && (width < bottom-top))
245     {
246         left   += width / 2;
247         right  -= (width + 1) / 2;
248         top    += width / 2;
249         bottom -= (width + 1) / 2;
250     }
251
252     if ((right > left + width) && (bottom > top + width))
253     {
254         if (DC_SetupGCForBrush( dc ))
255             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
256                             dc->w.DCOrgX + left + (width + 1) / 2,
257                             dc->w.DCOrgY + top + (width + 1) / 2,
258                             right-left-width-1, bottom-top-width-1);
259     }
260     if (DC_SetupGCForPen( dc ))
261         TSXDrawRectangle( display, dc->u.x.drawable, dc->u.x.gc,
262                         dc->w.DCOrgX + left, dc->w.DCOrgY + top,
263                         right-left-1, bottom-top-1 );
264     return TRUE;
265 }
266
267 /***********************************************************************
268  *           X11DRV_RoundRect
269  */
270 BOOL32
271 X11DRV_RoundRect( DC *dc, INT32 left, INT32 top, INT32 right,
272                   INT32 bottom, INT32 ell_width, INT32 ell_height )
273 {
274     dprintf_graphics(stddeb, "X11DRV_RoundRect(%d %d %d %d  %d %d\n", 
275         left, top, right, bottom, ell_width, ell_height);
276
277     left   = XLPTODP( dc, left );
278     top    = YLPTODP( dc, top );
279     right  = XLPTODP( dc, right );
280     bottom = YLPTODP( dc, bottom );
281     ell_width  = abs( ell_width * dc->vportExtX / dc->wndExtX );
282     ell_height = abs( ell_height * dc->vportExtY / dc->wndExtY );
283
284     /* Fix the coordinates */
285
286     if (right < left) { INT32 tmp = right; right = left; left = tmp; }
287     if (bottom < top) { INT32 tmp = bottom; bottom = top; top = tmp; }
288     if (ell_width > right - left) ell_width = right - left;
289     if (ell_height > bottom - top) ell_height = bottom - top;
290
291     if (DC_SetupGCForBrush( dc ))
292     {
293         if (ell_width && ell_height)
294         {
295             TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
296                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
297                       ell_width, ell_height, 90 * 64, 90 * 64 );
298             TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
299                       dc->w.DCOrgX + left, dc->w.DCOrgY + bottom - ell_height,
300                       ell_width, ell_height, 180 * 64, 90 * 64 );
301             TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
302                       dc->w.DCOrgX + right - ell_width,
303                       dc->w.DCOrgY + bottom - ell_height,
304                       ell_width, ell_height, 270 * 64, 90 * 64 );
305             TSXFillArc( display, dc->u.x.drawable, dc->u.x.gc,
306                       dc->w.DCOrgX + right - ell_width, dc->w.DCOrgY + top,
307                       ell_width, ell_height, 0, 90 * 64 );
308         }
309         if (ell_width < right - left)
310         {
311             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
312                             dc->w.DCOrgX + left + ell_width / 2,
313                             dc->w.DCOrgY + top,
314                             right - left - ell_width, ell_height / 2 );
315             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
316                             dc->w.DCOrgX + left + ell_width / 2,
317                             dc->w.DCOrgY + bottom - (ell_height+1) / 2,
318                             right - left - ell_width, (ell_height+1) / 2 );
319         }
320         if  (ell_height < bottom - top)
321         {
322             TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
323                             dc->w.DCOrgX + left,
324                             dc->w.DCOrgY + top + ell_height / 2,
325                             right - left, bottom - top - ell_height );
326         }
327     }
328     if (DC_SetupGCForPen(dc))
329     {
330         if (ell_width && ell_height)
331         {
332             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
333                       dc->w.DCOrgX + left, dc->w.DCOrgY + top,
334                       ell_width, ell_height, 90 * 64, 90 * 64 );
335             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
336                       dc->w.DCOrgX + left, dc->w.DCOrgY + bottom - ell_height,
337                       ell_width, ell_height, 180 * 64, 90 * 64 );
338             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
339                       dc->w.DCOrgX + right - ell_width,
340                       dc->w.DCOrgY + bottom - ell_height,
341                       ell_width, ell_height, 270 * 64, 90 * 64 );
342             TSXDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
343                       dc->w.DCOrgX + right - ell_width, dc->w.DCOrgY + top,
344                       ell_width, ell_height, 0, 90 * 64 );
345         }
346         if (ell_width < right - left)
347         {
348             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc, 
349                        dc->w.DCOrgX + left + ell_width / 2,
350                        dc->w.DCOrgY + top,
351                        dc->w.DCOrgX + right - ell_width / 2,
352                        dc->w.DCOrgY + top );
353             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc, 
354                        dc->w.DCOrgX + left + ell_width / 2,
355                        dc->w.DCOrgY + bottom,
356                        dc->w.DCOrgX + right - ell_width / 2,
357                        dc->w.DCOrgY + bottom );
358         }
359         if (ell_height < bottom - top)
360         {
361             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc, 
362                        dc->w.DCOrgX + right,
363                        dc->w.DCOrgY + top + ell_height / 2,
364                        dc->w.DCOrgX + right,
365                        dc->w.DCOrgY + bottom - ell_height / 2 );
366             TSXDrawLine( display, dc->u.x.drawable, dc->u.x.gc, 
367                        dc->w.DCOrgX + left,
368                        dc->w.DCOrgY + top + ell_height / 2,
369                        dc->w.DCOrgX + left,
370                        dc->w.DCOrgY + bottom - ell_height / 2 );
371         }
372     }
373     return TRUE;
374 }
375
376
377 /***********************************************************************
378  *           X11DRV_SetPixel
379  */
380 COLORREF
381 X11DRV_SetPixel( DC *dc, INT32 x, INT32 y, COLORREF color )
382 {
383     Pixel pixel;
384     
385     x = dc->w.DCOrgX + XLPTODP( dc, x );
386     y = dc->w.DCOrgY + YLPTODP( dc, y );
387     pixel = COLOR_ToPhysical( dc, color );
388     
389     TSXSetForeground( display, dc->u.x.gc, pixel );
390     TSXSetFunction( display, dc->u.x.gc, GXcopy );
391     TSXDrawPoint( display, dc->u.x.drawable, dc->u.x.gc, x, y );
392
393     /* inefficient but simple... */
394
395     return COLOR_ToLogical(pixel);
396 }
397
398
399 /***********************************************************************
400  *           X11DRV_GetPixel
401  */
402 COLORREF
403 X11DRV_GetPixel( DC *dc, INT32 x, INT32 y )
404 {
405     static Pixmap pixmap = 0;
406     XImage * image;
407     int pixel;
408
409     x = dc->w.DCOrgX + XLPTODP( dc, x );
410     y = dc->w.DCOrgY + YLPTODP( dc, y );
411     if (dc->w.flags & DC_MEMORY)
412     {
413         image = TSXGetImage( display, dc->u.x.drawable, x, y, 1, 1,
414                            AllPlanes, ZPixmap );
415     }
416     else
417     {
418         /* If we are reading from the screen, use a temporary copy */
419         /* to avoid a BadMatch error */
420         if (!pixmap) pixmap = TSXCreatePixmap( display, rootWindow,
421                                              1, 1, dc->w.bitsPerPixel );
422         TSXCopyArea( display, dc->u.x.drawable, pixmap, BITMAP_colorGC,
423                    x, y, 1, 1, 0, 0 );
424         image = TSXGetImage( display, pixmap, 0, 0, 1, 1, AllPlanes, ZPixmap );
425     }
426     pixel = TSXGetPixel( image, 0, 0 );
427     TSXDestroyImage( image );
428     
429     return COLOR_ToLogical(pixel);
430 }
431
432
433 /***********************************************************************
434  *           X11DRV_PaintRgn
435  */
436 BOOL32
437 X11DRV_PaintRgn( DC *dc, HRGN32 hrgn )
438 {
439     RECT32 box;
440     HRGN32 tmpVisRgn, prevVisRgn;
441     HDC32  hdc = dc->hSelf; /* FIXME: should not mix dc/hdc this way */
442
443     if (!(tmpVisRgn = CreateRectRgn32( 0, 0, 0, 0 ))) return FALSE;
444
445       /* Transform region into device co-ords */
446     if (!REGION_LPTODP( hdc, tmpVisRgn, hrgn )) {
447         DeleteObject32( tmpVisRgn );
448         return FALSE;
449     }
450
451       /* Modify visible region */
452     if (!(prevVisRgn = SaveVisRgn( hdc ))) {
453         DeleteObject32( tmpVisRgn );
454         return FALSE;
455     }
456     CombineRgn32( tmpVisRgn, prevVisRgn, tmpVisRgn, RGN_AND );
457     SelectVisRgn( hdc, tmpVisRgn );
458     DeleteObject32( tmpVisRgn );
459
460       /* Fill the region */
461
462     GetRgnBox32( dc->w.hGCClipRgn, &box );
463     if (DC_SetupGCForBrush( dc ))
464         TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
465                         dc->w.DCOrgX + box.left, dc->w.DCOrgY + box.top,
466                         box.right-box.left, box.bottom-box.top );
467
468       /* Restore the visible region */
469
470     RestoreVisRgn( hdc );
471     return TRUE;
472 }
473
474 /**********************************************************************
475  *          X11DRV_Polyline
476  */
477 BOOL32
478 X11DRV_Polyline( DC *dc, const LPPOINT32 pt, INT32 count )
479 {
480     register int i;
481
482     if (DC_SetupGCForPen( dc ))
483         for (i = 0; i < count-1; i ++)
484             TSXDrawLine (display, dc->u.x.drawable, dc->u.x.gc,  
485                        dc->w.DCOrgX + XLPTODP(dc, pt [i].x),
486                        dc->w.DCOrgY + YLPTODP(dc, pt [i].y),
487                        dc->w.DCOrgX + XLPTODP(dc, pt [i+1].x),
488                        dc->w.DCOrgY + YLPTODP(dc, pt [i+1].y));
489     return TRUE;
490 }
491
492
493 /**********************************************************************
494  *          X11DRV_Polygon
495  */
496 BOOL32
497 X11DRV_Polygon( DC *dc, LPPOINT32 pt, INT32 count )
498 {
499     register int i;
500     XPoint *points;
501
502     points = (XPoint *) xmalloc (sizeof (XPoint) * (count+1));
503     for (i = 0; i < count; i++)
504     {
505         points[i].x = dc->w.DCOrgX + XLPTODP( dc, pt[i].x );
506         points[i].y = dc->w.DCOrgY + YLPTODP( dc, pt[i].y );
507     }
508     points[count] = points[0];
509
510     if (DC_SetupGCForBrush( dc ))
511         TSXFillPolygon( display, dc->u.x.drawable, dc->u.x.gc,
512                      points, count+1, Complex, CoordModeOrigin);
513
514     if (DC_SetupGCForPen ( dc ))
515         TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
516                    points, count+1, CoordModeOrigin );
517
518     free( points );
519     return TRUE;
520 }
521
522
523 /**********************************************************************
524  *          X11DRV_PolyPolygon
525  */
526 BOOL32 
527 X11DRV_PolyPolygon( DC *dc, LPPOINT32 pt, LPINT32 counts, UINT32 polygons)
528 {
529     HRGN32 hrgn;
530
531       /* FIXME: The points should be converted to device coords before */
532       /* creating the region. But as CreatePolyPolygonRgn is not */
533       /* really correct either, it doesn't matter much... */
534       /* At least the outline will be correct :-) */
535     hrgn = CreatePolyPolygonRgn32( pt, counts, polygons, dc->w.polyFillMode );
536     X11DRV_PaintRgn( dc, hrgn );
537     DeleteObject32( hrgn );
538
539       /* Draw the outline of the polygons */
540
541     if (DC_SetupGCForPen ( dc ))
542     {
543         int i, j, max = 0;
544         XPoint *points;
545
546         for (i = 0; i < polygons; i++) if (counts[i] > max) max = counts[i];
547         points = (XPoint *) xmalloc( sizeof(XPoint) * (max+1) );
548
549         for (i = 0; i < polygons; i++)
550         {
551             for (j = 0; j < counts[i]; j++)
552             {
553                 points[j].x = dc->w.DCOrgX + XLPTODP( dc, pt->x );
554                 points[j].y = dc->w.DCOrgY + YLPTODP( dc, pt->y );
555                 pt++;
556             }
557             points[j] = points[0];
558             TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
559                         points, j + 1, CoordModeOrigin );
560         }
561         free( points );
562     }
563     return TRUE;
564 }
565
566
567 /**********************************************************************
568  *          X11DRV_InternalFloodFill
569  *
570  * Internal helper function for flood fill.
571  * (xorg,yorg) is the origin of the X image relative to the drawable.
572  * (x,y) is relative to the origin of the X image.
573  */
574 static void X11DRV_InternalFloodFill(XImage *image, DC *dc,
575                                      int x, int y,
576                                      int xOrg, int yOrg,
577                                      Pixel pixel, WORD fillType )
578 {
579     int left, right;
580
581 #define TO_FLOOD(x,y)  ((fillType == FLOODFILLBORDER) ? \
582                         (TSXGetPixel(image,x,y) != pixel) : \
583                         (TSXGetPixel(image,x,y) == pixel))
584
585     if (!TO_FLOOD(x,y)) return;
586
587       /* Find left and right boundaries */
588
589     left = right = x;
590     while ((left > 0) && TO_FLOOD( left-1, y )) left--;
591     while ((right < image->width) && TO_FLOOD( right, y )) right++;
592     TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
593                     xOrg + left, yOrg + y, right-left, 1 );
594
595       /* Set the pixels of this line so we don't fill it again */
596
597     for (x = left; x < right; x++)
598     {
599         if (fillType == FLOODFILLBORDER) TSXPutPixel( image, x, y, pixel );
600         else TSXPutPixel( image, x, y, ~pixel );
601     }
602
603       /* Fill the line above */
604
605     if (--y >= 0)
606     {
607         x = left;
608         while (x < right)
609         {
610             while ((x < right) && !TO_FLOOD(x,y)) x++;
611             if (x >= right) break;
612             while ((x < right) && TO_FLOOD(x,y)) x++;
613             X11DRV_InternalFloodFill(image, dc, x-1, y,
614                                      xOrg, yOrg, pixel, fillType );
615         }
616     }
617
618       /* Fill the line below */
619
620     if ((y += 2) < image->height)
621     {
622         x = left;
623         while (x < right)
624         {
625             while ((x < right) && !TO_FLOOD(x,y)) x++;
626             if (x >= right) break;
627             while ((x < right) && TO_FLOOD(x,y)) x++;
628             X11DRV_InternalFloodFill(image, dc, x-1, y,
629                                      xOrg, yOrg, pixel, fillType );
630         }
631     }
632 #undef TO_FLOOD    
633 }
634
635
636 /**********************************************************************
637  *          X11DRV_DoFloodFill
638  *
639  * Main flood-fill routine.
640  */
641
642 struct FloodFill_params
643 {
644     DC      *dc;
645     INT32    x;
646     INT32    y;
647     COLORREF color;
648     UINT32   fillType;
649 };
650
651 static BOOL32 X11DRV_DoFloodFill( const struct FloodFill_params *params )
652 {
653     XImage *image;
654     RECT32 rect;
655     DC *dc = params->dc;
656
657     if (GetRgnBox32( dc->w.hGCClipRgn, &rect ) == ERROR) return FALSE;
658
659     if (!(image = TSXGetImage( display, dc->u.x.drawable,
660                              dc->w.DCOrgX + rect.left,
661                              dc->w.DCOrgY + rect.top,
662                              rect.right - rect.left,
663                              rect.bottom - rect.top,
664                              AllPlanes, ZPixmap ))) return FALSE;
665
666     if (DC_SetupGCForBrush( dc ))
667     {
668           /* ROP mode is always GXcopy for flood-fill */
669         TSXSetFunction( display, dc->u.x.gc, GXcopy );
670         X11DRV_InternalFloodFill(image, dc,
671                                  XLPTODP(dc,params->x) - rect.left,
672                                  YLPTODP(dc,params->y) - rect.top,
673                                  dc->w.DCOrgX + rect.left,
674                                  dc->w.DCOrgY + rect.top,
675                                  COLOR_ToPhysical( dc, params->color ),
676                                  params->fillType );
677     }
678
679     TSXDestroyImage( image );
680     return TRUE;
681 }
682
683
684 /**********************************************************************
685  *          X11DRV_ExtFloodFill
686  */
687 BOOL32
688 X11DRV_ExtFloodFill( DC *dc, INT32 x, INT32 y, COLORREF color,
689                      UINT32 fillType )
690 {
691     struct FloodFill_params params = { dc, x, y, color, fillType };
692
693     dprintf_graphics( stddeb, "X11DRV_ExtFloodFill %d,%d %06lx %d\n",
694                       x, y, color, fillType );
695
696     if (!PtVisible32( dc->hSelf, x, y )) return FALSE;
697     return CALL_LARGE_STACK( X11DRV_DoFloodFill, &params );
698 }