?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Add a function to retrieve the rop codes.
[wine/multimedia.git] / dlls / gdi32 / dibdrv / objects.c
blob15ce72f6e13b9537e14b9d900d82ae6405da2da1
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 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 RGBQUAD rgbquad_from_colorref(COLORREF c)
107 {
108 RGBQUAD ret;
109
110 ret.rgbRed = GetRValue(c);
111 ret.rgbGreen = GetGValue(c);
112 ret.rgbBlue = GetBValue(c);
113 ret.rgbReserved = 0;
114 return ret;
115 }
116
117 static inline BOOL rgbquad_equal(const RGBQUAD *a, const RGBQUAD *b)
118 {
119 if(a->rgbRed == b->rgbRed &&
120 a->rgbGreen == b->rgbGreen &&
121 a->rgbBlue == b->rgbBlue)
122 return TRUE;
123 return FALSE;
124 }
125
126 /******************************************************************
127 * get_fg_color
128 *
129 * 1 bit bitmaps map the fg/bg colors as follows:
130 * If the fg colorref exactly matches one of the color table entries then
131 * that entry is the fg color and the other is the bg.
132 * Otherwise the bg color is mapped to the closest entry in the table and
133 * the fg takes the other one.
134 */
135 DWORD get_fg_color( dibdrv_physdev *pdev, COLORREF fg )
136 {
137 RGBQUAD fg_quad;
138
139 if(pdev->dib.bit_count != 1)
140 return pdev->dib.funcs->colorref_to_pixel( &pdev->dib, fg );
141
142 fg_quad = rgbquad_from_colorref( fg );
143 if(rgbquad_equal(&fg_quad, pdev->dib.color_table))
144 return 0;
145 if(rgbquad_equal(&fg_quad, pdev->dib.color_table + 1))
146 return 1;
147
148 if(fg == GetBkColor(pdev->dev.hdc)) return pdev->bkgnd_color;
149 else return pdev->bkgnd_color ? 0 : 1;
150 }
151
152 /***************************************************************************
153 * get_pen_bkgnd_masks
154 *
155 * Returns the pre-calculated bkgnd color masks unless the dib is 1 bpp.
156 * In this case since there are several fg sources (pen, brush, text)
157 * this makes pdev->bkgnd_color unusable. So here we take the inverse
158 * of the relevant fg color (which is always set up correctly).
159 */
160 static inline void get_pen_bkgnd_masks(const dibdrv_physdev *pdev, DWORD *and, DWORD *xor)
161 {
162 if(pdev->dib.bit_count != 1 || GetBkMode(pdev->dev.hdc) == TRANSPARENT)
163 {
164 *and = pdev->bkgnd_and;
165 *xor = pdev->bkgnd_xor;
166 }
167 else
168 {
169 DWORD color = ~pdev->pen_color;
170 if(pdev->pen_colorref == GetBkColor(pdev->dev.hdc)) color = pdev->pen_color;
171 calc_and_xor_masks( GetROP2(pdev->dev.hdc), color, and, xor );
172 }
173 }
174
175 static inline void get_brush_bkgnd_masks(const dibdrv_physdev *pdev, DWORD *and, DWORD *xor)
176 {
177 if(GetBkMode(pdev->dev.hdc) == TRANSPARENT)
178 {
179 *and = pdev->bkgnd_and;
180 *xor = pdev->bkgnd_xor;
181 }
182 else
183 {
184 DWORD color = pdev->bkgnd_color;
185
186 if(pdev->dib.bit_count == 1)
187 {
188 if(pdev->brush_colorref == GetBkColor(pdev->dev.hdc))
189 color = pdev->brush_color;
190 else
191 color = ~pdev->brush_color;
192 }
193 calc_and_xor_masks( pdev->brush_rop, color, and, xor );
194 }
195 }
196
197 static inline void order_end_points(int *s, int *e)
198 {
199 if(*s > *e)
200 {
201 int tmp;
202 tmp = *s + 1;
203 *s = *e + 1;
204 *e = tmp;
205 }
206 }
207
208 static inline BOOL pt_in_rect( const RECT *rect, const POINT *pt )
209 {
210 return ((pt->x >= rect->left) && (pt->x < rect->right) &&
211 (pt->y >= rect->top) && (pt->y < rect->bottom));
212 }
213
214 #define Y_INCREASING_MASK 0x0f
215 #define X_INCREASING_MASK 0xc3
216 #define X_MAJOR_MASK 0x99
217 #define POS_SLOPE_MASK 0x33
218
219 static inline BOOL is_xmajor(DWORD octant)
220 {
221 return octant & X_MAJOR_MASK;
222 }
223
224 static inline BOOL is_pos_slope(DWORD octant)
225 {
226 return octant & POS_SLOPE_MASK;
227 }
228
229 static inline BOOL is_x_increasing(DWORD octant)
230 {
231 return octant & X_INCREASING_MASK;
232 }
233
234 static inline BOOL is_y_increasing(DWORD octant)
235 {
236 return octant & Y_INCREASING_MASK;
237 }
238
239 /**********************************************************************
240 * get_octant_number
241 *
242 * Return the octant number starting clockwise from the +ve x-axis.
243 */
244 static inline int get_octant_number(int dx, int dy)
245 {
246 if(dy > 0)
247 if(dx > 0)
248 return ( dx > dy) ? 1 : 2;
249 else
250 return (-dx > dy) ? 4 : 3;
251 else
252 if(dx < 0)
253 return (-dx > -dy) ? 5 : 6;
254 else
255 return ( dx > -dy) ? 8 : 7;
256 }
257
258 static inline DWORD get_octant_mask(int dx, int dy)
259 {
260 return 1 << (get_octant_number(dx, dy) - 1);
261 }
262
263 static void solid_pen_line_callback(dibdrv_physdev *pdev, INT x, INT y)
264 {
265 RECT rect;
266
267 rect.left = x;
268 rect.right = x + 1;
269 rect.top = y;
270 rect.bottom = y + 1;
271 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, pdev->pen_and, pdev->pen_xor);
272 return;
273 }
274
275 #define OUT_LEFT 1
276 #define OUT_RIGHT 2
277 #define OUT_TOP 4
278 #define OUT_BOTTOM 8
279
280 static inline DWORD calc_outcode(const POINT *pt, const RECT *clip)
281 {
282 DWORD out = 0;
283 if(pt->x < clip->left) out |= OUT_LEFT;
284 else if(pt->x >= clip->right) out |= OUT_RIGHT;
285 if(pt->y < clip->top) out |= OUT_TOP;
286 else if(pt->y >= clip->bottom) out |= OUT_BOTTOM;
287
288 return out;
289 }
290
291 typedef struct
292 {
293 unsigned int dx, dy;
294 int bias;
295 DWORD octant;
296 } bres_params;
297
298 /******************************************************************************
299 * clip_line
300 *
301 * Clips the start and end points to a rectangle.
302 *
303 * Note, this treats the end point like the start point. If the
304 * caller doesn't want it displayed, it should exclude it. If the end
305 * point is clipped out, then the likelihood is that the new end point
306 * should be displayed.
307 *
308 * Returns 0 if totally excluded, 1 if partially clipped and 2 if unclipped.
309 *
310 * This derivation is based on the comments in X.org's xserver/mi/mizerclip.c,
311 * however the Bresenham error term is defined differently so the equations
312 * will also differ.
313 *
314 * For x major lines we have 2dy >= err + bias > 2dy - 2dx
315 * 0 >= err + bias - 2dy > -2dx
316 *
317 * Note dx, dy, m and n are all +ve.
318 *
319 * Moving the start pt from x1 to x1 + m, we need to figure out y1 + n.
320 * err = 2dy - dx + 2mdy - 2ndx
321 * 0 >= 2dy - dx + 2mdy - 2ndx + bias - 2dy > -2dx
322 * 0 >= 2mdy - 2ndx + bias - dx > -2dx
323 * which of course will give exactly one solution for n,
324 * so looking at the >= inequality
325 * n >= (2mdy + bias - dx) / 2dx
326 * n = ceiling((2mdy + bias - dx) / 2dx)
327 * = (2mdy + bias + dx - 1) / 2dx (assuming division truncation)
328 *
329 * Moving start pt from y1 to y1 + n we need to figure out x1 + m - there may be several
330 * solutions we pick the one that minimizes m (ie that first unlipped pt). As above:
331 * 0 >= 2mdy - 2ndx + bias - dx > -2dx
332 * 2mdy > 2ndx - bias - dx
333 * m > (2ndx - bias - dx) / 2dy
334 * m = floor((2ndx - bias - dx) / 2dy) + 1
335 * m = (2ndx - bias - dx) / 2dy + 1
336 *
337 * Moving end pt from x2 to x2 - m, we need to figure out y2 - n
338 * err = 2dy - dx + 2(dx - m)dy - 2(dy - n)dx
339 * = 2dy - dx - 2mdy + 2ndx
340 * 0 >= 2dy - dx - 2mdy + 2ndx + bias - 2dy > -2dx
341 * 0 >= 2ndx - 2mdy + bias - dx > -2dx
342 * again exactly one solution.
343 * 2ndx <= 2mdy - bias + dx
344 * n = floor((2mdy - bias + dx) / 2dx)
345 * = (2mdy - bias + dx) / 2dx
346 *
347 * Moving end pt from y2 to y2 - n when need x2 - m this time maximizing x2 - m so
348 * mininizing m to include all of the points at y = y2 - n. As above:
349 * 0 >= 2ndx - 2mdy + bias - dx > -2dx
350 * 2mdy >= 2ndx + bias - dx
351 * m = ceiling((2ndx + bias - dx) / 2dy)
352 * = (2ndx + bias - dx - 1) / 2dy + 1
353 *
354 * For y major lines, symmetry (dx <-> dy and swap the cases over) gives:
355 *
356 * Moving start point from y1 to y1 + n find x1 + m
357 * m = (2ndx + bias + dy - 1) / 2dy
358 *
359 * Moving start point from x1 to x1 + m find y1 + n
360 * n = (2mdy - bias - dy) / 2ndx + 1
361 *
362 * Moving end point from y2 to y2 - n find x1 - m
363 * m = (2ndx - bias + dy) / 2dy
364 *
365 * Moving end point from x2 to x2 - m find y2 - n
366 * n = (2mdy + bias - dy - 1) / 2dx + 1
367 */
368 static int clip_line(const POINT *start, const POINT *end, const RECT *clip,
369 const bres_params *params, POINT *pt1, POINT *pt2)
370 {
371 unsigned int n, m;
372 BOOL clipped = FALSE;
373 DWORD start_oc, end_oc;
374 const int bias = params->bias;
375 const unsigned int dx = params->dx;
376 const unsigned int dy = params->dy;
377 const unsigned int two_dx = params->dx * 2;
378 const unsigned int two_dy = params->dy * 2;
379 const BOOL xmajor = is_xmajor(params->octant);
380 const BOOL neg_slope = !is_pos_slope(params->octant);
381
382 *pt1 = *start;
383 *pt2 = *end;
384
385 start_oc = calc_outcode(start, clip);
386 end_oc = calc_outcode(end, clip);
387
388 while(1)
389 {
390 if(start_oc == 0 && end_oc == 0) return clipped ? 1 : 2; /* trivial accept */
391 if(start_oc & end_oc) return 0; /* trivial reject */
392
393 clipped = TRUE;
394 if(start_oc & OUT_LEFT)
395 {
396 m = clip->left - start->x;
397 if(xmajor)
398 n = (m * two_dy + bias + dx - 1) / two_dx;
399 else
400 n = (m * two_dy - bias - dy) / two_dx + 1;
401
402 pt1->x = clip->left;
403 if(neg_slope) n = -n;
404 pt1->y = start->y + n;
405 start_oc = calc_outcode(pt1, clip);
406 }
407 else if(start_oc & OUT_RIGHT)
408 {
409 m = start->x - clip->right + 1;
410 if(xmajor)
411 n = (m * two_dy + bias + dx - 1) / two_dx;
412 else
413 n = (m * two_dy - bias - dy) / two_dx + 1;
414
415 pt1->x = clip->right - 1;
416 if(neg_slope) n = -n;
417 pt1->y = start->y - n;
418 start_oc = calc_outcode(pt1, clip);
419 }
420 else if(start_oc & OUT_TOP)
421 {
422 n = clip->top - start->y;
423 if(xmajor)
424 m = (n * two_dx - bias - dx) / two_dy + 1;
425 else
426 m = (n * two_dx + bias + dy - 1) / two_dy;
427
428 pt1->y = clip->top;
429 if(neg_slope) m = -m;
430 pt1->x = start->x + m;
431 start_oc = calc_outcode(pt1, clip);
432 }
433 else if(start_oc & OUT_BOTTOM)
434 {
435 n = start->y - clip->bottom + 1;
436 if(xmajor)
437 m = (n * two_dx - bias - dx) / two_dy + 1;
438 else
439 m = (n * two_dx + bias + dy - 1) / two_dy;
440
441 pt1->y = clip->bottom - 1;
442 if(neg_slope) m = -m;
443 pt1->x = start->x - m;
444 start_oc = calc_outcode(pt1, clip);
445 }
446 else if(end_oc & OUT_LEFT)
447 {
448 m = clip->left - end->x;
449 if(xmajor)
450 n = (m * two_dy - bias + dx) / two_dx;
451 else
452 n = (m * two_dy + bias - dy - 1) / two_dx + 1;
453
454 pt2->x = clip->left;
455 if(neg_slope) n = -n;
456 pt2->y = end->y + n;
457 end_oc = calc_outcode(pt2, clip);
458 }
459 else if(end_oc & OUT_RIGHT)
460 {
461 m = end->x - clip->right + 1;
462 if(xmajor)
463 n = (m * two_dy - bias + dx) / two_dx;
464 else
465 n = (m * two_dy + bias - dy - 1) / two_dx + 1;
466
467 pt2->x = clip->right - 1;
468 if(neg_slope) n = -n;
469 pt2->y = end->y - n;
470 end_oc = calc_outcode(pt2, clip);
471 }
472 else if(end_oc & OUT_TOP)
473 {
474 n = clip->top - end->y;
475 if(xmajor)
476 m = (n * two_dx + bias - dx - 1) / two_dy + 1;
477 else
478 m = (n * two_dx - bias + dy) / two_dy;
479
480 pt2->y = clip->top;
481 if(neg_slope) m = -m;
482 pt2->x = end->x + m;
483 end_oc = calc_outcode(pt2, clip);
484 }
485 else if(end_oc & OUT_BOTTOM)
486 {
487 n = end->y - clip->bottom + 1;
488 if(xmajor)
489 m = (n * two_dx + bias - dx - 1) / two_dy + 1;
490 else
491 m = (n * two_dx - bias + dy) / two_dy;
492
493 pt2->y = clip->bottom - 1;
494 if(neg_slope) m = -m;
495 pt2->x = end->x - m;
496 end_oc = calc_outcode(pt2, clip);
497 }
498 }
499 }
500
501 static void bres_line_with_bias(INT x1, INT y1, INT x2, INT y2, const bres_params *params, INT err,
502 BOOL last_pt, void (* callback)(dibdrv_physdev*,INT,INT), dibdrv_physdev *pdev)
503 {
504 const int xadd = is_x_increasing(params->octant) ? 1 : -1;
505 const int yadd = is_y_increasing(params->octant) ? 1 : -1;
506 INT erradd;
507
508 if (is_xmajor(params->octant)) /* line is "more horizontal" */
509 {
510 erradd = 2*params->dy - 2*params->dx;
511 while(x1 != x2)
512 {
513 callback(pdev, x1, y1);
514 if (err + params->bias > 0)
515 {
516 y1 += yadd;
517 err += erradd;
518 }
519 else err += 2*params->dy;
520 x1 += xadd;
521 }
522 if(last_pt) callback(pdev, x1, y1);
523 }
524 else /* line is "more vertical" */
525 {
526 erradd = 2*params->dx - 2*params->dy;
527 while(y1 != y2)
528 {
529 callback(pdev, x1, y1);
530 if (err + params->bias > 0)
531 {
532 x1 += xadd;
533 err += erradd;
534 }
535 else err += 2*params->dx;
536 y1 += yadd;
537 }
538 if(last_pt) callback(pdev, x1, y1);
539 }
540 }
541
542 static BOOL solid_pen_line(dibdrv_physdev *pdev, POINT *start, POINT *end)
543 {
544 const WINEREGION *clip = get_wine_region(pdev->clip);
545
546 if(start->y == end->y)
547 {
548 RECT rect;
549 int i;
550
551 rect.left = start->x;
552 rect.top = start->y;
553 rect.right = end->x;
554 rect.bottom = end->y + 1;
555 order_end_points(&rect.left, &rect.right);
556 for(i = 0; i < clip->numRects; i++)
557 {
558 if(clip->rects[i].top >= rect.bottom) break;
559 if(clip->rects[i].bottom <= rect.top) continue;
560 /* Optimize the unclipped case */
561 if(clip->rects[i].left <= rect.left && clip->rects[i].right >= rect.right)
562 {
563 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, pdev->pen_and, pdev->pen_xor);
564 break;
565 }
566 if(clip->rects[i].right > rect.left && clip->rects[i].left < rect.right)
567 {
568 RECT tmp = rect;
569 tmp.left = max(rect.left, clip->rects[i].left);
570 tmp.right = min(rect.right, clip->rects[i].right);
571 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &tmp, pdev->pen_and, pdev->pen_xor);
572 }
573 }
574 }
575 else if(start->x == end->x)
576 {
577 RECT rect;
578 int i;
579
580 rect.left = start->x;
581 rect.top = start->y;
582 rect.right = end->x + 1;
583 rect.bottom = end->y;
584 order_end_points(&rect.top, &rect.bottom);
585 for(i = 0; i < clip->numRects; i++)
586 {
587 /* Optimize unclipped case */
588 if(clip->rects[i].top <= rect.top && clip->rects[i].bottom >= rect.bottom &&
589 clip->rects[i].left <= rect.left && clip->rects[i].right >= rect.right)
590 {
591 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, pdev->pen_and, pdev->pen_xor);
592 break;
593 }
594 if(clip->rects[i].top >= rect.bottom) break;
595 if(clip->rects[i].bottom <= rect.top) continue;
596 if(clip->rects[i].right > rect.left && clip->rects[i].left < rect.right)
597 {
598 RECT tmp = rect;
599 tmp.top = max(rect.top, clip->rects[i].top);
600 tmp.bottom = min(rect.bottom, clip->rects[i].bottom);
601 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &tmp, pdev->pen_and, pdev->pen_xor);
602 }
603 }
604 }
605 else
606 {
607 bres_params params;
608 INT dx = end->x - start->x;
609 INT dy = end->y - start->y;
610 INT i;
611
612 params.dx = abs(dx);
613 params.dy = abs(dy);
614 params.octant = get_octant_mask(dx, dy);
615 /* Octants 3, 5, 6 and 8 take a bias */
616 params.bias = (params.octant & 0xb4) ? 1 : 0;
617
618 for(i = 0; i < clip->numRects; i++)
619 {
620 POINT clipped_start, clipped_end;
621 int clip_status;
622 clip_status = clip_line(start, end, clip->rects + i, &params, &clipped_start, &clipped_end);
623
624 if(clip_status)
625 {
626 int m = abs(clipped_start.x - start->x);
627 int n = abs(clipped_start.y - start->y);
628 int err;
629 BOOL last_pt = FALSE;
630
631 if(is_xmajor(params.octant))
632 err = 2 * params.dy - params.dx + m * 2 * params.dy - n * 2 * params.dx;
633 else
634 err = 2 * params.dx - params.dy + n * 2 * params.dx - m * 2 * params.dy;
635
636 if(clip_status == 1 && (end->x != clipped_end.x || end->y != clipped_end.y)) last_pt = TRUE;
637
638 bres_line_with_bias(clipped_start.x, clipped_start.y, clipped_end.x, clipped_end.y, &params,
639 err, last_pt, solid_pen_line_callback, pdev);
640
641 if(clip_status == 2) break; /* completely unclipped, so we can finish */
642 }
643 }
644
645 }
646 release_wine_region(pdev->clip);
647 return TRUE;
648 }
649
650 void reset_dash_origin(dibdrv_physdev *pdev)
651 {
652 pdev->dash_pos.cur_dash = 0;
653 pdev->dash_pos.left_in_dash = pdev->pen_pattern.dashes[0];
654 pdev->dash_pos.mark = TRUE;
655 }
656
657 static inline void skip_dash(dibdrv_physdev *pdev, unsigned int skip)
658 {
659 skip %= pdev->pen_pattern.total_len;
660 while(skip)
661 {
662 if(pdev->dash_pos.left_in_dash > skip)
663 {
664 pdev->dash_pos.left_in_dash -= skip;
665 return;
666 }
667 skip -= pdev->dash_pos.left_in_dash;
668 pdev->dash_pos.cur_dash++;
669 if(pdev->dash_pos.cur_dash == pdev->pen_pattern.count) pdev->dash_pos.cur_dash = 0;
670 pdev->dash_pos.left_in_dash = pdev->pen_pattern.dashes[pdev->dash_pos.cur_dash];
671 pdev->dash_pos.mark = !pdev->dash_pos.mark;
672 }
673 }
674
675 static inline void get_dash_colors(const dibdrv_physdev *pdev, DWORD *and, DWORD *xor)
676 {
677 if(pdev->dash_pos.mark)
678 {
679 *and = pdev->pen_and;
680 *xor = pdev->pen_xor;
681 }
682 else /* space */
683 {
684 get_pen_bkgnd_masks( pdev, and, xor );
685 }
686 }
687
688 static void dashed_pen_line_callback(dibdrv_physdev *pdev, INT x, INT y)
689 {
690 RECT rect;
691 DWORD and, xor;
692
693 get_dash_colors(pdev, &and, &xor);
694 skip_dash(pdev, 1);
695 rect.left = x;
696 rect.right = x + 1;
697 rect.top = y;
698 rect.bottom = y + 1;
699 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, and, xor);
700 return;
701 }
702
703 static BOOL dashed_pen_line(dibdrv_physdev *pdev, POINT *start, POINT *end)
704 {
705 const WINEREGION *clip = get_wine_region(pdev->clip);
706 DWORD and, xor;
707 int i, dash_len;
708 RECT rect;
709 const dash_pos start_pos = pdev->dash_pos;
710
711 if(start->y == end->y) /* hline */
712 {
713 BOOL l_to_r;
714 INT left, right, cur_x;
715
716 rect.top = start->y;
717 rect.bottom = start->y + 1;
718
719 if(start->x <= end->x)
720 {
721 left = start->x;
722 right = end->x - 1;
723 l_to_r = TRUE;
724 }
725 else
726 {
727 left = end->x + 1;
728 right = start->x;
729 l_to_r = FALSE;
730 }
731
732 for(i = 0; i < clip->numRects; i++)
733 {
734 if(clip->rects[i].top > start->y) break;
735 if(clip->rects[i].bottom <= start->y) continue;
736
737 if(clip->rects[i].right > left && clip->rects[i].left <= right)
738 {
739 int clipped_left = max(clip->rects[i].left, left);
740 int clipped_right = min(clip->rects[i].right - 1, right);
741
742 pdev->dash_pos = start_pos;
743
744 if(l_to_r)
745 {
746 cur_x = clipped_left;
747 if(cur_x != left)
748 skip_dash(pdev, clipped_left - left);
749
750 while(cur_x <= clipped_right)
751 {
752 get_dash_colors(pdev, &and, &xor);
753 dash_len = pdev->dash_pos.left_in_dash;
754 if(cur_x + dash_len > clipped_right + 1)
755 dash_len = clipped_right - cur_x + 1;
756 rect.left = cur_x;
757 rect.right = cur_x + dash_len;
758
759 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, and, xor);
760 cur_x += dash_len;
761 skip_dash(pdev, dash_len);
762 }
763 }
764 else
765 {
766 cur_x = clipped_right;
767 if(cur_x != right)
768 skip_dash(pdev, right - clipped_right);
769
770 while(cur_x >= clipped_left)
771 {
772 get_dash_colors(pdev, &and, &xor);
773 dash_len = pdev->dash_pos.left_in_dash;
774 if(cur_x - dash_len < clipped_left - 1)
775 dash_len = cur_x - clipped_left + 1;
776 rect.left = cur_x - dash_len + 1;
777 rect.right = cur_x + 1;
778
779 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, and, xor);
780 cur_x -= dash_len;
781 skip_dash(pdev, dash_len);
782 }
783 }
784 }
785 }
786 pdev->dash_pos = start_pos;
787 skip_dash(pdev, right - left + 1);
788 }
789 else if(start->x == end->x) /* vline */
790 {
791 BOOL t_to_b;
792 INT top, bottom, cur_y;
793
794 rect.left = start->x;
795 rect.right = start->x + 1;
796
797 if(start->y <= end->y)
798 {
799 top = start->y;
800 bottom = end->y - 1;
801 t_to_b = TRUE;
802 }
803 else
804 {
805 top = end->y + 1;
806 bottom = start->y;
807 t_to_b = FALSE;
808 }
809
810 for(i = 0; i < clip->numRects; i++)
811 {
812 if(clip->rects[i].top > bottom) break;
813 if(clip->rects[i].bottom <= top) continue;
814 if(clip->rects[i].right > start->x && clip->rects[i].left <= start->x)
815 {
816 int clipped_top = max(clip->rects[i].top, top);
817 int clipped_bottom = min(clip->rects[i].bottom - 1, bottom);
818
819 pdev->dash_pos = start_pos;
820
821 if(t_to_b)
822 {
823 cur_y = clipped_top;
824 if(cur_y != top)
825 skip_dash(pdev, clipped_top - top);
826
827 while(cur_y <= clipped_bottom)
828 {
829 get_dash_colors(pdev, &and, &xor);
830 dash_len = pdev->dash_pos.left_in_dash;
831 if(cur_y + dash_len > clipped_bottom + 1)
832 dash_len = clipped_bottom - cur_y + 1;
833 rect.top = cur_y;
834 rect.bottom = cur_y + dash_len;
835
836 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, and, xor);
837 cur_y += dash_len;
838 skip_dash(pdev, dash_len);
839 }
840 }
841 else
842 {
843 cur_y = clipped_bottom;
844 if(cur_y != bottom)
845 skip_dash(pdev, bottom - clipped_bottom);
846
847 while(cur_y >= clipped_top)
848 {
849 get_dash_colors(pdev, &and, &xor);
850 dash_len = pdev->dash_pos.left_in_dash;
851 if(cur_y - dash_len < clipped_top - 1)
852 dash_len = cur_y - clipped_top + 1;
853 rect.top = cur_y - dash_len + 1;
854 rect.bottom = cur_y + 1;
855
856 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, and, xor);
857 cur_y -= dash_len;
858 skip_dash(pdev, dash_len);
859 }
860 }
861 }
862 }
863 pdev->dash_pos = start_pos;
864 skip_dash(pdev, bottom - top + 1);
865 }
866 else
867 {
868 bres_params params;
869 INT dx = end->x - start->x;
870 INT dy = end->y - start->y;
871 INT i;
872
873 params.dx = abs(dx);
874 params.dy = abs(dy);
875 params.octant = get_octant_mask(dx, dy);
876 /* Octants 3, 5, 6 and 8 take a bias */
877 params.bias = (params.octant & 0xb4) ? 1 : 0;
878
879 for(i = 0; i < clip->numRects; i++)
880 {
881 POINT clipped_start, clipped_end;
882 int clip_status;
883 clip_status = clip_line(start, end, clip->rects + i, &params, &clipped_start, &clipped_end);
884
885 if(clip_status)
886 {
887 int m = abs(clipped_start.x - start->x);
888 int n = abs(clipped_start.y - start->y);
889 int err;
890 BOOL last_pt = FALSE;
891
892 pdev->dash_pos = start_pos;
893
894 if(is_xmajor(params.octant))
895 {
896 err = 2 * params.dy - params.dx + m * 2 * params.dy - n * 2 * params.dx;
897 skip_dash(pdev, m);
898 }
899 else
900 {
901 err = 2 * params.dx - params.dy + n * 2 * params.dx - m * 2 * params.dy;
902 skip_dash(pdev, n);
903 }
904 if(clip_status == 1 && (end->x != clipped_end.x || end->y != clipped_end.y)) last_pt = TRUE;
905
906 bres_line_with_bias(clipped_start.x, clipped_start.y, clipped_end.x, clipped_end.y, &params,
907 err, last_pt, dashed_pen_line_callback, pdev);
908
909 if(clip_status == 2) break; /* completely unclipped, so we can finish */
910 }
911 }
912 pdev->dash_pos = start_pos;
913 if(is_xmajor(params.octant))
914 skip_dash(pdev, params.dx);
915 else
916 skip_dash(pdev, params.dy);
917 }
918
919 release_wine_region(pdev->clip);
920 return TRUE;
921 }
922
923 static BOOL null_pen_line(dibdrv_physdev *pdev, POINT *start, POINT *end)
924 {
925 return TRUE;
926 }
927
928 static const dash_pattern dash_patterns[5] =
929 {
930 {0, {0}, 0}, /* PS_SOLID - a pseudo-pattern used to initialise unpatterned pens. */
931 {2, {18, 6}, 24}, /* PS_DASH */
932 {2, {3, 3}, 6}, /* PS_DOT */
933 {4, {9, 6, 3, 6}, 24}, /* PS_DASHDOT */
934 {6, {9, 3, 3, 3, 3, 3}, 24} /* PS_DASHDOTDOT */
935 };
936
937 /***********************************************************************
938 * dibdrv_SelectPen
939 */
940 HPEN dibdrv_SelectPen( PHYSDEV dev, HPEN hpen )
941 {
942 PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSelectPen );
943 dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
944 LOGPEN logpen;
945 DWORD style;
946
947 TRACE("(%p, %p)\n", dev, hpen);
948
949 if (!GetObjectW( hpen, sizeof(logpen), &logpen ))
950 {
951 /* must be an extended pen */
952 EXTLOGPEN *elp;
953 INT size = GetObjectW( hpen, 0, NULL );
954
955 if (!size) return 0;
956
957 elp = HeapAlloc( GetProcessHeap(), 0, size );
958
959 GetObjectW( hpen, size, elp );
960 /* FIXME: add support for user style pens */
961 logpen.lopnStyle = elp->elpPenStyle;
962 logpen.lopnWidth.x = elp->elpWidth;
963 logpen.lopnWidth.y = 0;
964 logpen.lopnColor = elp->elpColor;
965
966 HeapFree( GetProcessHeap(), 0, elp );
967 }
968
969 if (hpen == GetStockObject( DC_PEN ))
970 logpen.lopnColor = GetDCPenColor( dev->hdc );
971
972 pdev->pen_colorref = logpen.lopnColor;
973 pdev->pen_color = get_fg_color( pdev, pdev->pen_colorref );
974 calc_and_xor_masks(GetROP2(dev->hdc), pdev->pen_color, &pdev->pen_and, &pdev->pen_xor);
975
976 pdev->pen_pattern = dash_patterns[PS_SOLID];
977
978 pdev->defer |= DEFER_PEN;
979
980 style = logpen.lopnStyle & PS_STYLE_MASK;
981
982 switch(style)
983 {
984 case PS_SOLID:
985 if(logpen.lopnStyle & PS_GEOMETRIC) break;
986 if(logpen.lopnWidth.x > 1) break;
987 pdev->pen_line = solid_pen_line;
988 pdev->defer &= ~DEFER_PEN;
989 break;
990
991 case PS_DASH:
992 case PS_DOT:
993 case PS_DASHDOT:
994 case PS_DASHDOTDOT:
995 if(logpen.lopnStyle & PS_GEOMETRIC) break;
996 if(logpen.lopnWidth.x > 1) break;
997 pdev->pen_line = dashed_pen_line;
998 pdev->pen_pattern = dash_patterns[style];
999 pdev->defer &= ~DEFER_PEN;
1000 break;
1001
1002 case PS_NULL:
1003 pdev->pen_line = null_pen_line;
1004 pdev->defer &= ~DEFER_PEN;
1005 break;
1006
1007 default:
1008 break;
1009 }
1010
1011 return next->funcs->pSelectPen( next, hpen );
1012 }
1013
1014 /***********************************************************************
1015 * dibdrv_SetDCPenColor
1016 */
1017 COLORREF dibdrv_SetDCPenColor( PHYSDEV dev, COLORREF color )
1018 {
1019 PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetDCPenColor );
1020 dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
1021
1022 if (GetCurrentObject(dev->hdc, OBJ_PEN) == GetStockObject( DC_PEN ))
1023 {
1024 pdev->pen_colorref = color;
1025 pdev->pen_color = get_fg_color( pdev, pdev->pen_colorref );
1026 calc_and_xor_masks(GetROP2(dev->hdc), pdev->pen_color, &pdev->pen_and, &pdev->pen_xor);
1027 }
1028
1029 return next->funcs->pSetDCPenColor( next, color );
1030 }
1031
1032 /**********************************************************************
1033 * solid_brush
1034 *
1035 * Fill a number of rectangles with the solid brush
1036 * FIXME: Should we insist l < r && t < b? Currently we assume this.
1037 */
1038 static BOOL solid_brush(dibdrv_physdev *pdev, int num, RECT *rects)
1039 {
1040 int i, j;
1041 const WINEREGION *clip = get_wine_region(pdev->clip);
1042
1043 for(i = 0; i < num; i++)
1044 {
1045 for(j = 0; j < clip->numRects; j++)
1046 {
1047 RECT rect = rects[i];
1048
1049 /* Optimize unclipped case */
1050 if(clip->rects[j].top <= rect.top && clip->rects[j].bottom >= rect.bottom &&
1051 clip->rects[j].left <= rect.left && clip->rects[j].right >= rect.right)
1052 {
1053 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, pdev->brush_and, pdev->brush_xor);
1054 break;
1055 }
1056
1057 if(clip->rects[j].top >= rect.bottom) break;
1058 if(clip->rects[j].bottom <= rect.top) continue;
1059
1060 if(clip->rects[j].right > rect.left && clip->rects[j].left < rect.right)
1061 {
1062 rect.left = max(rect.left, clip->rects[j].left);
1063 rect.top = max(rect.top, clip->rects[j].top);
1064 rect.right = min(rect.right, clip->rects[j].right);
1065 rect.bottom = min(rect.bottom, clip->rects[j].bottom);
1066
1067 pdev->dib.funcs->solid_rects(&pdev->dib, 1, &rect, pdev->brush_and, pdev->brush_xor);
1068 }
1069 }
1070 }
1071 release_wine_region(pdev->clip);
1072 return TRUE;
1073 }
1074
1075 static void free_pattern_brush_bits( dibdrv_physdev *pdev )
1076 {
1077 HeapFree(GetProcessHeap(), 0, pdev->brush_and_bits);
1078 HeapFree(GetProcessHeap(), 0, pdev->brush_xor_bits);
1079 pdev->brush_and_bits = NULL;
1080 pdev->brush_xor_bits = NULL;
1081 }
1082
1083 void free_pattern_brush( dibdrv_physdev *pdev )
1084 {
1085 free_pattern_brush_bits( pdev );
1086 free_dib_info( &pdev->brush_dib );
1087 }
1088
1089 static BOOL create_pattern_brush_bits(dibdrv_physdev *pdev)
1090 {
1091 DWORD size = pdev->brush_dib.height * abs(pdev->brush_dib.stride);
1092 DWORD *brush_bits = pdev->brush_dib.bits;
1093 DWORD *and_bits, *xor_bits;
1094
1095 assert(pdev->brush_and_bits == NULL);
1096 assert(pdev->brush_xor_bits == NULL);
1097
1098 assert(pdev->brush_dib.stride > 0);
1099
1100 and_bits = pdev->brush_and_bits = HeapAlloc(GetProcessHeap(), 0, size);
1101 xor_bits = pdev->brush_xor_bits = HeapAlloc(GetProcessHeap(), 0, size);
1102
1103 if(!and_bits || !xor_bits)
1104 {
1105 ERR("Failed to create pattern brush bits\n");
1106 free_pattern_brush_bits( pdev );
1107 return FALSE;
1108 }
1109
1110 while(size)
1111 {
1112 calc_and_xor_masks(pdev->brush_rop, *brush_bits++, and_bits++, xor_bits++);
1113 size -= 4;
1114 }
1115
1116 return TRUE;
1117 }
1118
1119 static const DWORD hatches[6][8] =
1120 {
1121 { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00 }, /* HS_HORIZONTAL */
1122 { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 }, /* HS_VERTICAL */
1123 { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }, /* HS_FDIAGONAL */
1124 { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 }, /* HS_BDIAGONAL */
1125 { 0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08 }, /* HS_CROSS */
1126 { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 } /* HS_DIAGCROSS */
1127 };
1128
1129 static BOOL create_hatch_brush_bits(dibdrv_physdev *pdev)
1130 {
1131 dib_info hatch;
1132 rop_mask fg_mask, bg_mask;
1133 rop_mask_bits mask_bits;
1134 DWORD size;
1135 BOOL ret;
1136
1137 assert(pdev->brush_and_bits == NULL);
1138 assert(pdev->brush_xor_bits == NULL);
1139
1140 /* Just initialise brush_dib with the color / sizing info. We don't
1141 need the bits as we'll calculate the rop masks straight from
1142 the hatch patterns. */
1143
1144 copy_dib_color_info(&pdev->brush_dib, &pdev->dib);
1145 pdev->brush_dib.width = 8;
1146 pdev->brush_dib.height = 8;
1147 pdev->brush_dib.stride = get_dib_stride( pdev->brush_dib.width, pdev->brush_dib.bit_count );
1148
1149 size = pdev->brush_dib.height * pdev->brush_dib.stride;
1150
1151 mask_bits.and = pdev->brush_and_bits = HeapAlloc(GetProcessHeap(), 0, size);
1152 mask_bits.xor = pdev->brush_xor_bits = HeapAlloc(GetProcessHeap(), 0, size);
1153
1154 if(!mask_bits.and || !mask_bits.xor)
1155 {
1156 ERR("Failed to create pattern brush bits\n");
1157 free_pattern_brush_bits( pdev );
1158 return FALSE;
1159 }
1160
1161 hatch.bit_count = 1;
1162 hatch.height = hatch.width = 8;
1163 hatch.stride = 4;
1164 hatch.bits = (void *) hatches[pdev->brush_hatch];
1165
1166 fg_mask.and = pdev->brush_and;
1167 fg_mask.xor = pdev->brush_xor;
1168 get_brush_bkgnd_masks( pdev, &bg_mask.and, &bg_mask.xor );
1169
1170 ret = pdev->brush_dib.funcs->create_rop_masks( &pdev->brush_dib, &hatch, &fg_mask, &bg_mask, &mask_bits );
1171 if(!ret) free_pattern_brush_bits( pdev );
1172
1173 return ret;
1174 }
1175
1176 /**********************************************************************
1177 * pattern_brush
1178 *
1179 * Fill a number of rectangles with the pattern brush
1180 * FIXME: Should we insist l < r && t < b? Currently we assume this.
1181 */
1182 static BOOL pattern_brush(dibdrv_physdev *pdev, int num, RECT *rects)
1183 {
1184 int i, j;
1185 const WINEREGION *clip;
1186 POINT origin;
1187
1188 if(pdev->brush_and_bits == NULL)
1189 {
1190 switch(pdev->brush_style)
1191 {
1192 case BS_DIBPATTERN:
1193 if(!create_pattern_brush_bits(pdev))
1194 return FALSE;
1195 break;
1196
1197 case BS_HATCHED:
1198 if(!create_hatch_brush_bits(pdev))
1199 return FALSE;
1200 break;
1201
1202 default:
1203 ERR("Unexpected brush style %d\n", pdev->brush_style);
1204 return FALSE;
1205 }
1206 }
1207
1208 GetBrushOrgEx(pdev->dev.hdc, &origin);
1209
1210 clip = get_wine_region(pdev->clip);
1211 for(i = 0; i < num; i++)
1212 {
1213 for(j = 0; j < clip->numRects; j++)
1214 {
1215 RECT rect = rects[i];
1216
1217 /* Optimize unclipped case */
1218 if(clip->rects[j].top <= rect.top && clip->rects[j].bottom >= rect.bottom &&
1219 clip->rects[j].left <= rect.left && clip->rects[j].right >= rect.right)
1220 {
1221 pdev->dib.funcs->pattern_rects(&pdev->dib, 1, &rect, &origin, &pdev->brush_dib, pdev->brush_and_bits, pdev->brush_xor_bits);
1222 break;
1223 }
1224
1225 if(clip->rects[j].top >= rect.bottom) break;
1226 if(clip->rects[j].bottom <= rect.top) continue;
1227
1228 if(clip->rects[j].right > rect.left && clip->rects[j].left < rect.right)
1229 {
1230 rect.left = max(rect.left, clip->rects[j].left);
1231 rect.top = max(rect.top, clip->rects[j].top);
1232 rect.right = min(rect.right, clip->rects[j].right);
1233 rect.bottom = min(rect.bottom, clip->rects[j].bottom);
1234
1235 pdev->dib.funcs->pattern_rects(&pdev->dib, 1, &rect, &origin, &pdev->brush_dib, pdev->brush_and_bits, pdev->brush_xor_bits);
1236 }
1237 }
1238 }
1239 release_wine_region(pdev->clip);
1240 return TRUE;
1241 }
1242
1243 static BOOL null_brush(dibdrv_physdev *pdev, int num, RECT *rects)
1244 {
1245 return TRUE;
1246 }
1247
1248 void update_brush_rop( dibdrv_physdev *pdev, INT rop )
1249 {
1250 pdev->brush_rop = rop;
1251 if(pdev->brush_style == BS_SOLID || pdev->brush_style == BS_HATCHED)
1252 calc_and_xor_masks(rop, pdev->brush_color, &pdev->brush_and, &pdev->brush_xor);
1253 free_pattern_brush_bits( pdev );
1254 }
1255
1256 /***********************************************************************
1257 * dibdrv_SelectBrush
1258 */
1259 HBRUSH dibdrv_SelectBrush( PHYSDEV dev, HBRUSH hbrush )
1260 {
1261 PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSelectBrush );
1262 dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
1263 LOGBRUSH logbrush;
1264
1265 TRACE("(%p, %p)\n", dev, hbrush);
1266
1267 if (!GetObjectW( hbrush, sizeof(logbrush), &logbrush )) return 0;
1268
1269 if (hbrush == GetStockObject( DC_BRUSH ))
1270 logbrush.lbColor = GetDCBrushColor( dev->hdc );
1271
1272 pdev->brush_style = logbrush.lbStyle;
1273
1274 pdev->defer |= DEFER_BRUSH;
1275
1276 free_pattern_brush( pdev );
1277
1278 switch(logbrush.lbStyle)
1279 {
1280 case BS_SOLID:
1281 pdev->brush_colorref = logbrush.lbColor;
1282 pdev->brush_color = get_fg_color( pdev, pdev->brush_colorref );
1283 calc_and_xor_masks(GetROP2(dev->hdc), pdev->brush_color, &pdev->brush_and, &pdev->brush_xor);
1284 pdev->brush_rects = solid_brush;
1285 pdev->defer &= ~DEFER_BRUSH;
1286 break;
1287
1288 case BS_NULL:
1289 pdev->brush_rects = null_brush;
1290 pdev->defer &= ~DEFER_BRUSH;
1291 break;
1292
1293 case BS_DIBPATTERN:
1294 {
1295 BITMAPINFOHEADER *bi = GlobalLock((HGLOBAL)logbrush.lbHatch);
1296 dib_info orig_dib;
1297 WORD usage = LOWORD(logbrush.lbColor);
1298 HPALETTE pal = (usage == DIB_PAL_COLORS) ? GetCurrentObject(dev->hdc, OBJ_PAL) : NULL;
1299 RECT rect;
1300
1301 if(!bi) return NULL;
1302 if(init_dib_info_from_packed(&orig_dib, bi, usage, pal))
1303 {
1304 copy_dib_color_info(&pdev->brush_dib, &pdev->dib);
1305
1306 pdev->brush_dib.height = orig_dib.height;
1307 pdev->brush_dib.width = orig_dib.width;
1308 pdev->brush_dib.stride = get_dib_stride( pdev->brush_dib.width, pdev->brush_dib.bit_count );
1309 pdev->brush_dib.ptr_to_free = HeapAlloc( GetProcessHeap(), 0, pdev->brush_dib.height * pdev->brush_dib.stride );
1310 pdev->brush_dib.bits = pdev->brush_dib.ptr_to_free;
1311
1312 rect.left = rect.top = 0;
1313 rect.right = orig_dib.width;
1314 rect.bottom = orig_dib.height;
1315
1316 if(pdev->brush_dib.funcs->convert_to(&pdev->brush_dib, &orig_dib, &rect))
1317 {
1318 pdev->brush_rects = pattern_brush;
1319 pdev->defer &= ~DEFER_BRUSH;
1320 }
1321 else
1322 free_dib_info(&pdev->brush_dib);
1323 free_dib_info(&orig_dib);
1324 }
1325 GlobalUnlock((HGLOBAL)logbrush.lbHatch);
1326 break;
1327 }
1328
1329 case BS_HATCHED:
1330 {
1331 if(logbrush.lbHatch > HS_DIAGCROSS) return 0;
1332 pdev->brush_hatch = logbrush.lbHatch;
1333 pdev->brush_colorref = logbrush.lbColor;
1334 pdev->brush_color = get_fg_color( pdev, pdev->brush_colorref );
1335 calc_and_xor_masks(GetROP2(dev->hdc), pdev->brush_color, &pdev->brush_and, &pdev->brush_xor);
1336 pdev->brush_rects = pattern_brush;
1337 pdev->defer &= ~DEFER_BRUSH;
1338 break;
1339 }
1340
1341 default:
1342 break;
1343 }
1344
1345 return next->funcs->pSelectBrush( next, hbrush );
1346 }
1347
1348 /***********************************************************************
1349 * dibdrv_SetDCBrushColor
1350 */
1351 COLORREF dibdrv_SetDCBrushColor( PHYSDEV dev, COLORREF color )
1352 {
1353 PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetDCBrushColor );
1354 dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
1355
1356 if (GetCurrentObject(dev->hdc, OBJ_BRUSH) == GetStockObject( DC_BRUSH ))
1357 {
1358 pdev->brush_colorref = color;
1359 pdev->brush_color = get_fg_color( pdev, pdev->brush_colorref );
1360 calc_and_xor_masks(GetROP2(dev->hdc), pdev->brush_color, &pdev->brush_and, &pdev->brush_xor);
1361 }
1362
1363 return next->funcs->pSetDCBrushColor( next, color );
1364 }
Maarten's multimedia branch