?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Clip solid pen regions to the DIB rectangle to avoid overflows.
[wine.git] / dlls / gdi32 / dibdrv / objects.c
blobf9736f66a880ae0bae8ea437b3da1a8750af0cd2
1 /*
2 * DIB driver GDI objects.
3 *
4 * Copyright 2011 Huw Davies
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <assert.h>
22 #include <stdlib.h>
23
24 #include "gdi_private.h"
25 #include "dibdrv.h"
26
27 #include "wine/debug.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(dib);
30
31 /*
32 *
33 * Decompose the 16 ROP2s into an expression of the form
34 *
35 * D = (D & A) ^ X
36 *
37 * Where A and X depend only on P (and so can be precomputed).
38 *
39 * A X
40 *
41 * R2_BLACK 0 0 0
42 * R2_NOTMERGEPEN ~(D | P) ~P ~P
43 * R2_MASKNOTPEN ~P & D ~P 0
44 * R2_NOTCOPYPEN ~P 0 ~P
45 * R2_MASKPENNOT P & ~D P P
46 * R2_NOT ~D 1 1
47 * R2_XORPEN P ^ D 1 P
48 * R2_NOTMASKPEN ~(P & D) P 1
49 * R2_MASKPEN P & D P 0
50 * R2_NOTXORPEN ~(P ^ D) 1 ~P
51 * R2_NOP D 1 0
52 * R2_MERGENOTPEN ~P | D P ~P
53 * R2_COPYPEN P 0 P
54 * R2_MERGEPENNOT P | ~D ~P 1
55 * R2_MERGEPEN P | D ~P P
56 * R2_WHITE 1 0 1
57 *
58 */
59
60 /* A = (P & A1) ^ A2 */
61 #define ZERO { 0u, 0u}
62 #define ONE { 0u, ~0u}
63 #define P {~0u, 0u}
64 #define NOT_P {~0u, ~0u}
65
66 static const DWORD rop2_and_array[16][2] =
67 {
68 ZERO, NOT_P, NOT_P, ZERO,
69 P, ONE, ONE, P,
70 P, ONE, ONE, P,
71 ZERO, NOT_P, NOT_P, ZERO
72 };
73
74 /* X = (P & X1) ^ X2 */
75 static const DWORD rop2_xor_array[16][2] =
76 {
77 ZERO, NOT_P, ZERO, NOT_P,
78 P, ONE, P, ONE,
79 ZERO, NOT_P, ZERO, NOT_P,
80 P, ONE, P, ONE
81 };
82
83 #undef NOT_P
84 #undef P
85 #undef ONE
86 #undef ZERO
87
88 void get_rop_codes(INT rop, struct rop_codes *codes)
89 {
90 /* NB The ROP2 codes start at one and the arrays are zero-based */
91 codes->a1 = rop2_and_array[rop-1][0];
92 codes->a2 = rop2_and_array[rop-1][1];
93 codes->x1 = rop2_xor_array[rop-1][0];
94 codes->x2 = rop2_xor_array[rop-1][1];
95 }
96
97 static inline void calc_and_xor_masks(INT rop, DWORD color, DWORD *and, DWORD *xor)
98 {
99 struct rop_codes codes;
100 get_rop_codes( rop, &codes );
101
102 *and = (color & codes.a1) ^ codes.a2;
103 *xor = (color & codes.x1) ^ codes.x2;
104 }
105
106 static inline void calc_rop_masks(INT rop, DWORD color, rop_mask *masks)
107 {
108 calc_and_xor_masks( rop, color, &masks->and, &masks->xor );
109 }
110
111 static inline RGBQUAD rgbquad_from_colorref(COLORREF c)
112 {
113 RGBQUAD ret;
114
115 ret.rgbRed = GetRValue(c);
116 ret.rgbGreen = GetGValue(c);
117 ret.rgbBlue = GetBValue(c);
118 ret.rgbReserved = 0;
119 return ret;
120 }
121
122 static inline BOOL rgbquad_equal(const RGBQUAD *a, const RGBQUAD *b)
123 {
124 if(a->rgbRed == b->rgbRed &&
125 a->rgbGreen == b->rgbGreen &&
126 a->rgbBlue == b->rgbBlue)
127 return TRUE;
128 return FALSE;
129 }
130
131 COLORREF make_rgb_colorref( HDC hdc, dib_info *dib, COLORREF color, BOOL *got_pixel, DWORD *pixel )
132 {
133 *pixel = 0;
134 *got_pixel = FALSE;
135
136 if (color & (1 << 24)) /* PALETTEINDEX */
137 {
138 HPALETTE pal = GetCurrentObject( hdc, OBJ_PAL );
139 PALETTEENTRY pal_ent;
140
141 if (!GetPaletteEntries( pal, LOWORD(color), 1, &pal_ent ))
142 GetPaletteEntries( pal, 0, 1, &pal_ent );
143 return RGB( pal_ent.peRed, pal_ent.peGreen, pal_ent.peBlue );
144 }
145
146 if (color >> 16 == 0x10ff) /* DIBINDEX */
147 {
148 const RGBQUAD *color_table = get_dib_color_table( dib );
149 WORD index = LOWORD( color );
150 *got_pixel = TRUE;
151 if (!color_table || index >= (1 << dib->bit_count)) return 0;
152 *pixel = index;
153 return RGB( color_table[index].rgbRed, color_table[index].rgbGreen, color_table[index].rgbBlue );
154 }
155
156 return color & 0xffffff;
157 }
158
159 /******************************************************************
160 * get_pixel_color
161 *
162 * 1 bit bitmaps map the fg/bg colors as follows:
163 * If the fg colorref exactly matches one of the color table entries then
164 * that entry is the fg color and the other is the bg.
165 * Otherwise the bg color is mapped to the closest entry in the table and
166 * the fg takes the other one.
167 */
168 DWORD get_pixel_color( dibdrv_physdev *pdev, COLORREF color, BOOL mono_fixup )
169 {
170 RGBQUAD fg_quad;
171 BOOL got_pixel;
172 DWORD pixel;
173 COLORREF rgb_ref;
174 const RGBQUAD *color_table;
175
176 rgb_ref = make_rgb_colorref( pdev->dev.hdc, &pdev->dib, color, &got_pixel, &pixel );
177 if (got_pixel) return pixel;
178
179 if (pdev->dib.bit_count != 1 || !mono_fixup)
180 return pdev->dib.funcs->colorref_to_pixel( &pdev->dib, rgb_ref );
181
182 color_table = get_dib_color_table( &pdev->dib );
183 fg_quad = rgbquad_from_colorref( rgb_ref );
184 if(rgbquad_equal(&fg_quad, color_table))
185 return 0;
186 if(rgbquad_equal(&fg_quad, color_table + 1))
187 return 1;
188
189 pixel = get_pixel_color( pdev, GetBkColor(pdev->dev.hdc), FALSE );
190 if (color == GetBkColor(pdev->dev.hdc)) return pixel;
191 else return !pixel;
192 }
193
194 /***************************************************************************
195 * get_color_masks
196 *
197 * Returns the color masks unless the dib is 1 bpp. In this case since
198 * there are several fg sources (pen, brush, text) we take as bg the inverse
199 * of the relevant fg color (which is always set up correctly).
200 */
201 static inline void get_color_masks( dibdrv_physdev *pdev, UINT rop, COLORREF colorref,
202 INT bkgnd_mode, rop_mask *fg_mask, rop_mask *bg_mask )
203 {
204 DWORD color = get_pixel_color( pdev, colorref, TRUE );
205
206 calc_rop_masks( rop, color, fg_mask );
207
208 if (bkgnd_mode == TRANSPARENT)
209 {
210 bg_mask->and = ~0u;
211 bg_mask->xor = 0;
212 return;
213 }
214
215 if (pdev->dib.bit_count != 1) color = get_pixel_color( pdev, GetBkColor(pdev->dev.hdc), FALSE );
216 else if (colorref != GetBkColor(pdev->dev.hdc)) color = !color;
217
218 calc_rop_masks( rop, color, bg_mask );
219 }
220
221 static inline void order_end_points(int *s, int *e)
222 {
223 if(*s > *e)
224 {
225 int tmp;
226 tmp = *s + 1;
227 *s = *e + 1;
228 *e = tmp;
229 }
230 }
231
232 #define Y_INCREASING_MASK 0x0f
233 #define X_INCREASING_MASK 0xc3
234 #define X_MAJOR_MASK 0x99
235 #define POS_SLOPE_MASK 0x33
236
237 static inline BOOL is_xmajor(DWORD octant)
238 {
239 return octant & X_MAJOR_MASK;
240 }
241
242 static inline BOOL is_pos_slope(DWORD octant)
243 {
244 return octant & POS_SLOPE_MASK;
245 }
246
247 static inline BOOL is_x_increasing(DWORD octant)
248 {
249 return octant & X_INCREASING_MASK;
250 }
251
252 static inline BOOL is_y_increasing(DWORD octant)
253 {
254 return octant & Y_INCREASING_MASK;
255 }
256
257 /**********************************************************************
258 * get_octant_number
259 *
260 * Return the octant number starting clockwise from the +ve x-axis.
261 */
262 static inline int get_octant_number(int dx, int dy)
263 {
264 if(dy > 0)
265 if(dx > 0)
266 return ( dx > dy) ? 1 : 2;
267 else
268 return (-dx > dy) ? 4 : 3;
269 else
270 if(dx < 0)
271 return (-dx > -dy) ? 5 : 6;
272 else
273 return ( dx > -dy) ? 8 : 7;
274 }
275
276 static inline DWORD get_octant_mask(int dx, int dy)
277 {
278 return 1 << (get_octant_number(dx, dy) - 1);
279 }
280
281 static inline int get_bias( DWORD mask )
282 {
283 /* Octants 3, 5, 6 and 8 take a bias */
284 return (mask & 0xb4) ? 1 : 0;
285 }
286
287 #define OUT_LEFT 1
288 #define OUT_RIGHT 2
289 #define OUT_TOP 4
290 #define OUT_BOTTOM 8
291
292 static inline DWORD calc_outcode(const POINT *pt, const RECT *clip)
293 {
294 DWORD out = 0;
295 if(pt->x < clip->left) out |= OUT_LEFT;
296 else if(pt->x >= clip->right) out |= OUT_RIGHT;
297 if(pt->y < clip->top) out |= OUT_TOP;
298 else if(pt->y >= clip->bottom) out |= OUT_BOTTOM;
299
300 return out;
301 }
302
303 /* crop coordinates to a reasonable range to avoid overflows in calculations */
304 static inline POINT crop_coords( POINT pt )
305 {
306 if (pt.x >= 0x10000000 || pt.x <= -0x10000000 || pt.y >= 0x10000000 || pt.y <= -0x10000000)
307 {
308 pt.x /= 8;
309 pt.y /= 8;
310 }
311 return pt;
312 }
313
314 static void init_bres_params( const POINT *start, const POINT *end, bres_params *clip_params,
315 struct line_params *line_params, RECT *rect )
316 {
317 INT dx = end->x - start->x, dy = end->y - start->y;
318 INT abs_dx = abs(dx), abs_dy = abs(dy);
319
320 clip_params->dx = abs_dx;
321 clip_params->dy = abs_dy;
322 clip_params->octant = get_octant_mask(dx, dy);
323 clip_params->bias = get_bias( clip_params->octant );
324
325 line_params->bias = clip_params->bias;
326 line_params->x_major = is_xmajor( clip_params->octant );
327 line_params->x_inc = is_x_increasing( clip_params->octant ) ? 1 : -1;
328 line_params->y_inc = is_y_increasing( clip_params->octant ) ? 1 : -1;
329
330 if (line_params->x_major)
331 {
332 line_params->err_add_1 = 2 * abs_dy - 2 * abs_dx;
333 line_params->err_add_2 = 2 * abs_dy;
334 }
335 else
336 {
337 line_params->err_add_1 = 2 * abs_dx - 2 * abs_dy;
338 line_params->err_add_2 = 2 * abs_dx;
339 }
340
341 rect->left = min( start->x, end->x );
342 rect->top = min( start->y, end->y );
343 rect->right = max( start->x, end->x ) + 1;
344 rect->bottom = max( start->y, end->y ) + 1;
345 }
346
347 /******************************************************************************
348 * clip_line
349 *
350 * Clips the start and end points to a rectangle.
351 *
352 * Note, this treats the end point like the start point. If the
353 * caller doesn't want it displayed, it should exclude it. If the end
354 * point is clipped out, then the likelihood is that the new end point
355 * should be displayed.
356 *
357 * Returns 0 if totally excluded, 1 if partially clipped and 2 if unclipped.
358 *
359 * This derivation is based on the comments in X.org's xserver/mi/mizerclip.c,
360 * however the Bresenham error term is defined differently so the equations
361 * will also differ.
362 *
363 * For x major lines we have 2dy >= err + bias > 2dy - 2dx
364 * 0 >= err + bias - 2dy > -2dx
365 *
366 * Note dx, dy, m and n are all +ve.
367 *
368 * Moving the start pt from x1 to x1 + m, we need to figure out y1 + n.
369 * err = 2dy - dx + 2mdy - 2ndx
370 * 0 >= 2dy - dx + 2mdy - 2ndx + bias - 2dy > -2dx
371 * 0 >= 2mdy - 2ndx + bias - dx > -2dx
372 * which of course will give exactly one solution for n,
373 * so looking at the >= inequality
374 * n >= (2mdy + bias - dx) / 2dx
375 * n = ceiling((2mdy + bias - dx) / 2dx)
376 * = (2mdy + bias + dx - 1) / 2dx (assuming division truncation)
377 *
378 * Moving start pt from y1 to y1 + n we need to figure out x1 + m - there may be several
379 * solutions we pick the one that minimizes m (ie that first unlipped pt). As above:
380 * 0 >= 2mdy - 2ndx + bias - dx > -2dx
381 * 2mdy > 2ndx - bias - dx
382 * m > (2ndx - bias - dx) / 2dy
383 * m = floor((2ndx - bias - dx) / 2dy) + 1
384 * m = (2ndx - bias - dx) / 2dy + 1
385 *
386 * Moving end pt from x2 to x2 - m, we need to figure out y2 - n
387 * err = 2dy - dx + 2(dx - m)dy - 2(dy - n)dx
388 * = 2dy - dx - 2mdy + 2ndx
389 * 0 >= 2dy - dx - 2mdy + 2ndx + bias - 2dy > -2dx
390 * 0 >= 2ndx - 2mdy + bias - dx > -2dx
391 * again exactly one solution.
392 * 2ndx <= 2mdy - bias + dx
393 * n = floor((2mdy - bias + dx) / 2dx)
394 * = (2mdy - bias + dx) / 2dx
395 *
396 * Moving end pt from y2 to y2 - n when need x2 - m this time maximizing x2 - m so
397 * mininizing m to include all of the points at y = y2 - n. As above:
398 * 0 >= 2ndx - 2mdy + bias - dx > -2dx
399 * 2mdy >= 2ndx + bias - dx
400 * m = ceiling((2ndx + bias - dx) / 2dy)
401 * = (2ndx + bias - dx - 1) / 2dy + 1
402 *
403 * For y major lines, symmetry (dx <-> dy and swap the cases over) gives:
404 *
405 * Moving start point from y1 to y1 + n find x1 + m
406 * m = (2ndx + bias + dy - 1) / 2dy
407 *
408 * Moving start point from x1 to x1 + m find y1 + n
409 * n = (2mdy - bias - dy) / 2ndx + 1
410 *
411 * Moving end point from y2 to y2 - n find x1 - m
412 * m = (2ndx - bias + dy) / 2dy
413 *
414 * Moving end point from x2 to x2 - m find y2 - n
415 * n = (2mdy + bias - dy - 1) / 2dx + 1
416 */
417 int clip_line(const POINT *start, const POINT *end, const RECT *clip,
418 const bres_params *params, POINT *pt1, POINT *pt2)
419 {
420
421 INT64 m, n; /* 64-bit to avoid overflows (FIXME: find a more efficient way) */
422 BOOL clipped = FALSE;
423 DWORD start_oc, end_oc;
424 const int bias = params->bias;
425 const unsigned int dx = params->dx;
426 const unsigned int dy = params->dy;
427 const unsigned int two_dx = params->dx * 2;
428 const unsigned int two_dy = params->dy * 2;
429 const BOOL xmajor = is_xmajor(params->octant);
430 const BOOL neg_slope = !is_pos_slope(params->octant);
431
432 *pt1 = *start;
433 *pt2 = *end;
434
435 start_oc = calc_outcode(start, clip);
436 end_oc = calc_outcode(end, clip);
437
438 while(1)
439 {
440 if(start_oc == 0 && end_oc == 0) return clipped ? 1 : 2; /* trivial accept */
441 if(start_oc & end_oc) return 0; /* trivial reject */
442
443 clipped = TRUE;
444 if(start_oc & OUT_LEFT)
445 {
446 m = clip->left - start->x;
447 if(xmajor)
448 n = (m * two_dy + bias + dx - 1) / two_dx;
449 else
450 n = (m * two_dy - bias - dy) / two_dx + 1;
451
452 pt1->x = clip->left;
453 if(neg_slope) n = -n;
454 pt1->y = start->y + n;
455 start_oc = calc_outcode(pt1, clip);
456 }
457 else if(start_oc & OUT_RIGHT)
458 {
459 m = start->x - clip->right + 1;
460 if(xmajor)
461 n = (m * two_dy + bias + dx - 1) / two_dx;
462 else
463 n = (m * two_dy - bias - dy) / two_dx + 1;
464
465 pt1->x = clip->right - 1;
466 if(neg_slope) n = -n;
467 pt1->y = start->y - n;
468 start_oc = calc_outcode(pt1, clip);
469 }
470 else if(start_oc & OUT_TOP)
471 {
472 n = clip->top - start->y;
473 if(xmajor)
474 m = (n * two_dx - bias - dx) / two_dy + 1;
475 else
476 m = (n * two_dx + bias + dy - 1) / two_dy;
477
478 pt1->y = clip->top;
479 if(neg_slope) m = -m;
480 pt1->x = start->x + m;
481 start_oc = calc_outcode(pt1, clip);
482 }
483 else if(start_oc & OUT_BOTTOM)
484 {
485 n = start->y - clip->bottom + 1;
486 if(xmajor)
487 m = (n * two_dx - bias - dx) / two_dy + 1;
488 else
489 m = (n * two_dx + bias + dy - 1) / two_dy;
490
491 pt1->y = clip->bottom - 1;
492 if(neg_slope) m = -m;
493 pt1->x = start->x - m;
494 start_oc = calc_outcode(pt1, clip);
495 }
496 else if(end_oc & OUT_LEFT)
497 {
498 m = clip->left - end->x;
499 if(xmajor)
500 n = (m * two_dy - bias + dx) / two_dx;
501 else
502 n = (m * two_dy + bias - dy - 1) / two_dx + 1;
503
504 pt2->x = clip->left;
505 if(neg_slope) n = -n;
506 pt2->y = end->y + n;
507 end_oc = calc_outcode(pt2, clip);
508 }
509 else if(end_oc & OUT_RIGHT)
510 {
511 m = end->x - clip->right + 1;
512 if(xmajor)
513 n = (m * two_dy - bias + dx) / two_dx;
514 else
515 n = (m * two_dy + bias - dy - 1) / two_dx + 1;
516
517 pt2->x = clip->right - 1;
518 if(neg_slope) n = -n;
519 pt2->y = end->y - n;
520 end_oc = calc_outcode(pt2, clip);
521 }
522 else if(end_oc & OUT_TOP)
523 {
524 n = clip->top - end->y;
525 if(xmajor)
526 m = (n * two_dx + bias - dx - 1) / two_dy + 1;
527 else
528 m = (n * two_dx - bias + dy) / two_dy;
529
530 pt2->y = clip->top;
531 if(neg_slope) m = -m;
532 pt2->x = end->x + m;
533 end_oc = calc_outcode(pt2, clip);
534 }
535 else if(end_oc & OUT_BOTTOM)
536 {
537 n = end->y - clip->bottom + 1;
538 if(xmajor)
539 m = (n * two_dx + bias - dx - 1) / two_dy + 1;
540 else
541 m = (n * two_dx - bias + dy) / two_dy;
542
543 pt2->y = clip->bottom - 1;
544 if(neg_slope) m = -m;
545 pt2->x = end->x - m;
546 end_oc = calc_outcode(pt2, clip);
547 }
548 }
549 }
550
551 static void bres_line_with_bias(const POINT *start, const struct line_params *params,
552 void (* callback)(dibdrv_physdev*,INT,INT), dibdrv_physdev *pdev)
553 {
554 POINT pt = *start;
555 int len = params->length, err = params->err_start;
556
557 if (params->x_major)
558 {
559 while(len--)
560 {
561 callback(pdev, pt.x, pt.y);
562 if (err + params->bias > 0)
563 {
564 pt.y += params->y_inc;
565 err += params->err_add_1;
566 }
567 else err += params->err_add_2;
568 pt.x += params->x_inc;
569 }
570 }
571 else
572 {
573 while(len--)
574 {
575 callback(pdev, pt.x, pt.y);
576 if (err + params->bias > 0)
577 {
578 pt.x += params->x_inc;
579 err += params->err_add_1;
580 }
581 else err += params->err_add_2;
582 pt.y += params->y_inc;
583 }
584 }
585 }
586
587 static BOOL solid_pen_line(dibdrv_physdev *pdev, POINT *start, POINT *end, DWORD and, DWORD xor)
588 {
589 struct clipped_rects clipped_rects;
590 RECT rect;
591 int i;
592
593 if(start->y == end->y)
594 {
595 rect.left = start->x;
596 rect.top = start->y;
597 rect.right = end->x;
598 rect.bottom = end->y + 1;
599 order_end_points(&rect.left, &rect.right);
600 if (!get_clipped_rects( &pdev->dib, &rect, pdev->clip, &clipped_rects )) return TRUE;
601 pdev->dib.funcs->solid_rects(&pdev->dib, clipped_rects.count, clipped_rects.rects, and, xor);
602 }
603 else if(start->x == end->x)
604 {
605 rect.left = start->x;
606 rect.top = start->y;
607 rect.right = end->x + 1;
608 rect.bottom = end->y;
609 order_end_points(&rect.top, &rect.bottom);
610 if (!get_clipped_rects( &pdev->dib, &rect, pdev->clip, &clipped_rects )) return TRUE;
611 pdev->dib.funcs->solid_rects(&pdev->dib, clipped_rects.count, clipped_rects.rects, and, xor);
612 }
613 else
614 {
615 bres_params clip_params;
616 struct line_params line_params;
617 POINT p1 = crop_coords( *start ), p2 = crop_coords( *end );
618
619 init_bres_params( start, end, &clip_params, &line_params, &rect );
620 if (!get_clipped_rects( &pdev->dib, &rect, pdev->clip, &clipped_rects )) return TRUE;
621 for (i = 0; i < clipped_rects.count; i++)
622 {
623 POINT clipped_start, clipped_end;
624 int clip_status;
625
626 clip_status = clip_line( &p1, &p2, clipped_rects.rects + i, &clip_params, &clipped_start, &clipped_end);
627 if(clip_status)
628 {
629 int m = abs(clipped_start.x - p1.x);
630 int n = abs(clipped_start.y - p1.y);
631
632 if (line_params.x_major)
633 {
634 line_params.err_start = 2 * clip_params.dy - clip_params.dx
635 + m * 2 * clip_params.dy - n * 2 * clip_params.dx;
636 line_params.length = abs( clipped_end.x - clipped_start.x ) + 1;
637 }
638 else
639 {
640 line_params.err_start = 2 * clip_params.dx - clip_params.dy
641 + n * 2 * clip_params.dx - m * 2 * clip_params.dy;
642 line_params.length = abs( clipped_end.y - clipped_start.y ) + 1;
643 }
644
645 if (clipped_end.x == p2.x && clipped_end.y == p2.y) line_params.length--;
646
647 pdev->dib.funcs->solid_line( &pdev->dib, &clipped_start, &line_params, and, xor );
648
649 if(clip_status == 2) break; /* completely unclipped, so we can finish */
650 }
651 }
652 }
653 free_clipped_rects( &clipped_rects );
654 return TRUE;
655 }
656
657 static void solid_line_region( const dib_info *dib, const POINT *start, const struct line_params *params,
658 HRGN region )
659 {
660 int len, err = params->err_start;
661 RECT rect;
662
663 rect.left = start->x;
664 rect.top = start->y;
665 rect.right = start->x + 1;
666 rect.bottom = start->y + 1;
667
668 if (params->x_major)
669 {
670 if (params->x_inc > 0)
671 {
672 for (len = params->length; len; len--, rect.right++)
673 {
674 if (err + params->bias > 0)
675 {
676 add_rect_to_region( region, &rect );
677 rect.left = rect.right;
678 rect.top += params->y_inc;
679 rect.bottom += params->y_inc;
680 err += params->err_add_1;
681 }
682 else err += params->err_add_2;
683 }
684 }
685 else
686 {
687 for (len = params->length; len; len--, rect.left--)
688 {
689 if (err + params->bias > 0)
690 {
691 add_rect_to_region( region, &rect );
692 rect.right = rect.left;
693 rect.top += params->y_inc;
694 rect.bottom += params->y_inc;
695 err += params->err_add_1;
696 }
697 else err += params->err_add_2;
698 }
699 }
700 }
701 else
702 {
703 if (params->y_inc > 0)
704 {
705 for (len = params->length; len; len--, rect.bottom++)
706 {
707 if (err + params->bias > 0)
708 {
709 add_rect_to_region( region, &rect );
710 rect.top = rect.bottom;
711 rect.left += params->x_inc;
712 rect.right += params->x_inc;
713 err += params->err_add_1;
714 }
715 else err += params->err_add_2;
716 }
717 }
718 else
719 {
720 for (len = params->length; len; len--, rect.top--)
721 {
722 if (err + params->bias > 0)
723 {
724 add_rect_to_region( region, &rect );
725 rect.bottom = rect.top;
726 rect.left += params->x_inc;
727 rect.right += params->x_inc;
728 err += params->err_add_1;
729 }
730 else err += params->err_add_2;
731 }
732 }
733 }
734 /* add final rect */
735 add_rect_to_region( region, &rect );
736 }
737
738 static BOOL solid_pen_line_region( dibdrv_physdev *pdev, POINT *start, POINT *end, HRGN region )
739 {
740 RECT rect;
741
742 rect.left = start->x;
743 rect.top = start->y;
744 rect.right = start->x + 1;
745 rect.bottom = start->y + 1;
746
747 if (start->y == end->y)
748 {
749 rect.right = end->x;
750 order_end_points(&rect.left, &rect.right);
751 if (clip_rect_to_dib( &pdev->dib, &rect )) add_rect_to_region( region, &rect );
752 }
753 else if(start->x == end->x)
754 {
755 rect.bottom = end->y;
756 order_end_points(&rect.top, &rect.bottom);
757 if (clip_rect_to_dib( &pdev->dib, &rect )) add_rect_to_region( region, &rect );
758 }
759 else
760 {
761 bres_params clip_params;
762 struct line_params line_params;
763 POINT p1 = crop_coords( *start ), p2 = crop_coords( *end );
764
765 init_bres_params( start, end, &clip_params, &line_params, &rect );
766 if (clip_rect_to_dib( &pdev->dib, &rect ))
767 {
768 POINT clipped_start, clipped_end;
769
770 if (clip_line( &p1, &p2, &rect, &clip_params, &clipped_start, &clipped_end ))
771 {
772 int m = abs(clipped_start.x - p1.x);
773 int n = abs(clipped_start.y - p1.y);
774
775 if (line_params.x_major)
776 {
777 line_params.err_start = 2 * clip_params.dy - clip_params.dx
778 + m * 2 * clip_params.dy - n * 2 * clip_params.dx;
779 line_params.length = abs( clipped_end.x - clipped_start.x ) + 1;
780 }
781 else
782 {
783 line_params.err_start = 2 * clip_params.dx - clip_params.dy
784 + n * 2 * clip_params.dx - m * 2 * clip_params.dy;
785 line_params.length = abs( clipped_end.y - clipped_start.y ) + 1;
786 }
787
788 if (clipped_end.x == p2.x && clipped_end.y == p2.y) line_params.length--;
789 solid_line_region( &pdev->dib, &clipped_start, &line_params, region );
790 }
791 }
792 }
793 return TRUE;
794 }
795
796 static BOOL solid_pen_lines(dibdrv_physdev *pdev, int num, POINT *pts, BOOL close, HRGN region)
797 {
798 int i;
799
800 assert( num >= 2 );
801
802 if (region)
803 {
804 for (i = 0; i < num - 1; i++)
805 if (!solid_pen_line_region( pdev, pts + i, pts + i + 1, region ))
806 return FALSE;
807 if (close) return solid_pen_line_region( pdev, pts + num - 1, pts, region );
808 }
809 else
810 {
811 DWORD color, and, xor;
812
813 color = get_pixel_color( pdev, pdev->pen_brush.colorref, TRUE );
814 calc_and_xor_masks( GetROP2(pdev->dev.hdc), color, &and, &xor );
815
816 for (i = 0; i < num - 1; i++)
817 if (!solid_pen_line( pdev, pts + i, pts + i + 1, and, xor ))
818 return FALSE;
819 if (close) return solid_pen_line( pdev, pts + num - 1, pts, and, xor );
820 }
821 return TRUE;
822 }
823
824 void reset_dash_origin(dibdrv_physdev *pdev)
825 {
826 pdev->dash_pos.cur_dash = 0;
827 pdev->dash_pos.left_in_dash = pdev->pen_pattern.dashes[0];
828 pdev->dash_pos.mark = TRUE;
829 }
830
831 static inline void skip_dash(dibdrv_physdev *pdev, unsigned int skip)
832 {
833 skip %= pdev->pen_pattern.total_len;
834 do
835 {
836 if(pdev->dash_pos.left_in_dash > skip)
837 {
838 pdev->dash_pos.left_in_dash -= skip;
839 return;
840 }
841 skip -= pdev->dash_pos.left_in_dash;
842 pdev->dash_pos.cur_dash++;
843 if(pdev->dash_pos.cur_dash == pdev->pen_pattern.count) pdev->dash_pos.cur_dash = 0;
844 pdev->dash_pos.left_in_dash = pdev->pen_pattern.dashes[pdev->dash_pos.cur_dash];
845 pdev->dash_pos.mark = !pdev->dash_pos.mark;
846 }
847 while (skip);
848 }
849
850 static void dashed_pen_line_callback(dibdrv_physdev *pdev, INT x, INT y)
851 {
852 RECT rect;
853 rop_mask mask = pdev->dash_masks[pdev->dash_pos.mark];
854
855 skip_dash(pdev, 1);
856 rect.left = x;
857 rect.right = x + 1;
858 rect.top = y;
859 rect.bottom = y + 1;
860 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, mask.and, mask.xor);
861 return;
862 }
863
864 static BOOL dashed_pen_line(dibdrv_physdev *pdev, POINT *start, POINT *end)
865 {
866 struct clipped_rects clipped_rects;
867 int i, dash_len;
868 RECT rect;
869 const dash_pos start_pos = pdev->dash_pos;
870
871 if(start->y == end->y) /* hline */
872 {
873 BOOL l_to_r;
874 INT left, right, cur_x;
875
876 rect.top = start->y;
877 rect.bottom = start->y + 1;
878
879 if(start->x <= end->x)
880 {
881 left = start->x;
882 right = end->x - 1;
883 l_to_r = TRUE;
884 }
885 else
886 {
887 left = end->x + 1;
888 right = start->x;
889 l_to_r = FALSE;
890 }
891
892 rect.left = min( start->x, end->x );
893 rect.right = max( start->x, end->x ) + 1;
894 get_clipped_rects( &pdev->dib, &rect, pdev->clip, &clipped_rects );
895 for (i = 0; i < clipped_rects.count; i++)
896 {
897 if(clipped_rects.rects[i].right > left && clipped_rects.rects[i].left <= right)
898 {
899 int clipped_left = max(clipped_rects.rects[i].left, left);
900 int clipped_right = min(clipped_rects.rects[i].right - 1, right);
901
902 pdev->dash_pos = start_pos;
903
904 if(l_to_r)
905 {
906 cur_x = clipped_left;
907 if(cur_x != left)
908 skip_dash(pdev, clipped_left - left);
909
910 while(cur_x <= clipped_right)
911 {
912 rop_mask mask = pdev->dash_masks[pdev->dash_pos.mark];
913 dash_len = pdev->dash_pos.left_in_dash;
914 if(cur_x + dash_len > clipped_right + 1)
915 dash_len = clipped_right - cur_x + 1;
916 rect.left = cur_x;
917 rect.right = cur_x + dash_len;
918
919 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, mask.and, mask.xor);
920 cur_x += dash_len;
921 skip_dash(pdev, dash_len);
922 }
923 }
924 else
925 {
926 cur_x = clipped_right;
927 if(cur_x != right)
928 skip_dash(pdev, right - clipped_right);
929
930 while(cur_x >= clipped_left)
931 {
932 rop_mask mask = pdev->dash_masks[pdev->dash_pos.mark];
933 dash_len = pdev->dash_pos.left_in_dash;
934 if(cur_x - dash_len < clipped_left - 1)
935 dash_len = cur_x - clipped_left + 1;
936 rect.left = cur_x - dash_len + 1;
937 rect.right = cur_x + 1;
938
939 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, mask.and, mask.xor);
940 cur_x -= dash_len;
941 skip_dash(pdev, dash_len);
942 }
943 }
944 }
945 }
946 pdev->dash_pos = start_pos;
947 skip_dash(pdev, right - left + 1);
948 }
949 else if(start->x == end->x) /* vline */
950 {
951 BOOL t_to_b;
952 INT top, bottom, cur_y;
953
954 rect.left = start->x;
955 rect.right = start->x + 1;
956
957 if(start->y <= end->y)
958 {
959 top = start->y;
960 bottom = end->y - 1;
961 t_to_b = TRUE;
962 }
963 else
964 {
965 top = end->y + 1;
966 bottom = start->y;
967 t_to_b = FALSE;
968 }
969
970 rect.top = min( start->y, end->y );
971 rect.bottom = max( start->y, end->y ) + 1;
972 get_clipped_rects( &pdev->dib, &rect, pdev->clip, &clipped_rects );
973 for (i = 0; i < clipped_rects.count; i++)
974 {
975 if(clipped_rects.rects[i].right > start->x && clipped_rects.rects[i].left <= start->x)
976 {
977 int clipped_top = max(clipped_rects.rects[i].top, top);
978 int clipped_bottom = min(clipped_rects.rects[i].bottom - 1, bottom);
979
980 pdev->dash_pos = start_pos;
981
982 if(t_to_b)
983 {
984 cur_y = clipped_top;
985 if(cur_y != top)
986 skip_dash(pdev, clipped_top - top);
987
988 while(cur_y <= clipped_bottom)
989 {
990 rop_mask mask = pdev->dash_masks[pdev->dash_pos.mark];
991 dash_len = pdev->dash_pos.left_in_dash;
992 if(cur_y + dash_len > clipped_bottom + 1)
993 dash_len = clipped_bottom - cur_y + 1;
994 rect.top = cur_y;
995 rect.bottom = cur_y + dash_len;
996
997 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, mask.and, mask.xor);
998 cur_y += dash_len;
999 skip_dash(pdev, dash_len);
1000 }
1001 }
1002 else
1003 {
1004 cur_y = clipped_bottom;
1005 if(cur_y != bottom)
1006 skip_dash(pdev, bottom - clipped_bottom);
1007
1008 while(cur_y >= clipped_top)
1009 {
1010 rop_mask mask = pdev->dash_masks[pdev->dash_pos.mark];
1011 dash_len = pdev->dash_pos.left_in_dash;
1012 if(cur_y - dash_len < clipped_top - 1)
1013 dash_len = cur_y - clipped_top + 1;
1014 rect.top = cur_y - dash_len + 1;
1015 rect.bottom = cur_y + 1;
1016
1017 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, mask.and, mask.xor);
1018 cur_y -= dash_len;
1019 skip_dash(pdev, dash_len);
1020 }
1021 }
1022 }
1023 }
1024 pdev->dash_pos = start_pos;
1025 skip_dash(pdev, bottom - top + 1);
1026 }
1027 else
1028 {
1029 bres_params clip_params;
1030 struct line_params line_params;
1031 POINT p1 = crop_coords( *start ), p2 = crop_coords( *end );
1032
1033 init_bres_params( start, end, &clip_params, &line_params, &rect );
1034 get_clipped_rects( &pdev->dib, &rect, pdev->clip, &clipped_rects );
1035 for (i = 0; i < clipped_rects.count; i++)
1036 {
1037 POINT clipped_start, clipped_end;
1038 int clip_status;
1039 clip_status = clip_line(&p1, &p2, clipped_rects.rects + i, &clip_params, &clipped_start, &clipped_end);
1040
1041 if(clip_status)
1042 {
1043 int m = abs(clipped_start.x - p1.x);
1044 int n = abs(clipped_start.y - p1.y);
1045
1046 pdev->dash_pos = start_pos;
1047
1048 if (line_params.x_major)
1049 {
1050 line_params.err_start = 2 * clip_params.dy - clip_params.dx
1051 + m * 2 * clip_params.dy - n * 2 * clip_params.dx;
1052 line_params.length = abs( clipped_end.x - clipped_start.x ) + 1;
1053 skip_dash(pdev, m);
1054 }
1055 else
1056 {
1057 line_params.err_start = 2 * clip_params.dx - clip_params.dy
1058 + n * 2 * clip_params.dx - m * 2 * clip_params.dy;
1059 line_params.length = abs( clipped_end.y - clipped_start.y ) + 1;
1060 skip_dash(pdev, n);
1061 }
1062 if (clipped_end.x == end->x && clipped_end.y == end->y) line_params.length--;
1063
1064 bres_line_with_bias( &clipped_start, &line_params, dashed_pen_line_callback, pdev );
1065
1066 if(clip_status == 2) break; /* completely unclipped, so we can finish */
1067 }
1068 }
1069 pdev->dash_pos = start_pos;
1070 if(line_params.x_major)
1071 skip_dash(pdev, clip_params.dx);
1072 else
1073 skip_dash(pdev, clip_params.dy);
1074 }
1075
1076 free_clipped_rects( &clipped_rects );
1077 return TRUE;
1078 }
1079
1080 static BOOL dashed_pen_line_region(dibdrv_physdev *pdev, POINT *start, POINT *end, HRGN region)
1081 {
1082 int i, dash_len;
1083 RECT rect;
1084
1085 rect.left = start->x;
1086 rect.top = start->y;
1087 rect.right = start->x + 1;
1088 rect.bottom = start->y + 1;
1089
1090 if (start->y == end->y) /* hline */
1091 {
1092 if (start->x <= end->x)
1093 {
1094 for (i = start->x; i < end->x; i += dash_len)
1095 {
1096 dash_len = min( pdev->dash_pos.left_in_dash, end->x - i );
1097 if (pdev->dash_pos.mark)
1098 {
1099 rect.left = i;
1100 rect.right = i + dash_len;
1101 add_rect_to_region( region, &rect );
1102 }
1103 skip_dash(pdev, dash_len);
1104 }
1105 }
1106 else
1107 {
1108 for (i = start->x; i > end->x; i -= dash_len)
1109 {
1110 dash_len = min( pdev->dash_pos.left_in_dash, i - end->x );
1111 if (pdev->dash_pos.mark)
1112 {
1113 rect.left = i - dash_len + 1;
1114 rect.right = i + 1;
1115 add_rect_to_region( region, &rect );
1116 }
1117 skip_dash(pdev, dash_len);
1118 }
1119 }
1120 }
1121 else if (start->x == end->x) /* vline */
1122 {
1123 if (start->y <= end->y)
1124 {
1125 for (i = start->y; i < end->y; i += dash_len)
1126 {
1127 dash_len = min( pdev->dash_pos.left_in_dash, end->y - i );
1128 if (pdev->dash_pos.mark)
1129 {
1130 rect.top = i;
1131 rect.bottom = i + dash_len;
1132 add_rect_to_region( region, &rect );
1133 }
1134 skip_dash(pdev, dash_len);
1135 }
1136 }
1137 else
1138 {
1139 for (i = start->y; i > end->y; i -= dash_len)
1140 {
1141 dash_len = min( pdev->dash_pos.left_in_dash, i - end->y );
1142 if (pdev->dash_pos.mark)
1143 {
1144 rect.top = i - dash_len + 1;
1145 rect.bottom = i + 1;
1146 add_rect_to_region( region, &rect );
1147 }
1148 skip_dash(pdev, dash_len);
1149 }
1150 }
1151 }
1152 else
1153 {
1154 INT dx = end->x - start->x, dy = end->y - start->y;
1155 INT abs_dx = abs(dx), abs_dy = abs(dy);
1156 DWORD octant = get_octant_mask(dx, dy);
1157 INT bias = get_bias( octant );
1158 int x_inc = is_x_increasing( octant ) ? 1 : -1;
1159 int y_inc = is_y_increasing( octant ) ? 1 : -1;
1160
1161 if (is_xmajor( octant ))
1162 {
1163 int err_add_1 = 2 * abs_dy - 2 * abs_dx;
1164 int err_add_2 = 2 * abs_dy;
1165 int err = 2 * abs_dy - abs_dx;
1166
1167 while (abs_dx--)
1168 {
1169 if (pdev->dash_pos.mark) add_rect_to_region( region, &rect );
1170 skip_dash(pdev, 1);
1171 rect.left += x_inc;
1172 rect.right += x_inc;
1173 if (err + bias > 0)
1174 {
1175 rect.top += y_inc;
1176 rect.bottom += y_inc;
1177 err += err_add_1;
1178 }
1179 else err += err_add_2;
1180 }
1181
1182 }
1183 else
1184 {
1185 int err_add_1 = 2 * abs_dx - 2 * abs_dy;
1186 int err_add_2 = 2 * abs_dx;
1187 int err = 2 * abs_dx - abs_dy;
1188
1189 while (abs_dy--)
1190 {
1191 if (pdev->dash_pos.mark) add_rect_to_region( region, &rect );
1192 skip_dash(pdev, 1);
1193 rect.top += y_inc;
1194 rect.bottom += y_inc;
1195 if (err + bias > 0)
1196 {
1197 rect.left += x_inc;
1198 rect.right += x_inc;
1199 err += err_add_1;
1200 }
1201 else err += err_add_2;
1202 }
1203 }
1204 }
1205 return TRUE;
1206 }
1207
1208 static BOOL dashed_pen_lines(dibdrv_physdev *pdev, int num, POINT *pts, BOOL close, HRGN region)
1209 {
1210 int i;
1211
1212 assert( num >= 2 );
1213
1214 if (region)
1215 {
1216 for (i = 0; i < num - 1; i++)
1217 if (!dashed_pen_line_region( pdev, pts + i, pts + i + 1, region ))
1218 return FALSE;
1219 if (close) return dashed_pen_line_region( pdev, pts + num - 1, pts, region );
1220 }
1221 else
1222 {
1223 get_color_masks( pdev, GetROP2(pdev->dev.hdc), pdev->pen_brush.colorref,
1224 pdev->pen_is_ext ? TRANSPARENT : GetBkMode(pdev->dev.hdc),
1225 &pdev->dash_masks[1], &pdev->dash_masks[0] );
1226
1227 for (i = 0; i < num - 1; i++)
1228 if (!dashed_pen_line( pdev, pts + i, pts + i + 1 ))
1229 return FALSE;
1230 if (close) return dashed_pen_line( pdev, pts + num - 1, pts );
1231 }
1232 return TRUE;
1233 }
1234
1235 static BOOL null_pen_lines(dibdrv_physdev *pdev, int num, POINT *pts, BOOL close, HRGN region)
1236 {
1237 return TRUE;
1238 }
1239
1240 struct face
1241 {
1242 POINT start, end;
1243 int dx, dy;
1244 };
1245
1246 static void add_cap( dibdrv_physdev *pdev, HRGN region, HRGN round_cap, const POINT *pt )
1247 {
1248 switch (pdev->pen_endcap)
1249 {
1250 default: FIXME( "Unknown end cap %x\n", pdev->pen_endcap );
1251 /* fall through */
1252 case PS_ENDCAP_ROUND:
1253 OffsetRgn( round_cap, pt->x, pt->y );
1254 CombineRgn( region, region, round_cap, RGN_OR );
1255 OffsetRgn( round_cap, -pt->x, -pt->y );
1256 return;
1257
1258 case PS_ENDCAP_SQUARE: /* already been handled */
1259 case PS_ENDCAP_FLAT:
1260 return;
1261 }
1262 }
1263
1264 #define round( f ) (((f) > 0) ? (f) + 0.5 : (f) - 0.5)
1265
1266 /*******************************************************************************
1267 * create_miter_region
1268 *
1269 * We need to calculate the intersection of two lines. We know a point
1270 * on each line (a face start and the other face end point) and
1271 * the direction vector of each line eg. (dx_1, dy_1).
1272 *
1273 * (x, y) = (x_1, y_1) + u * (dx_1, dy_1) = (x_2, y_2) + v * (dx_2, dy_2)
1274 * solving (eg using Cramer's rule) gives:
1275 * u = ((x_2 - x_1) dy_2 - (y_2 - y_1) dx_2) / det
1276 * with det = dx_1 dy_2 - dx_2 dy_1
1277 * substituting back in and simplifying gives
1278 * (x, y) = a (dx_1, dy_1) - b (dx_2, dy_2)
1279 * with a = (x_2 dy_2 - y_2 dx_2) / det
1280 * and b = (x_1 dy_1 - y_1 dx_1) / det
1281 */
1282 static HRGN create_miter_region( dibdrv_physdev *pdev, const POINT *pt,
1283 const struct face *face_1, const struct face *face_2 )
1284 {
1285 int det = face_1->dx * face_2->dy - face_1->dy * face_2->dx;
1286 POINT pt_1, pt_2, pts[5];
1287 double a, b, x, y;
1288 FLOAT limit;
1289
1290 if (det == 0) return 0;
1291
1292 if (det < 0)
1293 {
1294 const struct face *tmp = face_1;
1295 face_1 = face_2;
1296 face_2 = tmp;
1297 det = -det;
1298 }
1299
1300 pt_1 = face_1->start;
1301 pt_2 = face_2->end;
1302
1303 a = (double)((pt_2.x * face_2->dy - pt_2.y * face_2->dx)) / det;
1304 b = (double)((pt_1.x * face_1->dy - pt_1.y * face_1->dx)) / det;
1305
1306 x = a * face_1->dx - b * face_2->dx;
1307 y = a * face_1->dy - b * face_2->dy;
1308
1309 GetMiterLimit( pdev->dev.hdc, &limit );
1310
1311 if (((x - pt->x) * (x - pt->x) + (y - pt->y) * (y - pt->y)) * 4 > limit * limit * pdev->pen_width * pdev->pen_width)
1312 return 0;
1313
1314 pts[0] = face_2->start;
1315 pts[1] = face_1->start;
1316 pts[2].x = round( x );
1317 pts[2].y = round( y );
1318 pts[3] = face_2->end;
1319 pts[4] = face_1->end;
1320
1321 return CreatePolygonRgn( pts, 5, ALTERNATE );
1322 }
1323
1324 static void add_join( dibdrv_physdev *pdev, HRGN region, HRGN round_cap, const POINT *pt,
1325 const struct face *face_1, const struct face *face_2 )
1326 {
1327 HRGN join;
1328 POINT pts[4];
1329
1330 switch (pdev->pen_join)
1331 {
1332 default: FIXME( "Unknown line join %x\n", pdev->pen_join );
1333 /* fall through */
1334 case PS_JOIN_ROUND:
1335 OffsetRgn( round_cap, pt->x, pt->y );
1336 CombineRgn( region, region, round_cap, RGN_OR );
1337 OffsetRgn( round_cap, -pt->x, -pt->y );
1338 return;
1339
1340 case PS_JOIN_MITER:
1341 join = create_miter_region( pdev, pt, face_1, face_2 );
1342 if (join) break;
1343 /* fall through */
1344 case PS_JOIN_BEVEL:
1345 pts[0] = face_1->start;
1346 pts[1] = face_2->end;
1347 pts[2] = face_1->end;
1348 pts[3] = face_2->start;
1349 join = CreatePolygonRgn( pts, 4, ALTERNATE );
1350 break;
1351 }
1352
1353 CombineRgn( region, region, join, RGN_OR );
1354 DeleteObject( join );
1355 return;
1356 }
1357
1358 static int wide_line_segment( dibdrv_physdev *pdev, HRGN total,
1359 const POINT *pt_1, const POINT *pt_2, int dx, int dy,
1360 BOOL need_cap_1, BOOL need_cap_2, struct face *face_1, struct face *face_2 )
1361 {
1362 RECT rect;
1363 BOOL sq_cap_1 = need_cap_1 && (pdev->pen_endcap == PS_ENDCAP_SQUARE);
1364 BOOL sq_cap_2 = need_cap_2 && (pdev->pen_endcap == PS_ENDCAP_SQUARE);
1365
1366 if (dx == 0 && dy == 0) return 0;
1367
1368 if (dy == 0)
1369 {
1370 rect.left = min( pt_1->x, pt_2->x );
1371 rect.right = max( pt_1->x, pt_2->x );
1372 rect.top = pt_1->y - pdev->pen_width / 2;
1373 rect.bottom = rect.top + pdev->pen_width;
1374 if ((sq_cap_1 && dx > 0) || (sq_cap_2 && dx < 0)) rect.left -= pdev->pen_width / 2;
1375 if ((sq_cap_2 && dx > 0) || (sq_cap_1 && dx < 0)) rect.right += pdev->pen_width / 2;
1376 add_rect_to_region( total, &rect );
1377 if (dx > 0)
1378 {
1379 face_1->start.x = face_1->end.x = rect.left;
1380 face_1->start.y = face_2->end.y = rect.bottom;
1381 face_1->end.y = face_2->start.y = rect.top;
1382 face_2->start.x = face_2->end.x = rect.right - 1;
1383 }
1384 else
1385 {
1386 face_1->start.x = face_1->end.x = rect.right;
1387 face_1->start.y = face_2->end.y = rect.top;
1388 face_1->end.y = face_2->start.y = rect.bottom;
1389 face_2->start.x = face_2->end.x = rect.left + 1;
1390 }
1391 }
1392 else if (dx == 0)
1393 {
1394 rect.top = min( pt_1->y, pt_2->y );
1395 rect.bottom = max( pt_1->y, pt_2->y );
1396 rect.left = pt_1->x - pdev->pen_width / 2;
1397 rect.right = rect.left + pdev->pen_width;
1398 if ((sq_cap_1 && dy > 0) || (sq_cap_2 && dy < 0)) rect.top -= pdev->pen_width / 2;
1399 if ((sq_cap_2 && dy > 0) || (sq_cap_1 && dy < 0)) rect.bottom += pdev->pen_width / 2;
1400 add_rect_to_region( total, &rect );
1401 if (dy > 0)
1402 {
1403 face_1->start.x = face_2->end.x = rect.left;
1404 face_1->start.y = face_1->end.y = rect.top;
1405 face_1->end.x = face_2->start.x = rect.right;
1406 face_2->start.y = face_2->end.y = rect.bottom - 1;
1407 }
1408 else
1409 {
1410 face_1->start.x = face_2->end.x = rect.right;
1411 face_1->start.y = face_1->end.y = rect.bottom;
1412 face_1->end.x = face_2->start.x = rect.left;
1413 face_2->start.y = face_2->end.y = rect.top + 1;
1414 }
1415 }
1416 else
1417 {
1418 double len = hypot( dx, dy );
1419 double width_x, width_y;
1420 POINT seg_pts[4];
1421 POINT wide_half, narrow_half;
1422 HRGN segment;
1423
1424 width_x = pdev->pen_width * abs( dy ) / len;
1425 width_y = pdev->pen_width * abs( dx ) / len;
1426
1427 narrow_half.x = round( width_x / 2 );
1428 narrow_half.y = round( width_y / 2 );
1429 wide_half.x = round( (width_x + 1) / 2 );
1430 wide_half.y = round( (width_y + 1) / 2 );
1431
1432 if (dx < 0)
1433 {
1434 wide_half.y = -wide_half.y;
1435 narrow_half.y = -narrow_half.y;
1436 }
1437
1438 if (dy < 0)
1439 {
1440 POINT tmp = narrow_half; narrow_half = wide_half; wide_half = tmp;
1441 wide_half.x = -wide_half.x;
1442 narrow_half.x = -narrow_half.x;
1443 }
1444
1445 seg_pts[0].x = pt_1->x - narrow_half.x;
1446 seg_pts[0].y = pt_1->y + narrow_half.y;
1447 seg_pts[1].x = pt_1->x + wide_half.x;
1448 seg_pts[1].y = pt_1->y - wide_half.y;
1449 seg_pts[2].x = pt_2->x + wide_half.x;
1450 seg_pts[2].y = pt_2->y - wide_half.y;
1451 seg_pts[3].x = pt_2->x - narrow_half.x;
1452 seg_pts[3].y = pt_2->y + narrow_half.y;
1453
1454 if (sq_cap_1)
1455 {
1456 seg_pts[0].x -= narrow_half.y;
1457 seg_pts[1].x -= narrow_half.y;
1458 seg_pts[0].y -= narrow_half.x;
1459 seg_pts[1].y -= narrow_half.x;
1460 }
1461
1462 if (sq_cap_2)
1463 {
1464 seg_pts[2].x += wide_half.y;
1465 seg_pts[3].x += wide_half.y;
1466 seg_pts[2].y += wide_half.x;
1467 seg_pts[3].y += wide_half.x;
1468 }
1469
1470 segment = CreatePolygonRgn( seg_pts, 4, ALTERNATE );
1471 CombineRgn( total, total, segment, RGN_OR );
1472 DeleteObject( segment );
1473
1474 face_1->start = seg_pts[0];
1475 face_1->end = seg_pts[1];
1476 face_2->start = seg_pts[2];
1477 face_2->end = seg_pts[3];
1478 }
1479
1480 face_1->dx = face_2->dx = dx;
1481 face_1->dy = face_2->dy = dy;
1482
1483 return 1;
1484 }
1485
1486 static void wide_line_segments( dibdrv_physdev *pdev, int num, const POINT *pts, BOOL close,
1487 int start, int count, const POINT *first_pt, const POINT *last_pt,
1488 HRGN round_cap, HRGN total )
1489 {
1490 int i;
1491 struct face face_1, face_2, prev_face, first_face;
1492 const POINT *pt_1, *pt_2;
1493
1494 if (!close)
1495 {
1496 add_cap( pdev, total, round_cap, first_pt );
1497 add_cap( pdev, total, round_cap, last_pt );
1498 }
1499
1500 if (count == 1)
1501 {
1502 pt_1 = &pts[start];
1503 pt_2 = &pts[(start + 1) % num];
1504 wide_line_segment( pdev, total, first_pt, last_pt, pt_2->x - pt_1->x, pt_2->y - pt_1->y,
1505 TRUE, TRUE, &face_1, &face_2 );
1506 return;
1507 }
1508
1509 pt_1 = &pts[start];
1510 pt_2 = &pts[(start + 1) % num];
1511 wide_line_segment( pdev, total, first_pt, pt_2, pt_2->x - pt_1->x, pt_2->y - pt_1->y,
1512 !close, FALSE, &first_face, &prev_face );
1513
1514
1515 for (i = 1; i < count - 1; i++)
1516 {
1517 pt_1 = &pts[(start + i) % num];
1518 pt_2 = &pts[(start + i + 1) % num];
1519 if (wide_line_segment( pdev, total, pt_1, pt_2, pt_2->x - pt_1->x, pt_2->y - pt_1->y,
1520 FALSE, FALSE, &face_1, &face_2 ))
1521 {
1522 add_join( pdev, total, round_cap, pt_1, &prev_face, &face_1 );
1523 prev_face = face_2;
1524 }
1525 }
1526
1527 pt_1 = &pts[(start + count - 1) % num];
1528 pt_2 = &pts[(start + count) % num];
1529 wide_line_segment( pdev, total, pt_1, last_pt, pt_2->x - pt_1->x, pt_2->y - pt_1->y,
1530 FALSE, !close, &face_1, &face_2 );
1531 add_join( pdev, total, round_cap, pt_1, &prev_face, &face_1 );
1532 if (close) add_join( pdev, total, round_cap, last_pt, &face_2, &first_face );
1533 }
1534
1535 static BOOL wide_pen_lines(dibdrv_physdev *pdev, int num, POINT *pts, BOOL close, HRGN total)
1536 {
1537 HRGN round_cap = 0;
1538
1539 assert( total != 0 ); /* wide pens should always be drawn through a region */
1540 assert( num >= 2 );
1541
1542 /* skip empty segments */
1543 while (num > 2 && pts[0].x == pts[1].x && pts[0].y == pts[1].y) { pts++; num--; }
1544 while (num > 2 && pts[num - 1].x == pts[num - 2].x && pts[num - 1].y == pts[num - 2].y) num--;
1545
1546 if (pdev->pen_join == PS_JOIN_ROUND || pdev->pen_endcap == PS_ENDCAP_ROUND)
1547 round_cap = CreateEllipticRgn( -(pdev->pen_width / 2), -(pdev->pen_width / 2),
1548 (pdev->pen_width + 1) / 2 + 1, (pdev->pen_width + 1) / 2 + 1 );
1549
1550 if (close)
1551 wide_line_segments( pdev, num, pts, TRUE, 0, num, &pts[0], &pts[0], round_cap, total );
1552 else
1553 wide_line_segments( pdev, num, pts, FALSE, 0, num - 1, &pts[0], &pts[num - 1], round_cap, total );
1554
1555 if (round_cap) DeleteObject( round_cap );
1556 return TRUE;
1557 }
1558
1559 static BOOL dashed_wide_pen_lines(dibdrv_physdev *pdev, int num, POINT *pts, BOOL close, HRGN total)
1560 {
1561 int i, start, cur_len, initial_num = 0;
1562 POINT initial_point, start_point, end_point;
1563 HRGN round_cap = 0;
1564
1565 assert( total != 0 ); /* wide pens should always be drawn through a region */
1566 assert( num >= 2 );
1567
1568 /* skip empty segments */
1569 while (num > 2 && pts[0].x == pts[1].x && pts[0].y == pts[1].y) { pts++; num--; }
1570 while (num > 2 && pts[num - 1].x == pts[num - 2].x && pts[num - 1].y == pts[num - 2].y) num--;
1571
1572 if (pdev->pen_join == PS_JOIN_ROUND || pdev->pen_endcap == PS_ENDCAP_ROUND)
1573 round_cap = CreateEllipticRgn( -(pdev->pen_width / 2), -(pdev->pen_width / 2),
1574 (pdev->pen_width + 1) / 2 + 1, (pdev->pen_width + 1) / 2 + 1);
1575
1576 start = 0;
1577 cur_len = 0;
1578 start_point = pts[0];
1579
1580 for (i = 0; i < (close ? num : num - 1); i++)
1581 {
1582 const POINT *pt_1 = pts + i;
1583 const POINT *pt_2 = pts + ((close && i == num - 1) ? 0 : i + 1);
1584 int dx = pt_2->x - pt_1->x;
1585 int dy = pt_2->y - pt_1->y;
1586
1587 if (dx == 0 && dy == 0) continue;
1588
1589 if (dy == 0)
1590 {
1591 if (abs( dx ) - cur_len < pdev->dash_pos.left_in_dash)
1592 {
1593 skip_dash( pdev, abs( dx ) - cur_len );
1594 cur_len = 0;
1595 continue;
1596 }
1597 cur_len += pdev->dash_pos.left_in_dash;
1598 dx = (dx > 0) ? cur_len : -cur_len;
1599 }
1600 else if (dx == 0)
1601 {
1602 if (abs( dy ) - cur_len < pdev->dash_pos.left_in_dash)
1603 {
1604 skip_dash( pdev, abs( dy ) - cur_len );
1605 cur_len = 0;
1606 continue;
1607 }
1608 cur_len += pdev->dash_pos.left_in_dash;
1609 dy = (dy > 0) ? cur_len : -cur_len;
1610 }
1611 else
1612 {
1613 double len = hypot( dx, dy );
1614
1615 if (len - cur_len < pdev->dash_pos.left_in_dash)
1616 {
1617 skip_dash( pdev, len - cur_len );
1618 cur_len = 0;
1619 continue;
1620 }
1621 cur_len += pdev->dash_pos.left_in_dash;
1622 dx = dx * cur_len / len;
1623 dy = dy * cur_len / len;
1624 }
1625 end_point.x = pt_1->x + dx;
1626 end_point.y = pt_1->y + dy;
1627
1628 if (pdev->dash_pos.mark)
1629 {
1630 if (!initial_num && close) /* this is the first dash, save it for later */
1631 {
1632 initial_num = i - start + 1;
1633 initial_point = end_point;
1634 }
1635 else wide_line_segments( pdev, num, pts, FALSE, start, i - start + 1,
1636 &start_point, &end_point, round_cap, total );
1637 }
1638 if (!initial_num) initial_num = -1; /* no need to close it */
1639
1640 skip_dash( pdev, pdev->dash_pos.left_in_dash );
1641 start_point = end_point;
1642 start = i;
1643 i--; /* go on with the same segment */
1644 }
1645
1646 if (pdev->dash_pos.mark) /* we have a final dash */
1647 {
1648 int count;
1649
1650 if (initial_num > 0)
1651 {
1652 count = num - start + initial_num;
1653 end_point = initial_point;
1654 }
1655 else if (close)
1656 {
1657 count = num - start;
1658 end_point = pts[0];
1659 }
1660 else
1661 {
1662 count = num - start - 1;
1663 end_point = pts[num - 1];
1664 }
1665 wide_line_segments( pdev, num, pts, FALSE, start, count,
1666 &start_point, &end_point, round_cap, total );
1667 }
1668 else if (initial_num > 0) /* initial dash only */
1669 {
1670 wide_line_segments( pdev, num, pts, FALSE, 0, initial_num,
1671 &pts[0], &initial_point, round_cap, total );
1672 }
1673
1674 if (round_cap) DeleteObject( round_cap );
1675 return TRUE;
1676 }
1677
1678 static const dash_pattern dash_patterns_cosmetic[4] =
1679 {
1680 {2, {18, 6}, 24}, /* PS_DASH */
1681 {2, {3, 3}, 6}, /* PS_DOT */
1682 {4, {9, 6, 3, 6}, 24}, /* PS_DASHDOT */
1683 {6, {9, 3, 3, 3, 3, 3}, 24} /* PS_DASHDOTDOT */
1684 };
1685
1686 static const dash_pattern dash_patterns_geometric[4] =
1687 {
1688 {2, {3, 1}, 4}, /* PS_DASH */
1689 {2, {1, 1}, 2}, /* PS_DOT */
1690 {4, {3, 1, 1, 1}, 6}, /* PS_DASHDOT */
1691 {6, {3, 1, 1, 1, 1, 1}, 8} /* PS_DASHDOTDOT */
1692 };
1693
1694 static inline void set_dash_pattern( dash_pattern *pattern, DWORD count, DWORD *dashes )
1695 {
1696 DWORD i;
1697
1698 pattern->count = count;
1699 pattern->total_len = 0;
1700 memcpy( pattern->dashes, dashes, count * sizeof(DWORD) );
1701 for (i = 0; i < count; i++) pattern->total_len += dashes[i];
1702 if (pattern->count % 2) pattern->total_len *= 2;
1703 }
1704
1705 static inline void scale_dash_pattern( dash_pattern *pattern, DWORD scale, DWORD endcap )
1706 {
1707 DWORD i;
1708
1709 for (i = 0; i < pattern->count; i++) pattern->dashes[i] *= scale;
1710 pattern->total_len *= scale;
1711
1712 if (endcap != PS_ENDCAP_FLAT) /* shrink the dashes to leave room for the caps */
1713 {
1714 for (i = 0; i < pattern->count; i += 2)
1715 {
1716 pattern->dashes[i] -= scale;
1717 pattern->dashes[i + 1] += scale;
1718 }
1719 }
1720 }
1721
1722 static inline int get_pen_device_width( dibdrv_physdev *pdev, int width )
1723 {
1724 POINT pts[2];
1725
1726 if (!width) return 1;
1727 pts[0].x = pts[0].y = pts[1].y = 0;
1728 pts[1].x = width;
1729 LPtoDP( pdev->dev.hdc, pts, 2 );
1730 width = abs( pts[1].x - pts[0].x );
1731 return max( width, 1 );
1732 }
1733
1734 /***********************************************************************
1735 * dibdrv_SetDCPenColor
1736 */
1737 COLORREF dibdrv_SetDCPenColor( PHYSDEV dev, COLORREF color )
1738 {
1739 dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
1740
1741 if (GetCurrentObject(dev->hdc, OBJ_PEN) == GetStockObject( DC_PEN ))
1742 pdev->pen_brush.colorref = color;
1743
1744 return color;
1745 }
1746
1747 /**********************************************************************
1748 * solid_brush
1749 *
1750 * Fill a number of rectangles with the solid brush
1751 */
1752 static BOOL solid_brush(dibdrv_physdev *pdev, dib_brush *brush, dib_info *dib,
1753 int num, const RECT *rects, INT rop)
1754 {
1755 rop_mask brush_color;
1756 DWORD color = get_pixel_color( pdev, brush->colorref, TRUE );
1757
1758 calc_rop_masks( rop, color, &brush_color );
1759 dib->funcs->solid_rects( dib, num, rects, brush_color.and, brush_color.xor );
1760 return TRUE;
1761 }
1762
1763 static BOOL alloc_brush_mask_bits( dib_brush *brush )
1764 {
1765 DWORD size = brush->dib.height * abs(brush->dib.stride);
1766
1767 assert(brush->masks.and == NULL);
1768 assert(brush->masks.xor == NULL);
1769 assert(brush->dib.stride > 0);
1770
1771 if (!(brush->masks.and = HeapAlloc(GetProcessHeap(), 0, 2 * size))) return FALSE;
1772 brush->masks.xor = (char *)brush->masks.and + size;
1773 return TRUE;
1774 }
1775
1776 static void free_brush_mask_bits( dib_brush *brush )
1777 {
1778 HeapFree(GetProcessHeap(), 0, brush->masks.and);
1779 brush->masks.and = brush->masks.xor = NULL;
1780 }
1781
1782 void free_pattern_brush( dib_brush *brush )
1783 {
1784 free_brush_mask_bits( brush );
1785 free_dib_info( &brush->dib );
1786 }
1787
1788 static BOOL create_pattern_brush_bits( dib_brush *brush )
1789 {
1790 DWORD size = brush->dib.height * abs(brush->dib.stride);
1791 DWORD *brush_bits = brush->dib.bits.ptr;
1792 DWORD *and_bits, *xor_bits;
1793
1794 if (!alloc_brush_mask_bits( brush )) return FALSE;
1795
1796 and_bits = brush->masks.and;
1797 xor_bits = brush->masks.xor;
1798
1799 while(size)
1800 {
1801 calc_and_xor_masks(brush->rop, *brush_bits++, and_bits++, xor_bits++);
1802 size -= 4;
1803 }
1804
1805 return TRUE;
1806 }
1807
1808 static const BYTE hatches[6][8] =
1809 {
1810 { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00 }, /* HS_HORIZONTAL */
1811 { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 }, /* HS_VERTICAL */
1812 { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }, /* HS_FDIAGONAL */
1813 { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 }, /* HS_BDIAGONAL */
1814 { 0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08 }, /* HS_CROSS */
1815 { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 } /* HS_DIAGCROSS */
1816 };
1817
1818 static BOOL init_hatch_brush( dibdrv_physdev *pdev, dib_brush *brush )
1819 {
1820 /* Just initialise brush dib with the color / sizing info. We don't
1821 need the bits as we'll calculate the rop masks straight from
1822 the hatch patterns. */
1823
1824 copy_dib_color_info(&brush->dib, &pdev->dib);
1825 brush->dib.width = 8;
1826 brush->dib.height = 8;
1827 brush->dib.stride = get_dib_stride( brush->dib.width, brush->dib.bit_count );
1828 brush->dib.rect.left = 0;
1829 brush->dib.rect.top = 0;
1830 brush->dib.rect.right = 8;
1831 brush->dib.rect.bottom = 8;
1832 return alloc_brush_mask_bits( brush );
1833 }
1834
1835 static BOOL create_hatch_brush_bits(dibdrv_physdev *pdev, dib_brush *brush, BOOL *needs_reselect)
1836 {
1837 rop_mask fg_mask, bg_mask;
1838
1839 if (!init_hatch_brush( pdev, brush )) return FALSE;
1840
1841 get_color_masks( pdev, brush->rop, brush->colorref, GetBkMode(pdev->dev.hdc),
1842 &fg_mask, &bg_mask );
1843
1844 if (brush->colorref & (1 << 24)) /* PALETTEINDEX */
1845 *needs_reselect = TRUE;
1846 if (GetBkMode(pdev->dev.hdc) != TRANSPARENT && (GetBkColor(pdev->dev.hdc) & (1 << 24)))
1847 *needs_reselect = TRUE;
1848
1849 brush->dib.funcs->create_rop_masks( &brush->dib, hatches[brush->hatch],
1850 &fg_mask, &bg_mask, &brush->masks );
1851 return TRUE;
1852 }
1853
1854 static BOOL create_dither_brush_bits(dibdrv_physdev *pdev, dib_brush *brush, BOOL *needs_reselect)
1855 {
1856 COLORREF rgb;
1857 DWORD pixel;
1858 BOOL got_pixel;
1859
1860 if (!init_hatch_brush( pdev, brush )) return FALSE;
1861
1862 if (brush->colorref & (1 << 24)) /* PALETTEINDEX */
1863 *needs_reselect = TRUE;
1864
1865 rgb = make_rgb_colorref( pdev->dev.hdc, &pdev->dib, brush->colorref, &got_pixel, &pixel );
1866
1867 brush->dib.funcs->create_dither_masks( &brush->dib, brush->rop, rgb, &brush->masks );
1868 return TRUE;
1869 }
1870
1871 static BOOL matching_pattern_format( dib_info *dib, dib_info *pattern )
1872 {
1873 if (dib->bit_count != pattern->bit_count) return FALSE;
1874 if (dib->stride != pattern->stride) return FALSE;
1875
1876 switch (dib->bit_count)
1877 {
1878 case 1:
1879 case 4:
1880 case 8:
1881 if (dib->color_table_size != pattern->color_table_size) return FALSE;
1882 return !memcmp( dib->color_table, pattern->color_table, dib->color_table_size * sizeof(RGBQUAD) );
1883 case 16:
1884 case 32:
1885 return (dib->red_mask == pattern->red_mask &&
1886 dib->green_mask == pattern->green_mask &&
1887 dib->blue_mask == pattern->blue_mask);
1888 }
1889 return TRUE;
1890 }
1891
1892 static BOOL select_pattern_brush( dibdrv_physdev *pdev, dib_brush *brush, BOOL *needs_reselect )
1893 {
1894 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1895 BITMAPINFO *info = (BITMAPINFO *)buffer;
1896 RGBQUAD color_table[2];
1897 dib_info pattern;
1898 BOOL dither = (brush->dib.bit_count == 1);
1899
1900 if (pattern.bit_count == 1 && !pattern.color_table)
1901 dither = FALSE; /* monochrome DDB pattern brushes don't get dithered */
1902
1903 if (brush->pattern.info->bmiHeader.biClrUsed && brush->pattern.usage == DIB_PAL_COLORS)
1904 {
1905 copy_bitmapinfo( info, brush->pattern.info );
1906 fill_color_table_from_pal_colors( info, pdev->dev.hdc );
1907 init_dib_info_from_bitmapinfo( &pattern, info, brush->pattern.bits.ptr );
1908 *needs_reselect = TRUE;
1909 }
1910 else
1911 {
1912 init_dib_info_from_bitmapinfo( &pattern, brush->pattern.info, brush->pattern.bits.ptr );
1913 }
1914
1915 if (pattern.bit_count == 1 && !pattern.color_table &&
1916 (pdev->dib.bit_count != 1 || pdev->dib.color_table))
1917 {
1918 /* monochrome DDB pattern uses DC colors */
1919 DWORD pixel;
1920 BOOL got_pixel;
1921 COLORREF color;
1922
1923 color = make_rgb_colorref( pdev->dev.hdc, &pdev->dib, GetTextColor( pdev->dev.hdc ),
1924 &got_pixel, &pixel );
1925 color_table[0].rgbRed = GetRValue( color );
1926 color_table[0].rgbGreen = GetGValue( color );
1927 color_table[0].rgbBlue = GetBValue( color );
1928 color_table[0].rgbReserved = 0;
1929
1930 color = make_rgb_colorref( pdev->dev.hdc, &pdev->dib, GetBkColor( pdev->dev.hdc ),
1931 &got_pixel, &pixel );
1932 color_table[1].rgbRed = GetRValue( color );
1933 color_table[1].rgbGreen = GetGValue( color );
1934 color_table[1].rgbBlue = GetBValue( color );
1935 color_table[1].rgbReserved = 0;
1936
1937 pattern.color_table = color_table;
1938 pattern.color_table_size = 2;
1939 *needs_reselect = TRUE;
1940 }
1941
1942 copy_dib_color_info(&brush->dib, &pdev->dib);
1943
1944 brush->dib.height = pattern.height;
1945 brush->dib.width = pattern.width;
1946 brush->dib.stride = get_dib_stride( brush->dib.width, brush->dib.bit_count );
1947 brush->dib.rect = pattern.rect;
1948
1949 if (!dither && matching_pattern_format( &brush->dib, &pattern ))
1950 {
1951 brush->dib.bits.ptr = pattern.bits.ptr;
1952 brush->dib.bits.is_copy = FALSE;
1953 brush->dib.bits.free = NULL;
1954 }
1955 else
1956 {
1957 brush->dib.bits.ptr = HeapAlloc( GetProcessHeap(), 0, brush->dib.height * brush->dib.stride );
1958 brush->dib.bits.is_copy = TRUE;
1959 brush->dib.bits.free = free_heap_bits;
1960 brush->dib.funcs->convert_to(&brush->dib, &pattern, &pattern.rect, dither);
1961 }
1962 return TRUE;
1963 }
1964
1965 /**********************************************************************
1966 * pattern_brush
1967 *
1968 * Fill a number of rectangles with the pattern brush
1969 * FIXME: Should we insist l < r && t < b? Currently we assume this.
1970 */
1971 static BOOL pattern_brush(dibdrv_physdev *pdev, dib_brush *brush, dib_info *dib,
1972 int num, const RECT *rects, INT rop)
1973 {
1974 POINT origin;
1975 BOOL needs_reselect = FALSE;
1976
1977 if (rop != brush->rop)
1978 {
1979 free_brush_mask_bits( brush );
1980 brush->rop = rop;
1981 }
1982
1983 if(brush->masks.and == NULL)
1984 {
1985 switch(brush->style)
1986 {
1987 case BS_DIBPATTERN:
1988 if (!brush->dib.bits.ptr && !select_pattern_brush( pdev, brush, &needs_reselect ))
1989 return FALSE;
1990 if(!create_pattern_brush_bits( brush ))
1991 return FALSE;
1992 break;
1993
1994 case BS_SOLID:
1995 if(!create_dither_brush_bits(pdev, brush, &needs_reselect))
1996 return FALSE;
1997 break;
1998
1999 case BS_HATCHED:
2000 if(!create_hatch_brush_bits(pdev, brush, &needs_reselect))
2001 return FALSE;
2002 break;
2003
2004 default:
2005 ERR("Unexpected brush style %d\n", brush->style);
2006 return FALSE;
2007 }
2008 }
2009
2010 GetBrushOrgEx(pdev->dev.hdc, &origin);
2011
2012 dib->funcs->pattern_rects( dib, num, rects, &origin, &brush->dib, &brush->masks );
2013
2014 if (needs_reselect) free_pattern_brush( brush );
2015 return TRUE;
2016 }
2017
2018 static BOOL null_brush(dibdrv_physdev *pdev, dib_brush *brush, dib_info *dib,
2019 int num, const RECT *rects, INT rop)
2020 {
2021 return TRUE;
2022 }
2023
2024 static BOOL brush_needs_dithering( dibdrv_physdev *pdev, COLORREF color )
2025 {
2026 int i;
2027 RGBQUAD rgb;
2028 const RGBQUAD *color_table = get_default_color_table( pdev->dib.bit_count );
2029
2030 if (!color_table) return FALSE;
2031 if (pdev->dib.color_table) return FALSE;
2032 if (color & (1 << 24)) return TRUE; /* PALETTEINDEX */
2033 if (color >> 16 == 0x10ff) return FALSE; /* DIBINDEX */
2034
2035 rgb = rgbquad_from_colorref( color );
2036 for (i = 0; i < (1 << pdev->dib.bit_count); i++)
2037 if (rgbquad_equal( &color_table[i], &rgb )) return FALSE;
2038
2039 return TRUE;
2040 }
2041
2042 static void select_brush( dibdrv_physdev *pdev, dib_brush *brush,
2043 const LOGBRUSH *logbrush, const struct brush_pattern *pattern )
2044 {
2045 free_pattern_brush( brush );
2046
2047 if (pattern)
2048 {
2049 brush->style = BS_DIBPATTERN;
2050 brush->pattern = *pattern; /* brush is actually selected only when it's used */
2051 brush->rects = pattern_brush;
2052 }
2053 else
2054 {
2055 brush->style = logbrush->lbStyle;
2056 brush->colorref = logbrush->lbColor;
2057 brush->hatch = logbrush->lbHatch;
2058
2059 switch (logbrush->lbStyle)
2060 {
2061 case BS_NULL: brush->rects = null_brush; break;
2062 case BS_HATCHED: brush->rects = pattern_brush; break;
2063 case BS_SOLID:
2064 brush->rects = brush_needs_dithering( pdev, brush->colorref ) ? pattern_brush : solid_brush;
2065 break;
2066 }
2067 }
2068 }
2069
2070 /***********************************************************************
2071 * dibdrv_SelectBrush
2072 */
2073 HBRUSH dibdrv_SelectBrush( PHYSDEV dev, HBRUSH hbrush, const struct brush_pattern *pattern )
2074 {
2075 dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
2076 LOGBRUSH logbrush;
2077
2078 TRACE("(%p, %p)\n", dev, hbrush);
2079
2080 GetObjectW( hbrush, sizeof(logbrush), &logbrush );
2081
2082 if (hbrush == GetStockObject( DC_BRUSH ))
2083 logbrush.lbColor = GetDCBrushColor( dev->hdc );
2084
2085 select_brush( pdev, &pdev->brush, &logbrush, pattern );
2086 return hbrush;
2087 }
2088
2089 /***********************************************************************
2090 * dibdrv_SelectPen
2091 */
2092 HPEN dibdrv_SelectPen( PHYSDEV dev, HPEN hpen, const struct brush_pattern *pattern )
2093 {
2094 dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
2095 LOGPEN logpen;
2096 LOGBRUSH logbrush;
2097 EXTLOGPEN *elp = NULL;
2098
2099 TRACE("(%p, %p)\n", dev, hpen);
2100
2101 if (!GetObjectW( hpen, sizeof(logpen), &logpen ))
2102 {
2103 /* must be an extended pen */
2104 INT size = GetObjectW( hpen, 0, NULL );
2105
2106 if (!size) return 0;
2107
2108 elp = HeapAlloc( GetProcessHeap(), 0, size );
2109
2110 GetObjectW( hpen, size, elp );
2111 logpen.lopnStyle = elp->elpPenStyle;
2112 logpen.lopnWidth.x = elp->elpWidth;
2113 /* cosmetic ext pens are always 1-pixel wide */
2114 if (!(logpen.lopnStyle & PS_GEOMETRIC)) logpen.lopnWidth.x = 0;
2115
2116 logbrush.lbStyle = elp->elpBrushStyle;
2117 logbrush.lbColor = elp->elpColor;
2118 logbrush.lbHatch = elp->elpHatch;
2119 }
2120 else
2121 {
2122 logbrush.lbStyle = BS_SOLID;
2123 logbrush.lbColor = logpen.lopnColor;
2124 logbrush.lbHatch = 0;
2125 }
2126
2127 pdev->pen_join = logpen.lopnStyle & PS_JOIN_MASK;
2128 pdev->pen_endcap = logpen.lopnStyle & PS_ENDCAP_MASK;
2129 pdev->pen_width = get_pen_device_width( pdev, logpen.lopnWidth.x );
2130
2131 if (hpen == GetStockObject( DC_PEN ))
2132 logbrush.lbColor = GetDCPenColor( dev->hdc );
2133
2134 set_dash_pattern( &pdev->pen_pattern, 0, NULL );
2135 select_brush( pdev, &pdev->pen_brush, &logbrush, pattern );
2136
2137 pdev->pen_style = logpen.lopnStyle & PS_STYLE_MASK;
2138
2139 switch (pdev->pen_style)
2140 {
2141 case PS_DASH:
2142 case PS_DOT:
2143 case PS_DASHDOT:
2144 case PS_DASHDOTDOT:
2145 if (logpen.lopnStyle & PS_GEOMETRIC)
2146 {
2147 pdev->pen_pattern = dash_patterns_geometric[pdev->pen_style - 1];
2148 if (pdev->pen_width > 1)
2149 {
2150 scale_dash_pattern( &pdev->pen_pattern, pdev->pen_width, pdev->pen_endcap );
2151 pdev->pen_lines = dashed_wide_pen_lines;
2152 }
2153 else pdev->pen_lines = dashed_pen_lines;
2154 break;
2155 }
2156 if (pdev->pen_width == 1) /* wide cosmetic pens are not dashed */
2157 {
2158 pdev->pen_lines = dashed_pen_lines;
2159 pdev->pen_pattern = dash_patterns_cosmetic[pdev->pen_style - 1];
2160 break;
2161 }
2162 /* fall through */
2163 case PS_SOLID:
2164 case PS_INSIDEFRAME:
2165 pdev->pen_lines = (pdev->pen_width == 1) ? solid_pen_lines : wide_pen_lines;
2166 break;
2167
2168 case PS_NULL:
2169 pdev->pen_width = 0;
2170 pdev->pen_lines = null_pen_lines;
2171 break;
2172
2173 case PS_ALTERNATE:
2174 pdev->pen_lines = dashed_pen_lines;
2175 pdev->pen_pattern = dash_patterns_geometric[PS_DOT - 1];
2176 break;
2177
2178 case PS_USERSTYLE:
2179 pdev->pen_lines = (pdev->pen_width == 1) ? dashed_pen_lines : dashed_wide_pen_lines;
2180 set_dash_pattern( &pdev->pen_pattern, elp->elpNumEntries, elp->elpStyleEntry );
2181 if (!(logpen.lopnStyle & PS_GEOMETRIC)) scale_dash_pattern( &pdev->pen_pattern, 3, PS_ENDCAP_FLAT );
2182 break;
2183 }
2184
2185 pdev->pen_uses_region = (logpen.lopnStyle & PS_GEOMETRIC || pdev->pen_width > 1);
2186 pdev->pen_is_ext = (elp != NULL);
2187 HeapFree( GetProcessHeap(), 0, elp );
2188 return hpen;
2189 }
2190
2191 /***********************************************************************
2192 * dibdrv_SetDCBrushColor
2193 */
2194 COLORREF dibdrv_SetDCBrushColor( PHYSDEV dev, COLORREF color )
2195 {
2196 dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
2197
2198 if (GetCurrentObject(dev->hdc, OBJ_BRUSH) == GetStockObject( DC_BRUSH ))
2199 {
2200 LOGBRUSH logbrush = { BS_SOLID, color, 0 };
2201 select_brush( pdev, &pdev->brush, &logbrush, NULL );
2202 }
2203 return color;
2204 }
Windows API implementation