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