?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 981025.
[wine/multimedia.git] / graphics / x11drv / graphics.c
blob750c757841a2b44ec65467ec968a637c2f79cddf
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 || OffsetRgn32( tmpVisRgn, dc->w.DCOrgX, dc->w.DCOrgY ) == ERROR) {
624 DeleteObject32( tmpVisRgn );
625 return FALSE;
626 }
627
628 /* Modify visible region */
629 if (!(prevVisRgn = SaveVisRgn( hdc ))) {
630 DeleteObject32( tmpVisRgn );
631 return FALSE;
632 }
633 CombineRgn32( tmpVisRgn, prevVisRgn, tmpVisRgn, RGN_AND );
634 SelectVisRgn( hdc, tmpVisRgn );
635 DeleteObject32( tmpVisRgn );
636
637 /* Fill the region */
638
639 GetRgnBox32( dc->w.hGCClipRgn, &box );
640 if (DC_SetupGCForBrush( dc ))
641 TSXFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
642 box.left, box.top,
643 box.right-box.left, box.bottom-box.top );
644
645 /* Restore the visible region */
646
647 RestoreVisRgn( hdc );
648 return TRUE;
649 }
650
651 /**********************************************************************
652 * X11DRV_Polyline
653 */
654 BOOL32
655 X11DRV_Polyline( DC *dc, LPPOINT32 pt, INT32 count )
656 {
657 INT32 oldwidth;
658 register int i;
659 XPoint *points;
660 if((oldwidth=dc->u.x.pen.width)==0) dc->u.x.pen.width=1;
661
662 points = (XPoint *) xmalloc (sizeof (XPoint) * (count));
663 for (i = 0; i < count; i++)
664 {
665 points[i].x = dc->w.DCOrgX + XLPTODP( dc, pt[i].x );
666 points[i].y = dc->w.DCOrgY + YLPTODP( dc, pt[i].y );
667 }
668
669 if (DC_SetupGCForPen ( dc ))
670 TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
671 points, count, CoordModeOrigin );
672
673 free( points );
674 dc->u.x.pen.width=oldwidth;
675 return TRUE;
676 }
677
678
679 /**********************************************************************
680 * X11DRV_Polygon
681 */
682 BOOL32
683 X11DRV_Polygon( DC *dc, LPPOINT32 pt, INT32 count )
684 {
685 register int i;
686 XPoint *points;
687
688 points = (XPoint *) xmalloc (sizeof (XPoint) * (count+1));
689 for (i = 0; i < count; i++)
690 {
691 points[i].x = dc->w.DCOrgX + XLPTODP( dc, pt[i].x );
692 points[i].y = dc->w.DCOrgY + YLPTODP( dc, pt[i].y );
693 }
694 points[count] = points[0];
695
696 if (DC_SetupGCForBrush( dc ))
697 TSXFillPolygon( display, dc->u.x.drawable, dc->u.x.gc,
698 points, count+1, Complex, CoordModeOrigin);
699
700 if (DC_SetupGCForPen ( dc ))
701 TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
702 points, count+1, CoordModeOrigin );
703
704 free( points );
705 return TRUE;
706 }
707
708
709 /**********************************************************************
710 * X11DRV_PolyPolygon
711 */
712 BOOL32
713 X11DRV_PolyPolygon( DC *dc, LPPOINT32 pt, LPINT32 counts, UINT32 polygons)
714 {
715 HRGN32 hrgn;
716
717 /* FIXME: The points should be converted to device coords before */
718 /* creating the region. But as CreatePolyPolygonRgn is not */
719 /* really correct either, it doesn't matter much... */
720 /* At least the outline will be correct :-) */
721 hrgn = CreatePolyPolygonRgn32( pt, counts, polygons, dc->w.polyFillMode );
722 X11DRV_PaintRgn( dc, hrgn );
723 DeleteObject32( hrgn );
724
725 /* Draw the outline of the polygons */
726
727 if (DC_SetupGCForPen ( dc ))
728 {
729 int i, j, max = 0;
730 XPoint *points;
731
732 for (i = 0; i < polygons; i++) if (counts[i] > max) max = counts[i];
733 points = (XPoint *) xmalloc( sizeof(XPoint) * (max+1) );
734
735 for (i = 0; i < polygons; i++)
736 {
737 for (j = 0; j < counts[i]; j++)
738 {
739 points[j].x = dc->w.DCOrgX + XLPTODP( dc, pt->x );
740 points[j].y = dc->w.DCOrgY + YLPTODP( dc, pt->y );
741 pt++;
742 }
743 points[j] = points[0];
744 TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
745 points, j + 1, CoordModeOrigin );
746 }
747 free( points );
748 }
749 return TRUE;
750 }
751
752
753 /**********************************************************************
754 * X11DRV_PolyPolyline
755 */
756 BOOL32
757 X11DRV_PolyPolyline( DC *dc, LPPOINT32 pt, LPDWORD counts, DWORD polylines )
758 {
759 if (DC_SetupGCForPen ( dc ))
760 {
761 int i, j, max = 0;
762 XPoint *points;
763
764 for (i = 0; i < polylines; i++) if (counts[i] > max) max = counts[i];
765 points = (XPoint *) xmalloc( sizeof(XPoint) * (max+1) );
766
767 for (i = 0; i < polylines; i++)
768 {
769 for (j = 0; j < counts[i]; j++)
770 {
771 points[j].x = dc->w.DCOrgX + XLPTODP( dc, pt->x );
772 points[j].y = dc->w.DCOrgY + YLPTODP( dc, pt->y );
773 pt++;
774 }
775 points[j] = points[0];
776 TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
777 points, j + 1, CoordModeOrigin );
778 }
779 free( points );
780 }
781 return TRUE;
782 }
783
784
785 /**********************************************************************
786 * X11DRV_InternalFloodFill
787 *
788 * Internal helper function for flood fill.
789 * (xorg,yorg) is the origin of the X image relative to the drawable.
790 * (x,y) is relative to the origin of the X image.
791 */
792 static void X11DRV_InternalFloodFill(XImage *image, DC *dc,
793 int x, int y,
794 int xOrg, int yOrg,
795 Pixel pixel, WORD fillType )
796 {
797 int left, right;
798
799 #define TO_FLOOD(x,y) ((fillType == FLOODFILLBORDER) ? \
800 (XGetPixel(image,x,y) != pixel) : \
801 (XGetPixel(image,x,y) == pixel))
802
803 if (!TO_FLOOD(x,y)) return;
804
805 /* Find left and right boundaries */
806
807 left = right = x;
808 while ((left > 0) && TO_FLOOD( left-1, y )) left--;
809 while ((right < image->width) && TO_FLOOD( right, y )) right++;
810 XFillRectangle( display, dc->u.x.drawable, dc->u.x.gc,
811 xOrg + left, yOrg + y, right-left, 1 );
812
813 /* Set the pixels of this line so we don't fill it again */
814
815 for (x = left; x < right; x++)
816 {
817 if (fillType == FLOODFILLBORDER) XPutPixel( image, x, y, pixel );
818 else XPutPixel( image, x, y, ~pixel );
819 }
820
821 /* Fill the line above */
822
823 if (--y >= 0)
824 {
825 x = left;
826 while (x < right)
827 {
828 while ((x < right) && !TO_FLOOD(x,y)) x++;
829 if (x >= right) break;
830 while ((x < right) && TO_FLOOD(x,y)) x++;
831 X11DRV_InternalFloodFill(image, dc, x-1, y,
832 xOrg, yOrg, pixel, fillType );
833 }
834 }
835
836 /* Fill the line below */
837
838 if ((y += 2) < image->height)
839 {
840 x = left;
841 while (x < right)
842 {
843 while ((x < right) && !TO_FLOOD(x,y)) x++;
844 if (x >= right) break;
845 while ((x < right) && TO_FLOOD(x,y)) x++;
846 X11DRV_InternalFloodFill(image, dc, x-1, y,
847 xOrg, yOrg, pixel, fillType );
848 }
849 }
850 #undef TO_FLOOD
851 }
852
853
854 /**********************************************************************
855 * X11DRV_DoFloodFill
856 *
857 * Main flood-fill routine.
858 *
859 * The Xlib critical section must be entered before calling this function.
860 */
861
862 struct FloodFill_params
863 {
864 DC *dc;
865 INT32 x;
866 INT32 y;
867 COLORREF color;
868 UINT32 fillType;
869 };
870
871 static BOOL32 X11DRV_DoFloodFill( const struct FloodFill_params *params )
872 {
873 XImage *image;
874 RECT32 rect;
875 DC *dc = params->dc;
876
877 if (GetRgnBox32( dc->w.hGCClipRgn, &rect ) == ERROR) return FALSE;
878
879 if (!(image = XGetImage( display, dc->u.x.drawable,
880 rect.left,
881 rect.top,
882 rect.right - rect.left,
883 rect.bottom - rect.top,
884 AllPlanes, ZPixmap ))) return FALSE;
885
886 if (DC_SetupGCForBrush( dc ))
887 {
888 /* ROP mode is always GXcopy for flood-fill */
889 XSetFunction( display, dc->u.x.gc, GXcopy );
890 X11DRV_InternalFloodFill(image, dc,
891 XLPTODP(dc,params->x) + dc->w.DCOrgX - rect.left,
892 YLPTODP(dc,params->y) + dc->w.DCOrgY - rect.top,
893 rect.left,
894 rect.top,
895 COLOR_ToPhysical( dc, params->color ),
896 params->fillType );
897 }
898
899 XDestroyImage( image );
900 return TRUE;
901 }
902
903
904 /**********************************************************************
905 * X11DRV_ExtFloodFill
906 */
907 BOOL32
908 X11DRV_ExtFloodFill( DC *dc, INT32 x, INT32 y, COLORREF color,
909 UINT32 fillType )
910 {
911 BOOL32 result;
912 struct FloodFill_params params = { dc, x, y, color, fillType };
913
914 TRACE(graphics, "X11DRV_ExtFloodFill %d,%d %06lx %d\n",
915 x, y, color, fillType );
916
917 if (!PtVisible32( dc->hSelf, x, y )) return FALSE;
918 EnterCriticalSection( &X11DRV_CritSection );
919 result = CALL_LARGE_STACK( X11DRV_DoFloodFill, &params );
920 LeaveCriticalSection( &X11DRV_CritSection );
921 return result;
922 }
923
924 /******************************************************************
925 *
926 * *Very* simple bezier drawing code,
927 *
928 * It uses a recursive algorithm to divide the curve in a series
929 * of straight line segements. Not ideal but for me sufficient.
930 * If you are in need for something better look for some incremental
931 * algorithm.
932 *
933 * 7 July 1998 Rein Klazes
934 */
935
936 /*
937 * some macro definitions for bezier drawing
938 *
939 * to avoid trucation errors the coordinates are
940 * shifted upwards. When used in drawing they are
941 * shifted down again, including correct rounding
942 * and avoiding floating point arithmatic
943 * 4 bits should allow 27 bits coordinates which I saw
944 * somewere in the win32 doc's
945 *
946 */
947
948 #define BEZIERSHIFTBITS 4
949 #define BEZIERSHIFTUP(x) ((x)<<BEZIERSHIFTBITS)
950 #define BEZIERPIXEL BEZIERSHIFTUP(1)
951 #define BEZIERSHIFTDOWN(x) (((x)+(1<<(BEZIERSHIFTBITS-1)))>>BEZIERSHIFTBITS)
952 /* maximum depth of recursion */
953 #define BEZIERMAXDEPTH 8
954
955 /* size of array to store points on */
956 /* enough for one curve */
957 #define BEZMAXPOINTS (150)
958
959 /* calculate Bezier average, in this case the middle
960 * correctly rounded...
961 * */
962
963 #define BEZIERMIDDLE(Mid, P1, P2) \
964 (Mid).x=((P1).x+(P2).x + 1)/2;\
965 (Mid).y=((P1).y+(P2).y + 1)/2;
966
967 /**********************************************************
968 * BezierCheck helper function to check
969 * that recursion can be terminated
970 * Points[0] and Points[3] are begin and endpoint
971 * Points[1] and Points[2] are control points
972 * level is the recursion depth
973 * returns true if the recusion can be terminated
974 */
975 static BOOL32 BezierCheck( int level, POINT32 *Points)
976 {
977 INT32 dx, dy;
978 dx=Points[3].x-Points[0].x;
979 dy=Points[3].y-Points[0].y;
980 if(ABS(dy)<=ABS(dx)){/* shallow line */
981 /* check that control points are between begin and end */
982 if(Points[1].x < Points[0].x){
983 if(Points[1].x < Points[3].x)
984 return FALSE;
985 }else
986 if(Points[1].x > Points[3].x)
987 return FALSE;
988 if(Points[2].x < Points[0].x){
989 if(Points[2].x < Points[3].x)
990 return FALSE;
991 }else
992 if(Points[2].x > Points[3].x)
993 return FALSE;
994 dx=BEZIERSHIFTDOWN(dx);
995 if(!dx) return TRUE;
996 if(abs(Points[1].y-Points[0].y-(dy/dx)*
997 BEZIERSHIFTDOWN(Points[1].x-Points[0].x)) > BEZIERPIXEL ||
998 abs(Points[2].y-Points[0].y-(dy/dx)*
999 BEZIERSHIFTDOWN(Points[2].x-Points[0].x)) > BEZIERPIXEL )
1000 return FALSE;
1001 else
1002 return TRUE;
1003 }else{ /* steep line */
1004 /* check that control points are between begin and end */
1005 if(Points[1].y < Points[0].y){
1006 if(Points[1].y < Points[3].y)
1007 return FALSE;
1008 }else
1009 if(Points[1].y > Points[3].y)
1010 return FALSE;
1011 if(Points[2].y < Points[0].y){
1012 if(Points[2].y < Points[3].y)
1013 return FALSE;
1014 }else
1015 if(Points[2].y > Points[3].y)
1016 return FALSE;
1017 dy=BEZIERSHIFTDOWN(dy);
1018 if(!dy) return TRUE;
1019 if(abs(Points[1].x-Points[0].x-(dx/dy)*
1020 BEZIERSHIFTDOWN(Points[1].y-Points[0].y)) > BEZIERPIXEL ||
1021 abs(Points[2].x-Points[0].x-(dx/dy)*
1022 BEZIERSHIFTDOWN(Points[2].y-Points[0].y)) > BEZIERPIXEL )
1023 return FALSE;
1024 else
1025 return TRUE;
1026 }
1027 }
1028
1029 /***********************************************************************
1030 * X11DRV_Bezier
1031 * Draw a -what microsoft calls- bezier curve
1032 * The routine recursively devides the curve
1033 * in two parts until a straight line can be drawn
1034 *
1035 * level recusion depth counted backwards
1036 * dc device context
1037 * Points array of begin(0), end(3) and control points(1 and 2)
1038 * XPoints array with points calculated sofar
1039 * *pIx nr points calculated sofar
1040 *
1041 */
1042 static void X11DRV_Bezier(int level, DC * dc, POINT32 *Points,
1043 XPoint* xpoints, unsigned int* pIx)
1044 {
1045 if(*pIx == BEZMAXPOINTS){
1046 TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
1047 xpoints, *pIx, CoordModeOrigin );
1048 *pIx=0;
1049 }
1050 if(!level || BezierCheck(level, Points)) {
1051 if(*pIx == 0){
1052 xpoints[*pIx].x= dc->w.DCOrgX + BEZIERSHIFTDOWN(Points[0].x);
1053 xpoints[*pIx].y= dc->w.DCOrgY + BEZIERSHIFTDOWN(Points[0].y);
1054 *pIx=1;
1055 }
1056 xpoints[*pIx].x= dc->w.DCOrgX + BEZIERSHIFTDOWN(Points[3].x);
1057 xpoints[*pIx].y= dc->w.DCOrgY + BEZIERSHIFTDOWN(Points[3].y);
1058 (*pIx) ++;
1059 } else {
1060 POINT32 Points2[4]; /* for the second recursive call */
1061 Points2[3]=Points[3];
1062 BEZIERMIDDLE(Points2[2], Points[2], Points[3]);
1063 BEZIERMIDDLE(Points2[0], Points[1], Points[2]);
1064 BEZIERMIDDLE(Points2[1],Points2[0],Points2[2]);
1065
1066 BEZIERMIDDLE(Points[1], Points[0], Points[1]);
1067 BEZIERMIDDLE(Points[2], Points[1], Points2[0]);
1068 BEZIERMIDDLE(Points[3], Points[2], Points2[1]);
1069
1070 Points2[0]=Points[3];
1071
1072 /* do the two halves */
1073 X11DRV_Bezier(level-1, dc, Points, xpoints, pIx);
1074 X11DRV_Bezier(level-1, dc, Points2, xpoints, pIx);
1075 }
1076 }
1077
1078 /***********************************************************************
1079 * X11DRV_PolyBezier
1080 * Implement functionality for PolyBezier and PolyBezierTo
1081 * calls.
1082 * [i] dc pointer to device context
1083 * [i] start, first point in curve
1084 * [i] BezierPoints , array of point filled with rest of the points
1085 * [i] count, number of points in BezierPoints, must be a
1086 * multiple of 3.
1087 */
1088 BOOL32
1089 X11DRV_PolyBezier(DC *dc, POINT32 start, POINT32 *BezierPoints, DWORD count)
1090 {
1091 POINT32 Points[4];
1092 int i;
1093 unsigned int ix=0;
1094 XPoint* xpoints;
1095 TRACE(graphics, "dc=%04x count=%ld %d,%d - %d,%d - %d,%d -%d,%d \n",
1096 (int)dc, count,
1097 start.x, start.y,
1098 (Points+0)->x, (Points+0)->y,
1099 (Points+1)->x, (Points+1)->y,
1100 (Points+2)->x, (Points+2)->y);
1101 if(!count || count % 3){/* paranoid */
1102 WARN(graphics," bad value for count : %ld\n", count);
1103 return FALSE;
1104 }
1105 xpoints=(XPoint*) xmalloc( sizeof(XPoint)*BEZMAXPOINTS);
1106 Points[3].x=BEZIERSHIFTUP(XLPTODP(dc,start.x));
1107 Points[3].y=BEZIERSHIFTUP(YLPTODP(dc,start.y));
1108 while(count){
1109 Points[0]=Points[3];
1110 for(i=1;i<4;i++) {
1111 Points[i].x= BEZIERSHIFTUP(XLPTODP(dc,BezierPoints->x));
1112 Points[i].y= BEZIERSHIFTUP(YLPTODP(dc,BezierPoints->y));
1113 BezierPoints++;
1114 }
1115 X11DRV_Bezier(BEZIERMAXDEPTH , dc, Points, xpoints, &ix );
1116 count -=3;
1117 }
1118 if( ix) TSXDrawLines( display, dc->u.x.drawable, dc->u.x.gc,
1119 xpoints, ix, CoordModeOrigin );
1120 free(xpoints);
1121 return TRUE;
1122 }
1123
1124 /**********************************************************************
1125 * X11DRV_SetBkColor
1126 */
1127 COLORREF
1128 X11DRV_SetBkColor( DC *dc, COLORREF color )
1129 {
1130 X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
1131 COLORREF oldColor;
1132
1133 oldColor = dc->w.backgroundColor;
1134 dc->w.backgroundColor = color;
1135
1136 physDev->backgroundPixel = COLOR_ToPhysical( dc, color );
1137
1138 return oldColor;
1139 }
1140
1141 /**********************************************************************
1142 * X11DRV_SetTextColor
1143 */
1144 COLORREF
1145 X11DRV_SetTextColor( DC *dc, COLORREF color )
1146 {
1147 X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
1148 COLORREF oldColor;
1149
1150 oldColor = dc->w.textColor;
1151 dc->w.textColor = color;
1152
1153 physDev->textPixel = COLOR_ToPhysical( dc, color );
1154
1155 return oldColor;
1156 }
Maarten's multimedia branch