?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
comdlg32: Avoid a NULL dereference when changing the file type selection of a Unicode...
[wine.git] / dlls / winex11.drv / graphics.c
blob4c2d2668df772ab8ff0ba8c21a183bc82b817a40
1 /*
2 * X11 graphics driver graphics functions
3 *
4 * Copyright 1993,1994 Alexandre Julliard
5 * Copyright 1998 Huw Davies
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 /*
23 * FIXME: only some of these functions obey the GM_ADVANCED
24 * graphics mode
25 */
26
27 #include "config.h"
28
29 #include <stdarg.h>
30 #include <math.h>
31 #ifdef HAVE_FLOAT_H
32 # include <float.h>
33 #endif
34 #include <stdlib.h>
35 #ifndef PI
36 #define PI M_PI
37 #endif
38 #include <string.h>
39 #include <limits.h>
40
41 #include "windef.h"
42 #include "winbase.h"
43 #include "winreg.h"
44
45 #include "x11drv.h"
46 #include "x11font.h"
47 #include "wine/debug.h"
48 #include "wine/unicode.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(graphics);
51
52 #define ABS(x) ((x)<0?(-(x)):(x))
53
54 /* ROP code to GC function conversion */
55 const int X11DRV_XROPfunction[16] =
56 {
57 GXclear, /* R2_BLACK */
58 GXnor, /* R2_NOTMERGEPEN */
59 GXandInverted, /* R2_MASKNOTPEN */
60 GXcopyInverted, /* R2_NOTCOPYPEN */
61 GXandReverse, /* R2_MASKPENNOT */
62 GXinvert, /* R2_NOT */
63 GXxor, /* R2_XORPEN */
64 GXnand, /* R2_NOTMASKPEN */
65 GXand, /* R2_MASKPEN */
66 GXequiv, /* R2_NOTXORPEN */
67 GXnoop, /* R2_NOP */
68 GXorInverted, /* R2_MERGENOTPEN */
69 GXcopy, /* R2_COPYPEN */
70 GXorReverse, /* R2_MERGEPENNOT */
71 GXor, /* R2_MERGEPEN */
72 GXset /* R2_WHITE */
73 };
74
75
76 /* get the rectangle in device coordinates, with optional mirroring */
77 static RECT get_device_rect( HDC hdc, int left, int top, int right, int bottom )
78 {
79 RECT rect;
80
81 rect.left = left;
82 rect.top = top;
83 rect.right = right;
84 rect.bottom = bottom;
85 LPtoDP( hdc, (POINT *)&rect, 2 );
86 if (GetLayout( hdc ) & LAYOUT_RTL)
87 {
88 int tmp = rect.left;
89 rect.left = rect.right + 1;
90 rect.right = tmp + 1;
91 }
92 if (rect.left > rect.right)
93 {
94 int tmp = rect.left;
95 rect.left = rect.right;
96 rect.right = tmp;
97 }
98 if (rect.top > rect.bottom)
99 {
100 int tmp = rect.top;
101 rect.top = rect.bottom;
102 rect.bottom = tmp;
103 }
104 return rect;
105 }
106
107 /***********************************************************************
108 * X11DRV_GetRegionData
109 *
110 * Calls GetRegionData on the given region and converts the rectangle
111 * array to XRectangle format. The returned buffer must be freed by
112 * caller using HeapFree(GetProcessHeap(),...).
113 * If hdc_lptodp is not 0, the rectangles are converted through LPtoDP.
114 */
115 RGNDATA *X11DRV_GetRegionData( HRGN hrgn, HDC hdc_lptodp )
116 {
117 RGNDATA *data;
118 DWORD size;
119 unsigned int i;
120 RECT *rect, tmp;
121 XRectangle *xrect;
122
123 if (!(size = GetRegionData( hrgn, 0, NULL ))) return NULL;
124 if (sizeof(XRectangle) > sizeof(RECT))
125 {
126 /* add extra size for XRectangle array */
127 int count = (size - sizeof(RGNDATAHEADER)) / sizeof(RECT);
128 size += count * (sizeof(XRectangle) - sizeof(RECT));
129 }
130 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return NULL;
131 if (!GetRegionData( hrgn, size, data ))
132 {
133 HeapFree( GetProcessHeap(), 0, data );
134 return NULL;
135 }
136
137 rect = (RECT *)data->Buffer;
138 xrect = (XRectangle *)data->Buffer;
139 if (hdc_lptodp) /* map to device coordinates */
140 {
141 LPtoDP( hdc_lptodp, (POINT *)rect, data->rdh.nCount * 2 );
142 for (i = 0; i < data->rdh.nCount; i++)
143 {
144 if (rect[i].right < rect[i].left)
145 {
146 INT tmp = rect[i].right;
147 rect[i].right = rect[i].left;
148 rect[i].left = tmp;
149 }
150 if (rect[i].bottom < rect[i].top)
151 {
152 INT tmp = rect[i].bottom;
153 rect[i].bottom = rect[i].top;
154 rect[i].top = tmp;
155 }
156 }
157 }
158
159 if (sizeof(XRectangle) > sizeof(RECT))
160 {
161 int j;
162 /* need to start from the end */
163 for (j = data->rdh.nCount-1; j >= 0; j--)
164 {
165 tmp = rect[j];
166 xrect[j].x = max( min( tmp.left, SHRT_MAX), SHRT_MIN);
167 xrect[j].y = max( min( tmp.top, SHRT_MAX), SHRT_MIN);
168 xrect[j].width = max( min( tmp.right - xrect[j].x, USHRT_MAX), 0);
169 xrect[j].height = max( min( tmp.bottom - xrect[j].y, USHRT_MAX), 0);
170 }
171 }
172 else
173 {
174 for (i = 0; i < data->rdh.nCount; i++)
175 {
176 tmp = rect[i];
177 xrect[i].x = max( min( tmp.left, SHRT_MAX), SHRT_MIN);
178 xrect[i].y = max( min( tmp.top, SHRT_MAX), SHRT_MIN);
179 xrect[i].width = max( min( tmp.right - xrect[i].x, USHRT_MAX), 0);
180 xrect[i].height = max( min( tmp.bottom - xrect[i].y, USHRT_MAX), 0);
181 }
182 }
183 return data;
184 }
185
186
187 /***********************************************************************
188 * X11DRV_SetDeviceClipping
189 */
190 void CDECL X11DRV_SetDeviceClipping( X11DRV_PDEVICE *physDev, HRGN vis_rgn, HRGN clip_rgn )
191 {
192 RGNDATA *data;
193
194 CombineRgn( physDev->region, vis_rgn, clip_rgn, clip_rgn ? RGN_AND : RGN_COPY );
195 if (!(data = X11DRV_GetRegionData( physDev->region, 0 ))) return;
196
197 wine_tsx11_lock();
198 XSetClipRectangles( gdi_display, physDev->gc, physDev->dc_rect.left, physDev->dc_rect.top,
199 (XRectangle *)data->Buffer, data->rdh.nCount, YXBanded );
200 wine_tsx11_unlock();
201
202 if (physDev->xrender) X11DRV_XRender_SetDeviceClipping(physDev, data);
203
204 HeapFree( GetProcessHeap(), 0, data );
205 }
206
207
208 /***********************************************************************
209 * X11DRV_SetupGCForPatBlt
210 *
211 * Setup the GC for a PatBlt operation using current brush.
212 * If fMapColors is TRUE, X pixels are mapped to Windows colors.
213 * Return FALSE if brush is BS_NULL, TRUE otherwise.
214 */
215 BOOL X11DRV_SetupGCForPatBlt( X11DRV_PDEVICE *physDev, GC gc, BOOL fMapColors )
216 {
217 XGCValues val;
218 unsigned long mask;
219 Pixmap pixmap = 0;
220 POINT pt;
221
222 if (physDev->brush.style == BS_NULL) return FALSE;
223 if (physDev->brush.pixel == -1)
224 {
225 /* Special case used for monochrome pattern brushes.
226 * We need to swap foreground and background because
227 * Windows does it the wrong way...
228 */
229 val.foreground = physDev->backgroundPixel;
230 val.background = physDev->textPixel;
231 }
232 else
233 {
234 val.foreground = physDev->brush.pixel;
235 val.background = physDev->backgroundPixel;
236 }
237 if (fMapColors && X11DRV_PALETTE_XPixelToPalette)
238 {
239 val.foreground = X11DRV_PALETTE_XPixelToPalette[val.foreground];
240 val.background = X11DRV_PALETTE_XPixelToPalette[val.background];
241 }
242
243 val.function = X11DRV_XROPfunction[GetROP2(physDev->hdc)-1];
244 /*
245 ** Let's replace GXinvert by GXxor with (black xor white)
246 ** This solves the selection color and leak problems in excel
247 ** FIXME : Let's do that only if we work with X-pixels, not with Win-pixels
248 */
249 if (val.function == GXinvert)
250 {
251 val.foreground = (WhitePixel( gdi_display, DefaultScreen(gdi_display) ) ^
252 BlackPixel( gdi_display, DefaultScreen(gdi_display) ));
253 val.function = GXxor;
254 }
255 val.fill_style = physDev->brush.fillStyle;
256 switch(val.fill_style)
257 {
258 case FillStippled:
259 case FillOpaqueStippled:
260 if (GetBkMode(physDev->hdc)==OPAQUE) val.fill_style = FillOpaqueStippled;
261 val.stipple = physDev->brush.pixmap;
262 mask = GCStipple;
263 break;
264
265 case FillTiled:
266 if (fMapColors && X11DRV_PALETTE_XPixelToPalette)
267 {
268 register int x, y;
269 XImage *image;
270 wine_tsx11_lock();
271 pixmap = XCreatePixmap( gdi_display, root_window, 8, 8, physDev->depth );
272 image = XGetImage( gdi_display, physDev->brush.pixmap, 0, 0, 8, 8,
273 AllPlanes, ZPixmap );
274 for (y = 0; y < 8; y++)
275 for (x = 0; x < 8; x++)
276 XPutPixel( image, x, y,
277 X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, x, y)] );
278 XPutImage( gdi_display, pixmap, gc, image, 0, 0, 0, 0, 8, 8 );
279 XDestroyImage( image );
280 wine_tsx11_unlock();
281 val.tile = pixmap;
282 }
283 else val.tile = physDev->brush.pixmap;
284 mask = GCTile;
285 break;
286
287 default:
288 mask = 0;
289 break;
290 }
291 GetBrushOrgEx( physDev->hdc, &pt );
292 val.ts_x_origin = physDev->dc_rect.left + pt.x;
293 val.ts_y_origin = physDev->dc_rect.top + pt.y;
294 val.fill_rule = (GetPolyFillMode(physDev->hdc) == WINDING) ? WindingRule : EvenOddRule;
295 wine_tsx11_lock();
296 XChangeGC( gdi_display, gc,
297 GCFunction | GCForeground | GCBackground | GCFillStyle |
298 GCFillRule | GCTileStipXOrigin | GCTileStipYOrigin | mask,
299 &val );
300 if (pixmap) XFreePixmap( gdi_display, pixmap );
301 wine_tsx11_unlock();
302 return TRUE;
303 }
304
305
306 /***********************************************************************
307 * X11DRV_SetupGCForBrush
308 *
309 * Setup physDev->gc for drawing operations using current brush.
310 * Return FALSE if brush is BS_NULL, TRUE otherwise.
311 */
312 BOOL X11DRV_SetupGCForBrush( X11DRV_PDEVICE *physDev )
313 {
314 return X11DRV_SetupGCForPatBlt( physDev, physDev->gc, FALSE );
315 }
316
317
318 /***********************************************************************
319 * X11DRV_SetupGCForPen
320 *
321 * Setup physDev->gc for drawing operations using current pen.
322 * Return FALSE if pen is PS_NULL, TRUE otherwise.
323 */
324 static BOOL X11DRV_SetupGCForPen( X11DRV_PDEVICE *physDev )
325 {
326 XGCValues val;
327 UINT rop2 = GetROP2(physDev->hdc);
328
329 if (physDev->pen.style == PS_NULL) return FALSE;
330
331 switch (rop2)
332 {
333 case R2_BLACK :
334 val.foreground = BlackPixel( gdi_display, DefaultScreen(gdi_display) );
335 val.function = GXcopy;
336 break;
337 case R2_WHITE :
338 val.foreground = WhitePixel( gdi_display, DefaultScreen(gdi_display) );
339 val.function = GXcopy;
340 break;
341 case R2_XORPEN :
342 val.foreground = physDev->pen.pixel;
343 /* It is very unlikely someone wants to XOR with 0 */
344 /* This fixes the rubber-drawings in paintbrush */
345 if (val.foreground == 0)
346 val.foreground = (WhitePixel( gdi_display, DefaultScreen(gdi_display) ) ^
347 BlackPixel( gdi_display, DefaultScreen(gdi_display) ));
348 val.function = GXxor;
349 break;
350 default :
351 val.foreground = physDev->pen.pixel;
352 val.function = X11DRV_XROPfunction[rop2-1];
353 }
354 val.background = physDev->backgroundPixel;
355 val.fill_style = FillSolid;
356 val.line_width = physDev->pen.width;
357 if (val.line_width <= 1) {
358 val.cap_style = CapNotLast;
359 } else {
360 switch (physDev->pen.endcap)
361 {
362 case PS_ENDCAP_SQUARE:
363 val.cap_style = CapProjecting;
364 break;
365 case PS_ENDCAP_FLAT:
366 val.cap_style = CapButt;
367 break;
368 case PS_ENDCAP_ROUND:
369 default:
370 val.cap_style = CapRound;
371 }
372 }
373 switch (physDev->pen.linejoin)
374 {
375 case PS_JOIN_BEVEL:
376 val.join_style = JoinBevel;
377 break;
378 case PS_JOIN_MITER:
379 val.join_style = JoinMiter;
380 break;
381 case PS_JOIN_ROUND:
382 default:
383 val.join_style = JoinRound;
384 }
385
386 if (physDev->pen.dash_len)
387 val.line_style = ((GetBkMode(physDev->hdc) == OPAQUE) && (!physDev->pen.ext))
388 ? LineDoubleDash : LineOnOffDash;
389 else
390 val.line_style = LineSolid;
391
392 wine_tsx11_lock();
393 if (physDev->pen.dash_len)
394 XSetDashes( gdi_display, physDev->gc, 0, physDev->pen.dashes, physDev->pen.dash_len );
395 XChangeGC( gdi_display, physDev->gc,
396 GCFunction | GCForeground | GCBackground | GCLineWidth |
397 GCLineStyle | GCCapStyle | GCJoinStyle | GCFillStyle, &val );
398 wine_tsx11_unlock();
399 return TRUE;
400 }
401
402
403 /***********************************************************************
404 * X11DRV_SetupGCForText
405 *
406 * Setup physDev->gc for text drawing operations.
407 * Return FALSE if the font is null, TRUE otherwise.
408 */
409 BOOL X11DRV_SetupGCForText( X11DRV_PDEVICE *physDev )
410 {
411 XFontStruct* xfs = XFONT_GetFontStruct( physDev->font );
412
413 if( xfs )
414 {
415 XGCValues val;
416
417 val.function = GXcopy; /* Text is always GXcopy */
418 val.foreground = physDev->textPixel;
419 val.background = physDev->backgroundPixel;
420 val.fill_style = FillSolid;
421 val.font = xfs->fid;
422
423 wine_tsx11_lock();
424 XChangeGC( gdi_display, physDev->gc,
425 GCFunction | GCForeground | GCBackground | GCFillStyle |
426 GCFont, &val );
427 wine_tsx11_unlock();
428 return TRUE;
429 }
430 WARN("Physical font failure\n" );
431 return FALSE;
432 }
433
434 /***********************************************************************
435 * X11DRV_XWStoDS
436 *
437 * Performs a world-to-viewport transformation on the specified width.
438 */
439 INT X11DRV_XWStoDS( X11DRV_PDEVICE *physDev, INT width )
440 {
441 POINT pt[2];
442
443 pt[0].x = 0;
444 pt[0].y = 0;
445 pt[1].x = width;
446 pt[1].y = 0;
447 LPtoDP( physDev->hdc, pt, 2 );
448 return pt[1].x - pt[0].x;
449 }
450
451 /***********************************************************************
452 * X11DRV_YWStoDS
453 *
454 * Performs a world-to-viewport transformation on the specified height.
455 */
456 INT X11DRV_YWStoDS( X11DRV_PDEVICE *physDev, INT height )
457 {
458 POINT pt[2];
459
460 pt[0].x = 0;
461 pt[0].y = 0;
462 pt[1].x = 0;
463 pt[1].y = height;
464 LPtoDP( physDev->hdc, pt, 2 );
465 return pt[1].y - pt[0].y;
466 }
467
468 /***********************************************************************
469 * X11DRV_LineTo
470 */
471 BOOL CDECL
472 X11DRV_LineTo( X11DRV_PDEVICE *physDev, INT x, INT y )
473 {
474 POINT pt[2];
475
476 if (X11DRV_SetupGCForPen( physDev )) {
477 /* Update the pixmap from the DIB section */
478 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
479
480 GetCurrentPositionEx( physDev->hdc, &pt[0] );
481 pt[1].x = x;
482 pt[1].y = y;
483 LPtoDP( physDev->hdc, pt, 2 );
484
485 wine_tsx11_lock();
486 XDrawLine(gdi_display, physDev->drawable, physDev->gc,
487 physDev->dc_rect.left + pt[0].x, physDev->dc_rect.top + pt[0].y,
488 physDev->dc_rect.left + pt[1].x, physDev->dc_rect.top + pt[1].y );
489 wine_tsx11_unlock();
490
491 /* Update the DIBSection from the pixmap */
492 X11DRV_UnlockDIBSection(physDev, TRUE);
493 }
494 return TRUE;
495 }
496
497
498
499 /***********************************************************************
500 * X11DRV_DrawArc
501 *
502 * Helper functions for Arc(), Chord() and Pie().
503 * 'lines' is the number of lines to draw: 0 for Arc, 1 for Chord, 2 for Pie.
504 *
505 */
506 static BOOL
507 X11DRV_DrawArc( X11DRV_PDEVICE *physDev, INT left, INT top, INT right,
508 INT bottom, INT xstart, INT ystart,
509 INT xend, INT yend, INT lines )
510 {
511 INT xcenter, ycenter, istart_angle, idiff_angle;
512 INT width, oldwidth;
513 double start_angle, end_angle;
514 XPoint points[4];
515 BOOL update = FALSE;
516 POINT start, end;
517 RECT rc = get_device_rect( physDev->hdc, left, top, right, bottom );
518
519 start.x = xstart;
520 start.y = ystart;
521 end.x = xend;
522 end.y = yend;
523 LPtoDP(physDev->hdc, &start, 1);
524 LPtoDP(physDev->hdc, &end, 1);
525
526 if ((rc.left == rc.right) || (rc.top == rc.bottom)
527 ||(lines && ((rc.right-rc.left==1)||(rc.bottom-rc.top==1)))) return TRUE;
528
529 if (GetArcDirection( physDev->hdc ) == AD_CLOCKWISE)
530 { POINT tmp = start; start = end; end = tmp; }
531
532 oldwidth = width = physDev->pen.width;
533 if (!width) width = 1;
534 if(physDev->pen.style == PS_NULL) width = 0;
535
536 if ((physDev->pen.style == PS_INSIDEFRAME))
537 {
538 if (2*width > (rc.right-rc.left)) width=(rc.right-rc.left + 1)/2;
539 if (2*width > (rc.bottom-rc.top)) width=(rc.bottom-rc.top + 1)/2;
540 rc.left += width / 2;
541 rc.right -= (width - 1) / 2;
542 rc.top += width / 2;
543 rc.bottom -= (width - 1) / 2;
544 }
545 if(width == 0) width = 1; /* more accurate */
546 physDev->pen.width = width;
547
548 xcenter = (rc.right + rc.left) / 2;
549 ycenter = (rc.bottom + rc.top) / 2;
550 start_angle = atan2( (double)(ycenter-start.y)*(rc.right-rc.left),
551 (double)(start.x-xcenter)*(rc.bottom-rc.top) );
552 end_angle = atan2( (double)(ycenter-end.y)*(rc.right-rc.left),
553 (double)(end.x-xcenter)*(rc.bottom-rc.top) );
554 if ((start.x==end.x)&&(start.y==end.y))
555 { /* A lazy program delivers xstart=xend=ystart=yend=0) */
556 start_angle = 0;
557 end_angle = 2* PI;
558 }
559 else /* notorious cases */
560 if ((start_angle == PI)&&( end_angle <0))
561 start_angle = - PI;
562 else
563 if ((end_angle == PI)&&( start_angle <0))
564 end_angle = - PI;
565 istart_angle = (INT)(start_angle * 180 * 64 / PI + 0.5);
566 idiff_angle = (INT)((end_angle - start_angle) * 180 * 64 / PI + 0.5);
567 if (idiff_angle <= 0) idiff_angle += 360 * 64;
568
569 /* Update the pixmap from the DIB section */
570 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
571
572 /* Fill arc with brush if Chord() or Pie() */
573
574 if ((lines > 0) && X11DRV_SetupGCForBrush( physDev )) {
575 wine_tsx11_lock();
576 XSetArcMode( gdi_display, physDev->gc, (lines==1) ? ArcChord : ArcPieSlice);
577 XFillArc( gdi_display, physDev->drawable, physDev->gc,
578 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
579 rc.right-rc.left-1, rc.bottom-rc.top-1, istart_angle, idiff_angle );
580 wine_tsx11_unlock();
581 update = TRUE;
582 }
583
584 /* Draw arc and lines */
585
586 if (X11DRV_SetupGCForPen( physDev ))
587 {
588 wine_tsx11_lock();
589 XDrawArc( gdi_display, physDev->drawable, physDev->gc,
590 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
591 rc.right-rc.left-1, rc.bottom-rc.top-1, istart_angle, idiff_angle );
592 if (lines) {
593 /* use the truncated values */
594 start_angle=(double)istart_angle*PI/64./180.;
595 end_angle=(double)(istart_angle+idiff_angle)*PI/64./180.;
596 /* calculate the endpoints and round correctly */
597 points[0].x = (int) floor(physDev->dc_rect.left + (rc.right+rc.left)/2.0 +
598 cos(start_angle) * (rc.right-rc.left-width*2+2) / 2. + 0.5);
599 points[0].y = (int) floor(physDev->dc_rect.top + (rc.top+rc.bottom)/2.0 -
600 sin(start_angle) * (rc.bottom-rc.top-width*2+2) / 2. + 0.5);
601 points[1].x = (int) floor(physDev->dc_rect.left + (rc.right+rc.left)/2.0 +
602 cos(end_angle) * (rc.right-rc.left-width*2+2) / 2. + 0.5);
603 points[1].y = (int) floor(physDev->dc_rect.top + (rc.top+rc.bottom)/2.0 -
604 sin(end_angle) * (rc.bottom-rc.top-width*2+2) / 2. + 0.5);
605
606 /* OK, this stuff is optimized for Xfree86
607 * which is probably the server most used by
608 * wine users. Other X servers will not
609 * display correctly. (eXceed for instance)
610 * so if you feel you must make changes, make sure that
611 * you either use Xfree86 or separate your changes
612 * from these (compile switch or whatever)
613 */
614 if (lines == 2) {
615 INT dx1,dy1;
616 points[3] = points[1];
617 points[1].x = physDev->dc_rect.left + xcenter;
618 points[1].y = physDev->dc_rect.top + ycenter;
619 points[2] = points[1];
620 dx1=points[1].x-points[0].x;
621 dy1=points[1].y-points[0].y;
622 if(((rc.top-rc.bottom) | -2) == -2)
623 if(dy1>0) points[1].y--;
624 if(dx1<0) {
625 if (((-dx1)*64)<=ABS(dy1)*37) points[0].x--;
626 if(((-dx1*9))<(dy1*16)) points[0].y--;
627 if( dy1<0 && ((dx1*9)) < (dy1*16)) points[0].y--;
628 } else {
629 if(dy1 < 0) points[0].y--;
630 if(((rc.right-rc.left) | -2) == -2) points[1].x--;
631 }
632 dx1=points[3].x-points[2].x;
633 dy1=points[3].y-points[2].y;
634 if(((rc.top-rc.bottom) | -2 ) == -2)
635 if(dy1 < 0) points[2].y--;
636 if( dx1<0){
637 if( dy1>0) points[3].y--;
638 if(((rc.right-rc.left) | -2) == -2 ) points[2].x--;
639 }else {
640 points[3].y--;
641 if( dx1 * 64 < dy1 * -37 ) points[3].x--;
642 }
643 lines++;
644 }
645 XDrawLines( gdi_display, physDev->drawable, physDev->gc,
646 points, lines+1, CoordModeOrigin );
647 }
648 wine_tsx11_unlock();
649 update = TRUE;
650 }
651
652 /* Update the DIBSection of the pixmap */
653 X11DRV_UnlockDIBSection(physDev, update);
654
655 physDev->pen.width = oldwidth;
656 return TRUE;
657 }
658
659
660 /***********************************************************************
661 * X11DRV_Arc
662 */
663 BOOL CDECL
664 X11DRV_Arc( X11DRV_PDEVICE *physDev, INT left, INT top, INT right, INT bottom,
665 INT xstart, INT ystart, INT xend, INT yend )
666 {
667 return X11DRV_DrawArc( physDev, left, top, right, bottom,
668 xstart, ystart, xend, yend, 0 );
669 }
670
671
672 /***********************************************************************
673 * X11DRV_Pie
674 */
675 BOOL CDECL
676 X11DRV_Pie( X11DRV_PDEVICE *physDev, INT left, INT top, INT right, INT bottom,
677 INT xstart, INT ystart, INT xend, INT yend )
678 {
679 return X11DRV_DrawArc( physDev, left, top, right, bottom,
680 xstart, ystart, xend, yend, 2 );
681 }
682
683 /***********************************************************************
684 * X11DRV_Chord
685 */
686 BOOL CDECL
687 X11DRV_Chord( X11DRV_PDEVICE *physDev, INT left, INT top, INT right, INT bottom,
688 INT xstart, INT ystart, INT xend, INT yend )
689 {
690 return X11DRV_DrawArc( physDev, left, top, right, bottom,
691 xstart, ystart, xend, yend, 1 );
692 }
693
694
695 /***********************************************************************
696 * X11DRV_Ellipse
697 */
698 BOOL CDECL
699 X11DRV_Ellipse( X11DRV_PDEVICE *physDev, INT left, INT top, INT right, INT bottom )
700 {
701 INT width, oldwidth;
702 BOOL update = FALSE;
703 RECT rc = get_device_rect( physDev->hdc, left, top, right, bottom );
704
705 if ((rc.left == rc.right) || (rc.top == rc.bottom)) return TRUE;
706
707 oldwidth = width = physDev->pen.width;
708 if (!width) width = 1;
709 if(physDev->pen.style == PS_NULL) width = 0;
710
711 if ((physDev->pen.style == PS_INSIDEFRAME))
712 {
713 if (2*width > (rc.right-rc.left)) width=(rc.right-rc.left + 1)/2;
714 if (2*width > (rc.bottom-rc.top)) width=(rc.bottom-rc.top + 1)/2;
715 rc.left += width / 2;
716 rc.right -= (width - 1) / 2;
717 rc.top += width / 2;
718 rc.bottom -= (width - 1) / 2;
719 }
720 if(width == 0) width = 1; /* more accurate */
721 physDev->pen.width = width;
722
723 /* Update the pixmap from the DIB section */
724 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
725
726 if (X11DRV_SetupGCForBrush( physDev ))
727 {
728 wine_tsx11_lock();
729 XFillArc( gdi_display, physDev->drawable, physDev->gc,
730 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
731 rc.right-rc.left-1, rc.bottom-rc.top-1, 0, 360*64 );
732 wine_tsx11_unlock();
733 update = TRUE;
734 }
735 if (X11DRV_SetupGCForPen( physDev ))
736 {
737 wine_tsx11_lock();
738 XDrawArc( gdi_display, physDev->drawable, physDev->gc,
739 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
740 rc.right-rc.left-1, rc.bottom-rc.top-1, 0, 360*64 );
741 wine_tsx11_unlock();
742 update = TRUE;
743 }
744
745 /* Update the DIBSection from the pixmap */
746 X11DRV_UnlockDIBSection(physDev, update);
747
748 physDev->pen.width = oldwidth;
749 return TRUE;
750 }
751
752
753 /***********************************************************************
754 * X11DRV_Rectangle
755 */
756 BOOL CDECL
757 X11DRV_Rectangle(X11DRV_PDEVICE *physDev, INT left, INT top, INT right, INT bottom)
758 {
759 INT width, oldwidth, oldjoinstyle;
760 BOOL update = FALSE;
761 RECT rc = get_device_rect( physDev->hdc, left, top, right, bottom );
762
763 TRACE("(%d %d %d %d)\n", left, top, right, bottom);
764
765 if ((rc.left == rc.right) || (rc.top == rc.bottom)) return TRUE;
766
767 oldwidth = width = physDev->pen.width;
768 if (!width) width = 1;
769 if(physDev->pen.style == PS_NULL) width = 0;
770
771 if ((physDev->pen.style == PS_INSIDEFRAME))
772 {
773 if (2*width > (rc.right-rc.left)) width=(rc.right-rc.left + 1)/2;
774 if (2*width > (rc.bottom-rc.top)) width=(rc.bottom-rc.top + 1)/2;
775 rc.left += width / 2;
776 rc.right -= (width - 1) / 2;
777 rc.top += width / 2;
778 rc.bottom -= (width - 1) / 2;
779 }
780 if(width == 1) width = 0;
781 physDev->pen.width = width;
782 oldjoinstyle = physDev->pen.linejoin;
783 if(physDev->pen.type != PS_GEOMETRIC)
784 physDev->pen.linejoin = PS_JOIN_MITER;
785
786 /* Update the pixmap from the DIB section */
787 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
788
789 if ((rc.right > rc.left + width) && (rc.bottom > rc.top + width))
790 {
791 if (X11DRV_SetupGCForBrush( physDev ))
792 {
793 wine_tsx11_lock();
794 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
795 physDev->dc_rect.left + rc.left + (width + 1) / 2,
796 physDev->dc_rect.top + rc.top + (width + 1) / 2,
797 rc.right-rc.left-width-1, rc.bottom-rc.top-width-1);
798 wine_tsx11_unlock();
799 update = TRUE;
800 }
801 }
802 if (X11DRV_SetupGCForPen( physDev ))
803 {
804 wine_tsx11_lock();
805 XDrawRectangle( gdi_display, physDev->drawable, physDev->gc,
806 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
807 rc.right-rc.left-1, rc.bottom-rc.top-1 );
808 wine_tsx11_unlock();
809 update = TRUE;
810 }
811
812 /* Update the DIBSection from the pixmap */
813 X11DRV_UnlockDIBSection(physDev, update);
814
815 physDev->pen.width = oldwidth;
816 physDev->pen.linejoin = oldjoinstyle;
817 return TRUE;
818 }
819
820 /***********************************************************************
821 * X11DRV_RoundRect
822 */
823 BOOL CDECL
824 X11DRV_RoundRect( X11DRV_PDEVICE *physDev, INT left, INT top, INT right,
825 INT bottom, INT ell_width, INT ell_height )
826 {
827 INT width, oldwidth, oldendcap;
828 BOOL update = FALSE;
829 POINT pts[2];
830 RECT rc = get_device_rect( physDev->hdc, left, top, right, bottom );
831
832 TRACE("(%d %d %d %d %d %d\n",
833 left, top, right, bottom, ell_width, ell_height);
834
835 if ((rc.left == rc.right) || (rc.top == rc.bottom))
836 return TRUE;
837
838 /* Make sure ell_width and ell_height are >= 1 otherwise XDrawArc gets
839 called with width/height < 0 */
840 pts[0].x = pts[0].y = 0;
841 pts[1].x = ell_width;
842 pts[1].y = ell_height;
843 LPtoDP(physDev->hdc, pts, 2);
844 ell_width = max(abs( pts[1].x - pts[0].x ), 1);
845 ell_height = max(abs( pts[1].y - pts[0].y ), 1);
846
847 oldwidth = width = physDev->pen.width;
848 oldendcap = physDev->pen.endcap;
849 if (!width) width = 1;
850 if(physDev->pen.style == PS_NULL) width = 0;
851
852 if ((physDev->pen.style == PS_INSIDEFRAME))
853 {
854 if (2*width > (rc.right-rc.left)) width=(rc.right-rc.left + 1)/2;
855 if (2*width > (rc.bottom-rc.top)) width=(rc.bottom-rc.top + 1)/2;
856 rc.left += width / 2;
857 rc.right -= (width - 1) / 2;
858 rc.top += width / 2;
859 rc.bottom -= (width - 1) / 2;
860 }
861 if(width == 0) width = 1;
862 physDev->pen.width = width;
863 physDev->pen.endcap = PS_ENDCAP_SQUARE;
864
865 /* Update the pixmap from the DIB section */
866 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
867
868 if (X11DRV_SetupGCForBrush( physDev ))
869 {
870 wine_tsx11_lock();
871 if (ell_width > (rc.right-rc.left) )
872 if (ell_height > (rc.bottom-rc.top) )
873 XFillArc( gdi_display, physDev->drawable, physDev->gc,
874 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
875 rc.right - rc.left - 1, rc.bottom - rc.top - 1,
876 0, 360 * 64 );
877 else{
878 XFillArc( gdi_display, physDev->drawable, physDev->gc,
879 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
880 rc.right - rc.left - 1, ell_height, 0, 180 * 64 );
881 XFillArc( gdi_display, physDev->drawable, physDev->gc,
882 physDev->dc_rect.left + rc.left,
883 physDev->dc_rect.top + rc.bottom - ell_height - 1,
884 rc.right - rc.left - 1, ell_height, 180 * 64,
885 180 * 64 );
886 }
887 else if (ell_height > (rc.bottom-rc.top) ){
888 XFillArc( gdi_display, physDev->drawable, physDev->gc,
889 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
890 ell_width, rc.bottom - rc.top - 1, 90 * 64, 180 * 64 );
891 XFillArc( gdi_display, physDev->drawable, physDev->gc,
892 physDev->dc_rect.left + rc.right - ell_width - 1, physDev->dc_rect.top + rc.top,
893 ell_width, rc.bottom - rc.top - 1, 270 * 64, 180 * 64 );
894 }else{
895 XFillArc( gdi_display, physDev->drawable, physDev->gc,
896 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
897 ell_width, ell_height, 90 * 64, 90 * 64 );
898 XFillArc( gdi_display, physDev->drawable, physDev->gc,
899 physDev->dc_rect.left + rc.left,
900 physDev->dc_rect.top + rc.bottom - ell_height - 1,
901 ell_width, ell_height, 180 * 64, 90 * 64 );
902 XFillArc( gdi_display, physDev->drawable, physDev->gc,
903 physDev->dc_rect.left + rc.right - ell_width - 1,
904 physDev->dc_rect.top + rc.bottom - ell_height - 1,
905 ell_width, ell_height, 270 * 64, 90 * 64 );
906 XFillArc( gdi_display, physDev->drawable, physDev->gc,
907 physDev->dc_rect.left + rc.right - ell_width - 1,
908 physDev->dc_rect.top + rc.top,
909 ell_width, ell_height, 0, 90 * 64 );
910 }
911 if (ell_width < rc.right - rc.left)
912 {
913 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
914 physDev->dc_rect.left + rc.left + (ell_width + 1) / 2,
915 physDev->dc_rect.top + rc.top + 1,
916 rc.right - rc.left - ell_width - 1,
917 (ell_height + 1) / 2 - 1);
918 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
919 physDev->dc_rect.left + rc.left + (ell_width + 1) / 2,
920 physDev->dc_rect.top + rc.bottom - (ell_height) / 2 - 1,
921 rc.right - rc.left - ell_width - 1,
922 (ell_height) / 2 );
923 }
924 if (ell_height < rc.bottom - rc.top)
925 {
926 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
927 physDev->dc_rect.left + rc.left + 1,
928 physDev->dc_rect.top + rc.top + (ell_height + 1) / 2,
929 rc.right - rc.left - 2,
930 rc.bottom - rc.top - ell_height - 1);
931 }
932 wine_tsx11_unlock();
933 update = TRUE;
934 }
935 /* FIXME: this could be done with on X call
936 * more efficient and probably more correct
937 * on any X server: XDrawArcs will draw
938 * straight horizontal and vertical lines
939 * if width or height are zero.
940 *
941 * BTW this stuff is optimized for an Xfree86 server
942 * read the comments inside the X11DRV_DrawArc function
943 */
944 if (X11DRV_SetupGCForPen( physDev ))
945 {
946 wine_tsx11_lock();
947 if (ell_width > (rc.right-rc.left) )
948 if (ell_height > (rc.bottom-rc.top) )
949 XDrawArc( gdi_display, physDev->drawable, physDev->gc,
950 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
951 rc.right - rc.left - 1, rc.bottom - rc.top - 1, 0 , 360 * 64 );
952 else{
953 XDrawArc( gdi_display, physDev->drawable, physDev->gc,
954 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
955 rc.right - rc.left - 1, ell_height - 1, 0 , 180 * 64 );
956 XDrawArc( gdi_display, physDev->drawable, physDev->gc,
957 physDev->dc_rect.left + rc.left,
958 physDev->dc_rect.top + rc.bottom - ell_height,
959 rc.right - rc.left - 1, ell_height - 1, 180 * 64 , 180 * 64 );
960 }
961 else if (ell_height > (rc.bottom-rc.top) ){
962 XDrawArc( gdi_display, physDev->drawable, physDev->gc,
963 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
964 ell_width - 1 , rc.bottom - rc.top - 1, 90 * 64 , 180 * 64 );
965 XDrawArc( gdi_display, physDev->drawable, physDev->gc,
966 physDev->dc_rect.left + rc.right - ell_width,
967 physDev->dc_rect.top + rc.top,
968 ell_width - 1 , rc.bottom - rc.top - 1, 270 * 64 , 180 * 64 );
969 }else{
970 XDrawArc( gdi_display, physDev->drawable, physDev->gc,
971 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.top,
972 ell_width - 1, ell_height - 1, 90 * 64, 90 * 64 );
973 XDrawArc( gdi_display, physDev->drawable, physDev->gc,
974 physDev->dc_rect.left + rc.left, physDev->dc_rect.top + rc.bottom - ell_height,
975 ell_width - 1, ell_height - 1, 180 * 64, 90 * 64 );
976 XDrawArc( gdi_display, physDev->drawable, physDev->gc,
977 physDev->dc_rect.left + rc.right - ell_width,
978 physDev->dc_rect.top + rc.bottom - ell_height,
979 ell_width - 1, ell_height - 1, 270 * 64, 90 * 64 );
980 XDrawArc( gdi_display, physDev->drawable, physDev->gc,
981 physDev->dc_rect.left + rc.right - ell_width, physDev->dc_rect.top + rc.top,
982 ell_width - 1, ell_height - 1, 0, 90 * 64 );
983 }
984 if (ell_width < rc.right - rc.left)
985 {
986 XDrawLine( gdi_display, physDev->drawable, physDev->gc,
987 physDev->dc_rect.left + rc.left + ell_width / 2,
988 physDev->dc_rect.top + rc.top,
989 physDev->dc_rect.left + rc.right - (ell_width+1) / 2,
990 physDev->dc_rect.top + rc.top);
991 XDrawLine( gdi_display, physDev->drawable, physDev->gc,
992 physDev->dc_rect.left + rc.left + ell_width / 2 ,
993 physDev->dc_rect.top + rc.bottom - 1,
994 physDev->dc_rect.left + rc.right - (ell_width+1)/ 2,
995 physDev->dc_rect.top + rc.bottom - 1);
996 }
997 if (ell_height < rc.bottom - rc.top)
998 {
999 XDrawLine( gdi_display, physDev->drawable, physDev->gc,
1000 physDev->dc_rect.left + rc.right - 1,
1001 physDev->dc_rect.top + rc.top + ell_height / 2,
1002 physDev->dc_rect.left + rc.right - 1,
1003 physDev->dc_rect.top + rc.bottom - (ell_height+1) / 2);
1004 XDrawLine( gdi_display, physDev->drawable, physDev->gc,
1005 physDev->dc_rect.left + rc.left,
1006 physDev->dc_rect.top + rc.top + ell_height / 2,
1007 physDev->dc_rect.left + rc.left,
1008 physDev->dc_rect.top + rc.bottom - (ell_height+1) / 2);
1009 }
1010 wine_tsx11_unlock();
1011 update = TRUE;
1012 }
1013 /* Update the DIBSection from the pixmap */
1014 X11DRV_UnlockDIBSection(physDev, update);
1015
1016 physDev->pen.width = oldwidth;
1017 physDev->pen.endcap = oldendcap;
1018 return TRUE;
1019 }
1020
1021
1022 /***********************************************************************
1023 * X11DRV_SetPixel
1024 */
1025 COLORREF CDECL
1026 X11DRV_SetPixel( X11DRV_PDEVICE *physDev, INT x, INT y, COLORREF color )
1027 {
1028 unsigned long pixel;
1029 POINT pt;
1030
1031 pt.x = x;
1032 pt.y = y;
1033 LPtoDP( physDev->hdc, &pt, 1 );
1034 pixel = X11DRV_PALETTE_ToPhysical( physDev, color );
1035
1036 /* Update the pixmap from the DIB section */
1037 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
1038
1039 /* inefficient but simple... */
1040 wine_tsx11_lock();
1041 XSetForeground( gdi_display, physDev->gc, pixel );
1042 XSetFunction( gdi_display, physDev->gc, GXcopy );
1043 XDrawPoint( gdi_display, physDev->drawable, physDev->gc,
1044 physDev->dc_rect.left + pt.x, physDev->dc_rect.top + pt.y );
1045 wine_tsx11_unlock();
1046
1047 /* Update the DIBSection from the pixmap */
1048 X11DRV_UnlockDIBSection(physDev, TRUE);
1049
1050 return X11DRV_PALETTE_ToLogical(physDev, pixel);
1051 }
1052
1053
1054 /***********************************************************************
1055 * X11DRV_GetPixel
1056 */
1057 COLORREF CDECL
1058 X11DRV_GetPixel( X11DRV_PDEVICE *physDev, INT x, INT y )
1059 {
1060 static Pixmap pixmap = 0;
1061 XImage * image;
1062 int pixel;
1063 POINT pt;
1064 BOOL memdc = (GetObjectType(physDev->hdc) == OBJ_MEMDC);
1065
1066 pt.x = x;
1067 pt.y = y;
1068 LPtoDP( physDev->hdc, &pt, 1 );
1069
1070 /* Update the pixmap from the DIB section */
1071 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
1072
1073 wine_tsx11_lock();
1074 if (memdc)
1075 {
1076 image = XGetImage( gdi_display, physDev->drawable,
1077 physDev->dc_rect.left + pt.x, physDev->dc_rect.top + pt.y,
1078 1, 1, AllPlanes, ZPixmap );
1079 }
1080 else
1081 {
1082 /* If we are reading from the screen, use a temporary copy */
1083 /* to avoid a BadMatch error */
1084 if (!pixmap) pixmap = XCreatePixmap( gdi_display, root_window,
1085 1, 1, physDev->depth );
1086 XCopyArea( gdi_display, physDev->drawable, pixmap, get_bitmap_gc(physDev->depth),
1087 physDev->dc_rect.left + pt.x, physDev->dc_rect.top + pt.y, 1, 1, 0, 0 );
1088 image = XGetImage( gdi_display, pixmap, 0, 0, 1, 1, AllPlanes, ZPixmap );
1089 }
1090 pixel = XGetPixel( image, 0, 0 );
1091 XDestroyImage( image );
1092 wine_tsx11_unlock();
1093
1094 /* Update the DIBSection from the pixmap */
1095 X11DRV_UnlockDIBSection(physDev, FALSE);
1096 if( physDev->depth > 1)
1097 pixel = X11DRV_PALETTE_ToLogical(physDev, pixel);
1098 else
1099 /* monochrome bitmaps return black or white */
1100 if( pixel) pixel = 0xffffff;
1101 return pixel;
1102
1103 }
1104
1105
1106 /***********************************************************************
1107 * X11DRV_PaintRgn
1108 */
1109 BOOL CDECL
1110 X11DRV_PaintRgn( X11DRV_PDEVICE *physDev, HRGN hrgn )
1111 {
1112 if (X11DRV_SetupGCForBrush( physDev ))
1113 {
1114 unsigned int i;
1115 XRectangle *rect;
1116 RGNDATA *data = X11DRV_GetRegionData( hrgn, physDev->hdc );
1117
1118 if (!data) return FALSE;
1119 rect = (XRectangle *)data->Buffer;
1120 for (i = 0; i < data->rdh.nCount; i++)
1121 {
1122 rect[i].x += physDev->dc_rect.left;
1123 rect[i].y += physDev->dc_rect.top;
1124 }
1125
1126 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
1127 wine_tsx11_lock();
1128 XFillRectangles( gdi_display, physDev->drawable, physDev->gc, rect, data->rdh.nCount );
1129 wine_tsx11_unlock();
1130 X11DRV_UnlockDIBSection(physDev, TRUE);
1131 HeapFree( GetProcessHeap(), 0, data );
1132 }
1133 return TRUE;
1134 }
1135
1136 /**********************************************************************
1137 * X11DRV_Polyline
1138 */
1139 BOOL CDECL
1140 X11DRV_Polyline( X11DRV_PDEVICE *physDev, const POINT* pt, INT count )
1141 {
1142 int i;
1143 XPoint *points;
1144
1145 if (!(points = HeapAlloc( GetProcessHeap(), 0, sizeof(XPoint) * count )))
1146 {
1147 WARN("No memory to convert POINTs to XPoints!\n");
1148 return FALSE;
1149 }
1150 for (i = 0; i < count; i++)
1151 {
1152 POINT tmp = pt[i];
1153 LPtoDP(physDev->hdc, &tmp, 1);
1154 points[i].x = physDev->dc_rect.left + tmp.x;
1155 points[i].y = physDev->dc_rect.top + tmp.y;
1156 }
1157
1158 if (X11DRV_SetupGCForPen ( physDev ))
1159 {
1160 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
1161 wine_tsx11_lock();
1162 XDrawLines( gdi_display, physDev->drawable, physDev->gc,
1163 points, count, CoordModeOrigin );
1164 wine_tsx11_unlock();
1165 X11DRV_UnlockDIBSection(physDev, TRUE);
1166 }
1167
1168 HeapFree( GetProcessHeap(), 0, points );
1169 return TRUE;
1170 }
1171
1172
1173 /**********************************************************************
1174 * X11DRV_Polygon
1175 */
1176 BOOL CDECL
1177 X11DRV_Polygon( X11DRV_PDEVICE *physDev, const POINT* pt, INT count )
1178 {
1179 register int i;
1180 XPoint *points;
1181 BOOL update = FALSE;
1182
1183 if (!(points = HeapAlloc( GetProcessHeap(), 0, sizeof(XPoint) * (count+1) )))
1184 {
1185 WARN("No memory to convert POINTs to XPoints!\n");
1186 return FALSE;
1187 }
1188 for (i = 0; i < count; i++)
1189 {
1190 POINT tmp = pt[i];
1191 LPtoDP(physDev->hdc, &tmp, 1);
1192 points[i].x = physDev->dc_rect.left + tmp.x;
1193 points[i].y = physDev->dc_rect.top + tmp.y;
1194 }
1195 points[count] = points[0];
1196
1197 /* Update the pixmap from the DIB section */
1198 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
1199
1200 if (X11DRV_SetupGCForBrush( physDev ))
1201 {
1202 wine_tsx11_lock();
1203 XFillPolygon( gdi_display, physDev->drawable, physDev->gc,
1204 points, count+1, Complex, CoordModeOrigin);
1205 wine_tsx11_unlock();
1206 update = TRUE;
1207 }
1208 if (X11DRV_SetupGCForPen ( physDev ))
1209 {
1210 wine_tsx11_lock();
1211 XDrawLines( gdi_display, physDev->drawable, physDev->gc,
1212 points, count+1, CoordModeOrigin );
1213 wine_tsx11_unlock();
1214 update = TRUE;
1215 }
1216
1217 /* Update the DIBSection from the pixmap */
1218 X11DRV_UnlockDIBSection(physDev, update);
1219
1220 HeapFree( GetProcessHeap(), 0, points );
1221 return TRUE;
1222 }
1223
1224
1225 /**********************************************************************
1226 * X11DRV_PolyPolygon
1227 */
1228 BOOL CDECL
1229 X11DRV_PolyPolygon( X11DRV_PDEVICE *physDev, const POINT* pt, const INT* counts, UINT polygons)
1230 {
1231 HRGN hrgn;
1232
1233 /* FIXME: The points should be converted to device coords before */
1234 /* creating the region. */
1235
1236 hrgn = CreatePolyPolygonRgn( pt, counts, polygons, GetPolyFillMode( physDev->hdc ) );
1237 X11DRV_PaintRgn( physDev, hrgn );
1238 DeleteObject( hrgn );
1239
1240 /* Draw the outline of the polygons */
1241
1242 if (X11DRV_SetupGCForPen ( physDev ))
1243 {
1244 unsigned int i;
1245 int j, max = 0;
1246 XPoint *points;
1247
1248 /* Update the pixmap from the DIB section */
1249 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
1250
1251 for (i = 0; i < polygons; i++) if (counts[i] > max) max = counts[i];
1252 if (!(points = HeapAlloc( GetProcessHeap(), 0, sizeof(XPoint) * (max+1) )))
1253 {
1254 WARN("No memory to convert POINTs to XPoints!\n");
1255 return FALSE;
1256 }
1257 for (i = 0; i < polygons; i++)
1258 {
1259 for (j = 0; j < counts[i]; j++)
1260 {
1261 POINT tmp = *pt;
1262 LPtoDP(physDev->hdc, &tmp, 1);
1263 points[j].x = physDev->dc_rect.left + tmp.x;
1264 points[j].y = physDev->dc_rect.top + tmp.y;
1265 pt++;
1266 }
1267 points[j] = points[0];
1268 wine_tsx11_lock();
1269 XDrawLines( gdi_display, physDev->drawable, physDev->gc,
1270 points, j + 1, CoordModeOrigin );
1271 wine_tsx11_unlock();
1272 }
1273
1274 /* Update the DIBSection of the dc's bitmap */
1275 X11DRV_UnlockDIBSection(physDev, TRUE);
1276
1277 HeapFree( GetProcessHeap(), 0, points );
1278 }
1279 return TRUE;
1280 }
1281
1282
1283 /**********************************************************************
1284 * X11DRV_PolyPolyline
1285 */
1286 BOOL CDECL
1287 X11DRV_PolyPolyline( X11DRV_PDEVICE *physDev, const POINT* pt, const DWORD* counts, DWORD polylines )
1288 {
1289 if (X11DRV_SetupGCForPen ( physDev ))
1290 {
1291 unsigned int i, j, max = 0;
1292 XPoint *points;
1293
1294 /* Update the pixmap from the DIB section */
1295 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
1296
1297 for (i = 0; i < polylines; i++) if (counts[i] > max) max = counts[i];
1298 if (!(points = HeapAlloc( GetProcessHeap(), 0, sizeof(XPoint) * max )))
1299 {
1300 WARN("No memory to convert POINTs to XPoints!\n");
1301 return FALSE;
1302 }
1303 for (i = 0; i < polylines; i++)
1304 {
1305 for (j = 0; j < counts[i]; j++)
1306 {
1307 POINT tmp = *pt;
1308 LPtoDP(physDev->hdc, &tmp, 1);
1309 points[j].x = physDev->dc_rect.left + tmp.x;
1310 points[j].y = physDev->dc_rect.top + tmp.y;
1311 pt++;
1312 }
1313 wine_tsx11_lock();
1314 XDrawLines( gdi_display, physDev->drawable, physDev->gc,
1315 points, j, CoordModeOrigin );
1316 wine_tsx11_unlock();
1317 }
1318
1319 /* Update the DIBSection of the dc's bitmap */
1320 X11DRV_UnlockDIBSection(physDev, TRUE);
1321
1322 HeapFree( GetProcessHeap(), 0, points );
1323 }
1324 return TRUE;
1325 }
1326
1327
1328 /**********************************************************************
1329 * X11DRV_InternalFloodFill
1330 *
1331 * Internal helper function for flood fill.
1332 * (xorg,yorg) is the origin of the X image relative to the drawable.
1333 * (x,y) is relative to the origin of the X image.
1334 */
1335 static void X11DRV_InternalFloodFill(XImage *image, X11DRV_PDEVICE *physDev,
1336 int x, int y,
1337 int xOrg, int yOrg,
1338 unsigned long pixel, WORD fillType )
1339 {
1340 int left, right;
1341
1342 #define TO_FLOOD(x,y) ((fillType == FLOODFILLBORDER) ? \
1343 (XGetPixel(image,x,y) != pixel) : \
1344 (XGetPixel(image,x,y) == pixel))
1345
1346 if (!TO_FLOOD(x,y)) return;
1347
1348 /* Find left and right boundaries */
1349
1350 left = right = x;
1351 while ((left > 0) && TO_FLOOD( left-1, y )) left--;
1352 while ((right < image->width) && TO_FLOOD( right, y )) right++;
1353 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
1354 xOrg + left, yOrg + y, right-left, 1 );
1355
1356 /* Set the pixels of this line so we don't fill it again */
1357
1358 for (x = left; x < right; x++)
1359 {
1360 if (fillType == FLOODFILLBORDER) XPutPixel( image, x, y, pixel );
1361 else XPutPixel( image, x, y, ~pixel );
1362 }
1363
1364 /* Fill the line above */
1365
1366 if (--y >= 0)
1367 {
1368 x = left;
1369 while (x < right)
1370 {
1371 while ((x < right) && !TO_FLOOD(x,y)) x++;
1372 if (x >= right) break;
1373 while ((x < right) && TO_FLOOD(x,y)) x++;
1374 X11DRV_InternalFloodFill(image, physDev, x-1, y,
1375 xOrg, yOrg, pixel, fillType );
1376 }
1377 }
1378
1379 /* Fill the line below */
1380
1381 if ((y += 2) < image->height)
1382 {
1383 x = left;
1384 while (x < right)
1385 {
1386 while ((x < right) && !TO_FLOOD(x,y)) x++;
1387 if (x >= right) break;
1388 while ((x < right) && TO_FLOOD(x,y)) x++;
1389 X11DRV_InternalFloodFill(image, physDev, x-1, y,
1390 xOrg, yOrg, pixel, fillType );
1391 }
1392 }
1393 #undef TO_FLOOD
1394 }
1395
1396
1397 static int ExtFloodFillXGetImageErrorHandler( Display *dpy, XErrorEvent *event, void *arg )
1398 {
1399 return (event->request_code == X_GetImage && event->error_code == BadMatch);
1400 }
1401
1402 /**********************************************************************
1403 * X11DRV_ExtFloodFill
1404 */
1405 BOOL CDECL
1406 X11DRV_ExtFloodFill( X11DRV_PDEVICE *physDev, INT x, INT y, COLORREF color,
1407 UINT fillType )
1408 {
1409 XImage *image;
1410 RECT rect;
1411 POINT pt;
1412
1413 TRACE("X11DRV_ExtFloodFill %d,%d %06x %d\n", x, y, color, fillType );
1414
1415 pt.x = x;
1416 pt.y = y;
1417 LPtoDP( physDev->hdc, &pt, 1 );
1418 if (!PtInRegion( physDev->region, pt.x, pt.y )) return FALSE;
1419 GetRgnBox( physDev->region, &rect );
1420
1421 X11DRV_expect_error( gdi_display, ExtFloodFillXGetImageErrorHandler, NULL );
1422 image = XGetImage( gdi_display, physDev->drawable,
1423 physDev->dc_rect.left + rect.left, physDev->dc_rect.top + rect.top,
1424 rect.right - rect.left, rect.bottom - rect.top,
1425 AllPlanes, ZPixmap );
1426 if(X11DRV_check_error()) image = NULL;
1427 if (!image) return FALSE;
1428
1429 if (X11DRV_SetupGCForBrush( physDev ))
1430 {
1431 unsigned long pixel = X11DRV_PALETTE_ToPhysical( physDev, color );
1432
1433 /* Update the pixmap from the DIB section */
1434 X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
1435
1436 /* ROP mode is always GXcopy for flood-fill */
1437 wine_tsx11_lock();
1438 XSetFunction( gdi_display, physDev->gc, GXcopy );
1439 X11DRV_InternalFloodFill(image, physDev,
1440 pt.x - rect.left,
1441 pt.y - rect.top,
1442 physDev->dc_rect.left + rect.left,
1443 physDev->dc_rect.top + rect.top,
1444 pixel, fillType );
1445 wine_tsx11_unlock();
1446 /* Update the DIBSection of the dc's bitmap */
1447 X11DRV_UnlockDIBSection(physDev, TRUE);
1448 }
1449
1450 wine_tsx11_lock();
1451 XDestroyImage( image );
1452 wine_tsx11_unlock();
1453 return TRUE;
1454 }
1455
1456 /**********************************************************************
1457 * X11DRV_SetBkColor
1458 */
1459 COLORREF CDECL
1460 X11DRV_SetBkColor( X11DRV_PDEVICE *physDev, COLORREF color )
1461 {
1462 physDev->backgroundPixel = X11DRV_PALETTE_ToPhysical( physDev, color );
1463 return color;
1464 }
1465
1466 /**********************************************************************
1467 * X11DRV_SetTextColor
1468 */
1469 COLORREF CDECL
1470 X11DRV_SetTextColor( X11DRV_PDEVICE *physDev, COLORREF color )
1471 {
1472 physDev->textPixel = X11DRV_PALETTE_ToPhysical( physDev, color );
1473 return color;
1474 }
1475
1476
1477 static unsigned char *get_icm_profile( unsigned long *size )
1478 {
1479 Atom type;
1480 int format;
1481 unsigned long count, remaining;
1482 unsigned char *profile, *ret = NULL;
1483
1484 wine_tsx11_lock();
1485 XGetWindowProperty( gdi_display, DefaultRootWindow(gdi_display),
1486 x11drv_atom(_ICC_PROFILE), 0, ~0UL, False, AnyPropertyType,
1487 &type, &format, &count, &remaining, &profile );
1488 *size = get_property_size( format, count );
1489 if (format && count)
1490 {
1491 if ((ret = HeapAlloc( GetProcessHeap(), 0, *size ))) memcpy( ret, profile, *size );
1492 XFree( profile );
1493 }
1494 wine_tsx11_unlock();
1495 return ret;
1496 }
1497
1498 typedef struct
1499 {
1500 unsigned int unknown[6];
1501 unsigned int state[5];
1502 unsigned int count[2];
1503 unsigned char buffer[64];
1504 } sha_ctx;
1505
1506 extern void WINAPI A_SHAInit( sha_ctx * );
1507 extern void WINAPI A_SHAUpdate( sha_ctx *, const unsigned char *, unsigned int );
1508 extern void WINAPI A_SHAFinal( sha_ctx *, unsigned char * );
1509
1510 /***********************************************************************
1511 * GetICMProfile (X11DRV.@)
1512 */
1513 BOOL CDECL X11DRV_GetICMProfile( X11DRV_PDEVICE *physDev, LPDWORD size, LPWSTR filename )
1514 {
1515 static const WCHAR path[] =
1516 {'\\','s','p','o','o','l','\\','d','r','i','v','e','r','s',
1517 '\\','c','o','l','o','r','\\',0};
1518 static const WCHAR srgb[] =
1519 {'s','R','G','B',' ','C','o','l','o','r',' ','S','p','a','c','e',' ',
1520 'P','r','o','f','i','l','e','.','i','c','m',0};
1521 static const WCHAR mntr[] =
1522 {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
1523 'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t',
1524 'V','e','r','s','i','o','n','\\','I','C','M','\\','m','n','t','r',0};
1525
1526 HKEY hkey;
1527 DWORD required, len;
1528 WCHAR profile[MAX_PATH], fullname[2*MAX_PATH + sizeof(path)/sizeof(WCHAR)];
1529 unsigned char *buffer;
1530 unsigned long buflen;
1531
1532 if (!size) return FALSE;
1533
1534 GetSystemDirectoryW( fullname, MAX_PATH );
1535 strcatW( fullname, path );
1536
1537 len = sizeof(profile)/sizeof(WCHAR);
1538 if (!RegCreateKeyExW( HKEY_LOCAL_MACHINE, mntr, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL ) &&
1539 !RegEnumValueW( hkey, 0, profile, &len, NULL, NULL, NULL, NULL )) /* FIXME handle multiple values */
1540 {
1541 strcatW( fullname, profile );
1542 RegCloseKey( hkey );
1543 }
1544 else if ((buffer = get_icm_profile( &buflen )))
1545 {
1546 static const WCHAR fmt[] = {'%','0','2','x',0};
1547 static const WCHAR icm[] = {'.','i','c','m',0};
1548
1549 unsigned char sha1sum[20];
1550 unsigned int i;
1551 sha_ctx ctx;
1552 HANDLE file;
1553
1554 A_SHAInit( &ctx );
1555 A_SHAUpdate( &ctx, buffer, buflen );
1556 A_SHAFinal( &ctx, sha1sum );
1557
1558 for (i = 0; i < sizeof(sha1sum); i++) sprintfW( &profile[i * 2], fmt, sha1sum[i] );
1559 memcpy( &profile[i * 2], icm, sizeof(icm) );
1560
1561 strcatW( fullname, profile );
1562 file = CreateFileW( fullname, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0 );
1563 if (file != INVALID_HANDLE_VALUE)
1564 {
1565 DWORD written;
1566
1567 if (!WriteFile( file, buffer, buflen, &written, NULL ) || written != buflen)
1568 ERR( "Unable to write color profile\n" );
1569 CloseHandle( file );
1570 }
1571 HeapFree( GetProcessHeap(), 0, buffer );
1572 }
1573 else strcatW( fullname, srgb );
1574
1575 required = strlenW( fullname ) + 1;
1576 if (*size < required)
1577 {
1578 *size = required;
1579 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1580 return FALSE;
1581 }
1582 if (filename)
1583 {
1584 strcpyW( filename, fullname );
1585 if (GetFileAttributesW( filename ) == INVALID_FILE_ATTRIBUTES)
1586 WARN( "color profile not found\n" );
1587 }
1588 *size = required;
1589 return TRUE;
1590 }
Windows API implementation