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