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