projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[USER32][WIN32K] Make antialiased disabled font readable. Patch by Katayama Hirofumi...
[reactos.git] / reactos / win32ss / user / user32 / windows / draw.c
1 /*
2 * ReactOS User32 Library
3 * - Various drawing functions
4 *
5 * Copyright 2001 Casper S. Hournstroup
6 * Copyright 2003 Andrew Greenwood
7 * Copyright 2003 Filip Navara
8 * Copyright 2009 Matthias Kupfer
9 * Copyright 2017 Katayama Hirofumi MZ
10 *
11 * Based on Wine code.
12 *
13 * Copyright 1993, 1994 Alexandre Julliard
14 * Copyright 2002 Bill Medland
15 *
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 */
30
31 /* INCLUDES *******************************************************************/
32
33 #include <user32.h>
34
35 #include <wine/debug.h>
36
37 WINE_DEFAULT_DEBUG_CHANNEL(user32);
38
39 /* GLOBALS *******************************************************************/
40
41 /* These tables are used in:
42 * UITOOLS_DrawDiagEdge()
43 * UITOOLS_DrawRectEdge()
44 */
45 static const signed char LTInnerNormal[] = {
46 -1, -1, -1, -1,
47 -1, COLOR_BTNHIGHLIGHT, COLOR_BTNHIGHLIGHT, -1,
48 -1, COLOR_3DDKSHADOW, COLOR_3DDKSHADOW, -1,
49 -1, -1, -1, -1
50 };
51
52 static const signed char LTOuterNormal[] = {
53 -1, COLOR_3DLIGHT, COLOR_BTNSHADOW, -1,
54 COLOR_BTNHIGHLIGHT, COLOR_3DLIGHT, COLOR_BTNSHADOW, -1,
55 COLOR_3DDKSHADOW, COLOR_3DLIGHT, COLOR_BTNSHADOW, -1,
56 -1, COLOR_3DLIGHT, COLOR_BTNSHADOW, -1
57 };
58
59 static const signed char RBInnerNormal[] = {
60 -1, -1, -1, -1,
61 -1, COLOR_BTNSHADOW, COLOR_BTNSHADOW, -1,
62 -1, COLOR_3DLIGHT, COLOR_3DLIGHT, -1,
63 -1, -1, -1, -1
64 };
65
66 static const signed char RBOuterNormal[] = {
67 -1, COLOR_3DDKSHADOW, COLOR_BTNHIGHLIGHT, -1,
68 COLOR_BTNSHADOW, COLOR_3DDKSHADOW, COLOR_BTNHIGHLIGHT, -1,
69 COLOR_3DLIGHT, COLOR_3DDKSHADOW, COLOR_BTNHIGHLIGHT, -1,
70 -1, COLOR_3DDKSHADOW, COLOR_BTNHIGHLIGHT, -1
71 };
72
73 static const signed char LTInnerSoft[] = {
74 -1, -1, -1, -1,
75 -1, COLOR_3DLIGHT, COLOR_3DLIGHT, -1,
76 -1, COLOR_BTNSHADOW, COLOR_BTNSHADOW, -1,
77 -1, -1, -1, -1
78 };
79
80 static const signed char LTOuterSoft[] = {
81 -1, COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1,
82 COLOR_3DLIGHT, COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1,
83 COLOR_BTNSHADOW, COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1,
84 -1, COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1
85 };
86
87 #define RBInnerSoft RBInnerNormal /* These are the same */
88 #define RBOuterSoft RBOuterNormal
89
90 static const signed char LTRBOuterMono[] = {
91 -1, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
92 COLOR_WINDOW, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
93 COLOR_WINDOW, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
94 COLOR_WINDOW, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
95 };
96
97 static const signed char LTRBInnerMono[] = {
98 -1, -1, -1, -1,
99 -1, COLOR_WINDOW, COLOR_WINDOW, COLOR_WINDOW,
100 -1, COLOR_WINDOW, COLOR_WINDOW, COLOR_WINDOW,
101 -1, COLOR_WINDOW, COLOR_WINDOW, COLOR_WINDOW,
102 };
103
104 static const signed char LTRBOuterFlat[] = {
105 -1, COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
106 COLOR_BTNFACE, COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
107 COLOR_BTNFACE, COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
108 COLOR_BTNFACE, COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
109 };
110
111 static const signed char LTRBInnerFlat[] = {
112 -1, -1, -1, -1,
113 -1, COLOR_BTNFACE, COLOR_BTNFACE, COLOR_BTNFACE,
114 -1, COLOR_BTNFACE, COLOR_BTNFACE, COLOR_BTNFACE,
115 -1, COLOR_BTNFACE, COLOR_BTNFACE, COLOR_BTNFACE,
116 };
117 /* FUNCTIONS *****************************************************************/
118
119
120 HBRUSH WINAPI GetSysColorBrush(int nIndex);
121
122 /* Ported from WINE20020904 */
123 /* Same as DrawEdge invoked with BF_DIAGONAL */
124 static BOOL IntDrawDiagEdge(HDC hdc, LPRECT rc, UINT uType, UINT uFlags)
125 {
126 POINT Points[4];
127 signed char InnerI, OuterI;
128 HPEN InnerPen, OuterPen;
129 POINT SavePoint;
130 HPEN SavePen;
131 int spx, spy;
132 int epx, epy;
133 int Width = rc->right - rc->left;
134 int Height= rc->bottom - rc->top;
135 int SmallDiam = Width > Height ? Height : Width;
136 BOOL retval = !( ((uType & BDR_INNER) == BDR_INNER
137 || (uType & BDR_OUTER) == BDR_OUTER)
138 && !(uFlags & (BF_FLAT|BF_MONO)) );
139 int add = (LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0)
140 + (LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0);
141
142 /* Init some vars */
143 OuterPen = InnerPen = (HPEN)GetStockObject(NULL_PEN);
144 SavePen = (HPEN)SelectObject(hdc, InnerPen);
145 spx = spy = epx = epy = 0; /* Satisfy the compiler... */
146
147 /* Determine the colors of the edges */
148 if(uFlags & BF_MONO)
149 {
150 InnerI = LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)];
151 OuterI = LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)];
152 }
153 else if(uFlags & BF_FLAT)
154 {
155 InnerI = LTRBInnerFlat[uType & (BDR_INNER|BDR_OUTER)];
156 OuterI = LTRBOuterFlat[uType & (BDR_INNER|BDR_OUTER)];
157 }
158 else if(uFlags & BF_SOFT)
159 {
160 if(uFlags & BF_BOTTOM)
161 {
162 InnerI = RBInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
163 OuterI = RBOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
164 }
165 else
166 {
167 InnerI = LTInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
168 OuterI = LTOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
169 }
170 }
171 else
172 {
173 if(uFlags & BF_BOTTOM)
174 {
175 InnerI = RBInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
176 OuterI = RBOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
177 }
178 else
179 {
180 InnerI = LTInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
181 OuterI = LTOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
182 }
183 }
184
185 if(InnerI != -1) InnerPen = GetStockObject(DC_PEN);
186 if(OuterI != -1) OuterPen = GetStockObject(DC_PEN);
187
188 MoveToEx(hdc, 0, 0, &SavePoint);
189
190 /* Don't ask me why, but this is what is visible... */
191 /* This must be possible to do much simpler, but I fail to */
192 /* see the logic in the MS implementation (sigh...). */
193 /* So, this might look a bit brute force here (and it is), but */
194 /* it gets the job done;) */
195
196 switch(uFlags & BF_RECT)
197 {
198 case 0:
199 case BF_LEFT:
200 case BF_BOTTOM:
201 case BF_BOTTOMLEFT:
202 /* Left bottom endpoint */
203 epx = rc->left-1;
204 spx = epx + SmallDiam;
205 epy = rc->bottom;
206 spy = epy - SmallDiam;
207 break;
208
209 case BF_TOPLEFT:
210 case BF_BOTTOMRIGHT:
211 /* Left top endpoint */
212 epx = rc->left-1;
213 spx = epx + SmallDiam;
214 epy = rc->top-1;
215 spy = epy + SmallDiam;
216 break;
217
218 case BF_TOP:
219 case BF_RIGHT:
220 case BF_TOPRIGHT:
221 case BF_RIGHT|BF_LEFT:
222 case BF_RIGHT|BF_LEFT|BF_TOP:
223 case BF_BOTTOM|BF_TOP:
224 case BF_BOTTOM|BF_TOP|BF_LEFT:
225 case BF_BOTTOMRIGHT|BF_LEFT:
226 case BF_BOTTOMRIGHT|BF_TOP:
227 case BF_RECT:
228 /* Right top endpoint */
229 spx = rc->left;
230 epx = spx + SmallDiam;
231 spy = rc->bottom-1;
232 epy = spy - SmallDiam;
233 break;
234 }
235
236 MoveToEx(hdc, spx, spy, NULL);
237 SelectObject(hdc, OuterPen);
238 SetDCPenColor(hdc, GetSysColor(OuterI));
239 LineTo(hdc, epx, epy);
240
241 SelectObject(hdc, InnerPen);
242 SetDCPenColor(hdc, GetSysColor(InnerI));
243
244 switch(uFlags & (BF_RECT|BF_DIAGONAL))
245 {
246 case BF_DIAGONAL_ENDBOTTOMLEFT:
247 case (BF_DIAGONAL|BF_BOTTOM):
248 case BF_DIAGONAL:
249 case (BF_DIAGONAL|BF_LEFT):
250 MoveToEx(hdc, spx-1, spy, NULL);
251 LineTo(hdc, epx, epy-1);
252 Points[0].x = spx-add;
253 Points[0].y = spy;
254 Points[1].x = rc->left;
255 Points[1].y = rc->top;
256 Points[2].x = epx+1;
257 Points[2].y = epy-1-add;
258 Points[3] = Points[2];
259 break;
260
261 case BF_DIAGONAL_ENDBOTTOMRIGHT:
262 MoveToEx(hdc, spx-1, spy, NULL);
263 LineTo(hdc, epx, epy+1);
264 Points[0].x = spx-add;
265 Points[0].y = spy;
266 Points[1].x = rc->left;
267 Points[1].y = rc->bottom-1;
268 Points[2].x = epx+1;
269 Points[2].y = epy+1+add;
270 Points[3] = Points[2];
271 break;
272
273 case (BF_DIAGONAL|BF_BOTTOM|BF_RIGHT|BF_TOP):
274 case (BF_DIAGONAL|BF_BOTTOM|BF_RIGHT|BF_TOP|BF_LEFT):
275 case BF_DIAGONAL_ENDTOPRIGHT:
276 case (BF_DIAGONAL|BF_RIGHT|BF_TOP|BF_LEFT):
277 MoveToEx(hdc, spx+1, spy, NULL);
278 LineTo(hdc, epx, epy+1);
279 Points[0].x = epx-1;
280 Points[0].y = epy+1+add;
281 Points[1].x = rc->right-1;
282 Points[1].y = rc->top+add;
283 Points[2].x = rc->right-1;
284 Points[2].y = rc->bottom-1;
285 Points[3].x = spx+add;
286 Points[3].y = spy;
287 break;
288
289 case BF_DIAGONAL_ENDTOPLEFT:
290 MoveToEx(hdc, spx, spy-1, NULL);
291 LineTo(hdc, epx+1, epy);
292 Points[0].x = epx+1+add;
293 Points[0].y = epy+1;
294 Points[1].x = rc->right-1;
295 Points[1].y = rc->top;
296 Points[2].x = rc->right-1;
297 Points[2].y = rc->bottom-1-add;
298 Points[3].x = spx;
299 Points[3].y = spy-add;
300 break;
301
302 case (BF_DIAGONAL|BF_TOP):
303 case (BF_DIAGONAL|BF_BOTTOM|BF_TOP):
304 case (BF_DIAGONAL|BF_BOTTOM|BF_TOP|BF_LEFT):
305 MoveToEx(hdc, spx+1, spy-1, NULL);
306 LineTo(hdc, epx, epy);
307 Points[0].x = epx-1;
308 Points[0].y = epy+1;
309 Points[1].x = rc->right-1;
310 Points[1].y = rc->top;
311 Points[2].x = rc->right-1;
312 Points[2].y = rc->bottom-1-add;
313 Points[3].x = spx+add;
314 Points[3].y = spy-add;
315 break;
316
317 case (BF_DIAGONAL|BF_RIGHT):
318 case (BF_DIAGONAL|BF_RIGHT|BF_LEFT):
319 case (BF_DIAGONAL|BF_RIGHT|BF_LEFT|BF_BOTTOM):
320 MoveToEx(hdc, spx, spy, NULL);
321 LineTo(hdc, epx-1, epy+1);
322 Points[0].x = spx;
323 Points[0].y = spy;
324 Points[1].x = rc->left;
325 Points[1].y = rc->top+add;
326 Points[2].x = epx-1-add;
327 Points[2].y = epy+1+add;
328 Points[3] = Points[2];
329 break;
330 }
331
332 /* Fill the interior if asked */
333 if((uFlags & BF_MIDDLE) && retval)
334 {
335 HBRUSH hbsave;
336 HPEN hpsave;
337 hbsave = (HBRUSH)SelectObject(hdc, GetStockObject(DC_BRUSH));
338 hpsave = (HPEN)SelectObject(hdc, GetStockObject(DC_PEN));
339 SetDCBrushColor(hdc, GetSysColor(uFlags & BF_MONO ? COLOR_WINDOW : COLOR_BTNFACE));
340 SetDCPenColor(hdc, GetSysColor(uFlags & BF_MONO ? COLOR_WINDOW : COLOR_BTNFACE));
341 Polygon(hdc, Points, 4);
342 SelectObject(hdc, hbsave);
343 SelectObject(hdc, hpsave);
344 }
345
346 /* Adjust rectangle if asked */
347 if(uFlags & BF_ADJUST)
348 {
349 if(uFlags & BF_LEFT) rc->left += add;
350 if(uFlags & BF_RIGHT) rc->right -= add;
351 if(uFlags & BF_TOP) rc->top += add;
352 if(uFlags & BF_BOTTOM) rc->bottom -= add;
353 }
354
355 /* Cleanup */
356 SelectObject(hdc, SavePen);
357 MoveToEx(hdc, SavePoint.x, SavePoint.y, NULL);
358
359 return retval;
360 }
361
362 /* Ported from WINE20020904 */
363 /* Same as DrawEdge invoked without BF_DIAGONAL
364 *
365 * 23-Nov-1997: Changed by Bertho Stultiens
366 * The width parameter sets the width of each outer and inner edge.
367 *
368 * Well, I started testing this and found out that there are a few things
369 * that weren't quite as win95. The following rewrite should reproduce
370 * win95 results completely.
371 * The colorselection is table-driven to avoid awfull if-statements.
372 * The table below show the color settings.
373 *
374 * Pen selection table for uFlags = 0
375 *
376 * uType | LTI | LTO | RBI | RBO
377 * ------+-------+-------+-------+-------
378 * 0000 | x | x | x | x
379 * 0001 | x | 22 | x | 21
380 * 0010 | x | 16 | x | 20
381 * 0011 | x | x | x | x
382 * ------+-------+-------+-------+-------
383 * 0100 | x | 20 | x | 16
384 * 0101 | 20 | 22 | 16 | 21
385 * 0110 | 20 | 16 | 16 | 20
386 * 0111 | x | x | x | x
387 * ------+-------+-------+-------+-------
388 * 1000 | x | 21 | x | 22
389 * 1001 | 21 | 22 | 22 | 21
390 * 1010 | 21 | 16 | 22 | 20
391 * 1011 | x | x | x | x
392 * ------+-------+-------+-------+-------
393 * 1100 | x | x | x | x
394 * 1101 | x | x (22)| x | x (21)
395 * 1110 | x | x (16)| x | x (20)
396 * 1111 | x | x | x | x
397 *
398 * Pen selection table for uFlags = BF_SOFT
399 *
400 * uType | LTI | LTO | RBI | RBO
401 * ------+-------+-------+-------+-------
402 * 0000 | x | x | x | x
403 * 0001 | x | 20 | x | 21
404 * 0010 | x | 21 | x | 20
405 * 0011 | x | x | x | x
406 * ------+-------+-------+-------+-------
407 * 0100 | x | 22 | x | 16
408 * 0101 | 22 | 20 | 16 | 21
409 * 0110 | 22 | 21 | 16 | 20
410 * 0111 | x | x | x | x
411 * ------+-------+-------+-------+-------
412 * 1000 | x | 16 | x | 22
413 * 1001 | 16 | 20 | 22 | 21
414 * 1010 | 16 | 21 | 22 | 20
415 * 1011 | x | x | x | x
416 * ------+-------+-------+-------+-------
417 * 1100 | x | x | x | x
418 * 1101 | x | x (20)| x | x (21)
419 * 1110 | x | x (21)| x | x (20)
420 * 1111 | x | x | x | x
421 *
422 * x = don't care; (n) = is what win95 actually uses
423 * LTI = left Top Inner line
424 * LTO = left Top Outer line
425 * RBI = Right Bottom Inner line
426 * RBO = Right Bottom Outer line
427 * 15 = COLOR_BTNFACE
428 * 16 = COLOR_BTNSHADOW
429 * 20 = COLOR_BTNHIGHLIGHT
430 * 21 = COLOR_3DDKSHADOW
431 * 22 = COLOR_3DLIGHT
432 */
433 static BOOL IntDrawRectEdge(HDC hdc, LPRECT rc, UINT uType, UINT uFlags, UINT width)
434 {
435 signed char LTInnerI, LTOuterI;
436 signed char RBInnerI, RBOuterI;
437 HBRUSH lti_brush, lto_brush, rbi_brush, rbo_brush;
438 RECT InnerRect = *rc, fill_rect;
439 int lbi_offset = 0, lti_offset = 0, rti_offset = 0, rbi_offset = 0;
440 BOOL retval = !( ((uType & BDR_INNER) == BDR_INNER
441 || (uType & BDR_OUTER) == BDR_OUTER)
442 && !(uFlags & (BF_FLAT|BF_MONO)) );
443
444 lti_brush = lto_brush = rbi_brush = rbo_brush = GetStockObject(NULL_BRUSH);
445
446 /* Determine the colors of the edges */
447 if(uFlags & BF_MONO)
448 {
449 LTInnerI = RBInnerI = LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)];
450 LTOuterI = RBOuterI = LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)];
451 }
452 else if(uFlags & BF_FLAT)
453 {
454 LTInnerI = RBInnerI = LTRBInnerFlat[uType & (BDR_INNER|BDR_OUTER)];
455 LTOuterI = RBOuterI = LTRBOuterFlat[uType & (BDR_INNER|BDR_OUTER)];
456
457 /* Bertho Stultiens states above that this function exactly matches win95
458 * In win98 BF_FLAT rectangles have an inner border same color as the
459 * middle (COLOR_BTNFACE). I believe it's the same for win95 but since
460 * I don't know I go with Bertho and just sets it for win98 until proven
461 * otherwise.
462 * Dennis Björklund, 10 June, 99
463 */
464 if( LTInnerI != -1 ) LTInnerI = RBInnerI = COLOR_BTNFACE;
465 }
466 else if(uFlags & BF_SOFT)
467 {
468 LTInnerI = LTInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
469 LTOuterI = LTOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
470 RBInnerI = RBInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
471 RBOuterI = RBOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
472 }
473 else
474 {
475 LTInnerI = LTInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
476 LTOuterI = LTOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
477 RBInnerI = RBInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
478 RBOuterI = RBOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
479 }
480
481 if((uFlags & BF_BOTTOMLEFT) == BF_BOTTOMLEFT) lbi_offset = width;
482 if((uFlags & BF_TOPRIGHT) == BF_TOPRIGHT) rti_offset = width;
483 if((uFlags & BF_BOTTOMRIGHT) == BF_BOTTOMRIGHT) rbi_offset = width;
484 if((uFlags & BF_TOPLEFT) == BF_TOPLEFT) lti_offset = width;
485
486 if(LTInnerI != -1) lti_brush = GetSysColorBrush(LTInnerI);
487 if(LTOuterI != -1) lto_brush = GetSysColorBrush(LTOuterI);
488 if(RBInnerI != -1) rbi_brush = GetSysColorBrush(RBInnerI);
489 if(RBOuterI != -1) rbo_brush = GetSysColorBrush(RBOuterI);
490
491 /* Draw the outer edge */
492 if(uFlags & BF_TOP)
493 {
494 fill_rect = InnerRect;
495 fill_rect.bottom = fill_rect.top + width;
496 FillRect( hdc, &fill_rect, lto_brush );
497 }
498 if(uFlags & BF_LEFT)
499 {
500 fill_rect = InnerRect;
501 fill_rect.right = fill_rect.left + width;
502 FillRect( hdc, &fill_rect, lto_brush );
503 }
504 if(uFlags & BF_BOTTOM)
505 {
506 fill_rect = InnerRect;
507 fill_rect.top = fill_rect.bottom - width;
508 FillRect( hdc, &fill_rect, rbo_brush );
509 }
510 if(uFlags & BF_RIGHT)
511 {
512 fill_rect = InnerRect;
513 fill_rect.left = fill_rect.right - width;
514 FillRect( hdc, &fill_rect, rbo_brush );
515 }
516
517 /* Draw the inner edge */
518 if(uFlags & BF_TOP)
519 {
520 SetRect( &fill_rect, InnerRect.left + lti_offset, InnerRect.top + width,
521 InnerRect.right - rti_offset, InnerRect.top + 2 * width );
522 FillRect( hdc, &fill_rect, lti_brush );
523 }
524 if(uFlags & BF_LEFT)
525 {
526 SetRect( &fill_rect, InnerRect.left + width, InnerRect.top + lti_offset,
527 InnerRect.left + 2 * width, InnerRect.bottom - lbi_offset );
528 FillRect( hdc, &fill_rect, lti_brush );
529 }
530 if(uFlags & BF_BOTTOM)
531 {
532 SetRect( &fill_rect, InnerRect.left + lbi_offset, InnerRect.bottom - 2 * width,
533 InnerRect.right - rbi_offset, InnerRect.bottom - width );
534 FillRect( hdc, &fill_rect, rbi_brush );
535 }
536 if(uFlags & BF_RIGHT)
537 {
538 SetRect( &fill_rect, InnerRect.right - 2 * width, InnerRect.top + rti_offset,
539 InnerRect.right - width, InnerRect.bottom - rbi_offset );
540 FillRect( hdc, &fill_rect, rbi_brush );
541 }
542
543 if( ((uFlags & BF_MIDDLE) && retval) || (uFlags & BF_ADJUST) )
544 {
545 int add = (LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? width : 0)
546 + (LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? width : 0);
547
548 if(uFlags & BF_LEFT) InnerRect.left += add;
549 if(uFlags & BF_RIGHT) InnerRect.right -= add;
550 if(uFlags & BF_TOP) InnerRect.top += add;
551 if(uFlags & BF_BOTTOM) InnerRect.bottom -= add;
552
553 if((uFlags & BF_MIDDLE) && retval)
554 {
555 FillRect(hdc, &InnerRect, GetSysColorBrush(uFlags & BF_MONO ?
556 COLOR_WINDOW : COLOR_BTNFACE));
557 }
558
559 if(uFlags & BF_ADJUST)
560 *rc = InnerRect;
561 }
562
563 return retval;
564 }
565
566 /* Ported from WINE20020904 */
567 /* Utility to create a square rectangle and returning the width */
568 static int UITOOLS_MakeSquareRect(LPRECT src, LPRECT dst)
569 {
570 int Width = src->right - src->left;
571 int Height = src->bottom - src->top;
572 int SmallDiam = Width > Height ? Height : Width;
573
574 *dst = *src;
575
576 /* Make it a square box */
577 if(Width < Height) /* SmallDiam == Width */
578 {
579 dst->top += (Height-Width)/2;
580 dst->bottom = dst->top + SmallDiam;
581 }
582 else if(Width > Height) /* SmallDiam == Height */
583 {
584 dst->left += (Width-Height)/2;
585 dst->right = dst->left + SmallDiam;
586 }
587
588 return SmallDiam;
589 }
590
591 /* Ported from WINE20020904 */
592 static void UITOOLS_DrawCheckedRect( HDC dc, LPRECT rect )
593 {
594 if(GetSysColor(COLOR_BTNHIGHLIGHT) == RGB(255, 255, 255))
595 {
596 HBRUSH hbsave;
597 COLORREF bg;
598
599 FillRect(dc, rect, GetSysColorBrush(COLOR_BTNFACE));
600 bg = SetBkColor(dc, RGB(255, 255, 255));
601 hbsave = (HBRUSH)SelectObject(dc, gpsi->hbrGray);
602 PatBlt(dc, rect->left, rect->top, rect->right-rect->left, rect->bottom-rect->top, 0x00FA0089);
603 SelectObject(dc, hbsave);
604 SetBkColor(dc, bg);
605 }
606 else
607 {
608 FillRect(dc, rect, GetSysColorBrush(COLOR_BTNHIGHLIGHT));
609 }
610 }
611
612 /* Ported from WINE20020904 */
613 /* Draw a push button coming from DrawFrameControl()
614 *
615 * Does a pretty good job in emulating MS behavior. Some quirks are
616 * however there because MS uses a TrueType font (Marlett) to draw
617 * the buttons.
618 *
619 * FIXME: This looks a little bit strange, needs to be rewritten completely
620 * (several quirks with adjust, DFCS_CHECKED aso)
621 */
622 static BOOL UITOOLS95_DFC_ButtonPush(HDC dc, LPRECT r, UINT uFlags)
623 {
624 UINT edge;
625 RECT myr = *r;
626
627 if(uFlags & (DFCS_PUSHED | DFCS_CHECKED | DFCS_FLAT))
628 edge = EDGE_SUNKEN;
629 else
630 edge = EDGE_RAISED;
631
632 if(uFlags & DFCS_CHECKED)
633 {
634 if(uFlags & DFCS_MONO)
635 IntDrawRectEdge(dc, &myr, edge, BF_MONO|BF_RECT|BF_ADJUST, 1);
636 else
637 IntDrawRectEdge(dc, &myr, edge, (uFlags&DFCS_FLAT)|BF_RECT|BF_SOFT|BF_ADJUST, 1);
638
639 UITOOLS_DrawCheckedRect( dc, &myr );
640 }
641 else
642 {
643 if(uFlags & DFCS_MONO)
644 {
645 IntDrawRectEdge(dc, &myr, edge, BF_MONO|BF_RECT|BF_ADJUST, 1);
646 FillRect(dc, &myr, GetSysColorBrush(COLOR_BTNFACE));
647 }
648 else
649 {
650 IntDrawRectEdge(dc, r, edge, (uFlags&DFCS_FLAT) | BF_MIDDLE | BF_RECT | BF_SOFT, 1);
651 }
652 }
653
654 /* Adjust rectangle if asked */
655 if(uFlags & DFCS_ADJUSTRECT)
656 InflateRect(r, -2, -2);
657
658 return TRUE;
659 }
660
661 static BOOL UITOOLS95_DFC_ButtonCheckRadio(HDC dc, LPRECT r, UINT uFlags, BOOL Radio)
662 {
663 LOGFONTW lf;
664 HFONT hFont, hOldFont;
665 int i;
666 TCHAR OutRight, OutLeft, InRight, InLeft, Center;
667 INT X, Y, Width, Height, Shorter;
668 INT BkMode = GetBkMode(dc);
669 COLORREF TextColor = GetTextColor(dc);
670
671 Width = r->right - r->left;
672 Height = r->bottom - r->top;
673 Shorter = (Width < Height) ? Width : Height;
674 X = r->left + (Width - Shorter) / 2;
675 Y = r->top + (Height - Shorter) / 2;
676
677 if (Radio)
678 {
679 OutRight = 'j'; // Outer right
680 OutLeft = 'k'; // Outer left
681 InRight = 'l'; // inner left
682 InLeft = 'm'; // inner right
683 Center = 'n'; // center
684 }
685 else
686 {
687 OutRight = 'c'; // Outer right
688 OutLeft = 'd'; // Outer left
689 InRight = 'e'; // inner left
690 InLeft = 'f'; // inner right
691 Center = 'g'; // center
692 }
693
694 ZeroMemory(&lf, sizeof(LOGFONTW));
695 lf.lfHeight = Shorter;
696 lf.lfCharSet = DEFAULT_CHARSET;
697 lstrcpy(lf.lfFaceName, TEXT("Marlett"));
698 if (Radio && ((uFlags & 0xFF) == DFCS_BUTTONRADIOMASK))
699 {
700 lf.lfQuality = NONANTIALIASED_QUALITY;
701 }
702 hFont = CreateFontIndirect(&lf);
703 hOldFont = SelectObject(dc, hFont);
704
705 if (Radio && ((uFlags & 0xFF) == DFCS_BUTTONRADIOMASK))
706 {
707 #if 1
708 // FIXME: improve font rendering
709 RECT Rect;
710 HGDIOBJ hbrOld, hpenOld;
711 FillRect(dc, r, (HBRUSH)GetStockObject(WHITE_BRUSH));
712 SetRect(&Rect, X, Y, X + Shorter, Y + Shorter);
713 InflateRect(&Rect, -(Shorter * 8) / 54, -(Shorter * 8) / 54);
714 hbrOld = SelectObject(dc, GetStockObject(BLACK_BRUSH));
715 hpenOld = SelectObject(dc, GetStockObject(NULL_PEN));
716 Ellipse(dc, Rect.left, Rect.top, Rect.right, Rect.bottom);
717 SelectObject(dc, hbrOld);
718 SelectObject(dc, hpenOld);
719 #else
720 SetBkMode(dc, OPAQUE);
721 SetBkColor(dc, RGB(255, 255, 255));
722 SetTextColor(dc, RGB(0, 0, 0));
723 TextOut(dc, X, Y, &Center, 1);
724 SetBkMode(dc, TRANSPARENT);
725 TextOut(dc, X, Y, &OutRight, 1);
726 TextOut(dc, X, Y, &OutLeft, 1);
727 TextOut(dc, X, Y, &InRight, 1);
728 TextOut(dc, X, Y, &InLeft, 1);
729 #endif
730 }
731 else
732 {
733 SetBkMode(dc, TRANSPARENT);
734
735 /* Center section, white for active, grey for inactive */
736 if ((uFlags & (DFCS_INACTIVE | DFCS_PUSHED)))
737 i = COLOR_BTNFACE;
738 else
739 i = COLOR_WINDOW;
740 SetTextColor(dc, GetSysColor(i));
741 TextOut(dc, X, Y, &Center, 1);
742
743 if (uFlags & (DFCS_FLAT | DFCS_MONO))
744 {
745 SetTextColor(dc, GetSysColor(COLOR_WINDOWFRAME));
746 TextOut(dc, X, Y, &OutRight, 1);
747 TextOut(dc, X, Y, &OutLeft, 1);
748 TextOut(dc, X, Y, &InRight, 1);
749 TextOut(dc, X, Y, &InLeft, 1);
750 }
751 else
752 {
753 SetTextColor(dc, GetSysColor(COLOR_BTNSHADOW));
754 TextOut(dc, X, Y, &OutRight, 1);
755 SetTextColor(dc, GetSysColor(COLOR_BTNHIGHLIGHT));
756 TextOut(dc, X, Y, &OutLeft, 1);
757 SetTextColor(dc, GetSysColor(COLOR_3DDKSHADOW));
758 TextOut(dc, X, Y, &InRight, 1);
759 SetTextColor(dc, GetSysColor(COLOR_3DLIGHT));
760 TextOut(dc, X, Y, &InLeft, 1);
761 }
762
763 if (uFlags & DFCS_CHECKED)
764 {
765 TCHAR Check = (Radio) ? 'i' : 'b';
766
767 SetTextColor(dc, GetSysColor(COLOR_WINDOWTEXT));
768 TextOut(dc, X, Y, &Check, 1);
769 }
770 }
771
772 SelectObject(dc, hOldFont);
773 DeleteObject(hFont);
774
775 SetTextColor(dc, TextColor);
776 SetBkMode(dc, BkMode);
777
778 return TRUE;
779 }
780
781 /* Ported from WINE20020904 */
782 static BOOL UITOOLS95_DrawFrameButton(HDC hdc, LPRECT rc, UINT uState)
783 {
784 switch(uState & 0xff)
785 {
786 case DFCS_BUTTONPUSH:
787 return UITOOLS95_DFC_ButtonPush(hdc, rc, uState);
788
789 case DFCS_BUTTONCHECK:
790 case DFCS_BUTTON3STATE:
791 return UITOOLS95_DFC_ButtonCheckRadio(hdc, rc, uState, FALSE);
792
793 case DFCS_BUTTONRADIOIMAGE:
794 case DFCS_BUTTONRADIOMASK:
795 case DFCS_BUTTONRADIO:
796 return UITOOLS95_DFC_ButtonCheckRadio(hdc, rc, uState, TRUE);
797
798 /*
799 default:
800 DbgPrint("Invalid button state=0x%04x\n", uState);
801 */
802 }
803
804 return FALSE;
805 }
806
807 static BOOL UITOOLS95_DrawFrameCaption(HDC dc, LPRECT r, UINT uFlags)
808 {
809 LOGFONTW lf;
810 HFONT hFont, hOldFont;
811 COLORREF clrsave;
812 RECT myr;
813 INT bkmode;
814 TCHAR Symbol;
815 switch(uFlags & 0xff)
816 {
817 case DFCS_CAPTIONCLOSE:
818 Symbol = 'r';
819 break;
820 case DFCS_CAPTIONHELP:
821 Symbol = 's';
822 break;
823 case DFCS_CAPTIONMIN:
824 Symbol = '0';
825 break;
826 case DFCS_CAPTIONMAX:
827 Symbol = '1';
828 break;
829 case DFCS_CAPTIONRESTORE:
830 Symbol = '2';
831 break;
832 default:
833 WARN("Invalid caption; flags=0x%04x\n", uFlags);
834 return FALSE;
835 }
836 IntDrawRectEdge(dc,r,(uFlags&DFCS_PUSHED) ? EDGE_SUNKEN : EDGE_RAISED, BF_RECT | BF_MIDDLE | BF_SOFT, 1);
837 ZeroMemory(&lf, sizeof(LOGFONTW));
838 UITOOLS_MakeSquareRect(r, &myr);
839 myr.left += 1;
840 myr.top += 1;
841 myr.right -= 1;
842 myr.bottom -= 1;
843 if(uFlags & DFCS_PUSHED)
844 OffsetRect(&myr,1,1);
845 lf.lfHeight = myr.bottom - myr.top;
846 lf.lfWidth = 0;
847 lf.lfWeight = FW_NORMAL;
848 lf.lfCharSet = DEFAULT_CHARSET;
849 lstrcpy(lf.lfFaceName, TEXT("Marlett"));
850 hFont = CreateFontIndirect(&lf);
851 /* save font and text color */
852 hOldFont = SelectObject(dc, hFont);
853 clrsave = GetTextColor(dc);
854 bkmode = GetBkMode(dc);
855 /* set color and drawing mode */
856 SetBkMode(dc, TRANSPARENT);
857 if(uFlags & DFCS_INACTIVE)
858 {
859 /* draw shadow */
860 SetTextColor(dc, GetSysColor(COLOR_BTNHIGHLIGHT));
861 TextOut(dc, myr.left + 1, myr.top + 1, &Symbol, 1);
862 }
863 SetTextColor(dc, GetSysColor((uFlags & DFCS_INACTIVE) ? COLOR_BTNSHADOW : COLOR_BTNTEXT));
864 /* draw selected symbol */
865 TextOut(dc, myr.left, myr.top, &Symbol, 1);
866 /* restore previous settings */
867 SetTextColor(dc, clrsave);
868 SelectObject(dc, hOldFont);
869 SetBkMode(dc, bkmode);
870 DeleteObject(hFont);
871 return TRUE;
872 }
873
874 static BOOL UITOOLS95_DrawFrameScroll(HDC dc, LPRECT r, UINT uFlags)
875 {
876 LOGFONTW lf;
877 HFONT hFont, hOldFont;
878 COLORREF clrsave;
879 RECT myr;
880 INT bkmode;
881 TCHAR Symbol;
882 switch(uFlags & 0xff)
883 {
884 case DFCS_SCROLLCOMBOBOX:
885 case DFCS_SCROLLDOWN:
886 Symbol = '6';
887 break;
888
889 case DFCS_SCROLLUP:
890 Symbol = '5';
891 break;
892
893 case DFCS_SCROLLLEFT:
894 Symbol = '3';
895 break;
896
897 case DFCS_SCROLLRIGHT:
898 Symbol = '4';
899 break;
900
901 case DFCS_SCROLLSIZEGRIP:
902 case DFCS_SCROLLSIZEGRIPRIGHT:
903 ZeroMemory(&lf, sizeof(LOGFONTW));
904 UITOOLS_MakeSquareRect(r, &myr);
905 lf.lfHeight = myr.bottom - myr.top;
906 lf.lfWidth = 0;
907 lf.lfWeight = FW_NORMAL;
908 lf.lfCharSet = DEFAULT_CHARSET;
909 lstrcpy(lf.lfFaceName, TEXT("Marlett"));
910 hFont = CreateFontIndirect(&lf);
911 /* save font and text color */
912 hOldFont = SelectObject(dc, hFont);
913 clrsave = GetTextColor(dc);
914 bkmode = GetBkMode(dc);
915 /* set color and drawing mode */
916 SetBkMode(dc, TRANSPARENT);
917 if (!(uFlags & (DFCS_MONO | DFCS_FLAT)))
918 {
919 SetTextColor(dc, GetSysColor(COLOR_BTNHIGHLIGHT));
920 /* draw selected symbol */
921 Symbol = ((uFlags & 0xff) == DFCS_SCROLLSIZEGRIP) ? 'o' : 'x';
922 TextOut(dc, myr.left, myr.top, &Symbol, 1);
923 SetTextColor(dc, GetSysColor(COLOR_BTNSHADOW));
924 } else
925 SetTextColor(dc, GetSysColor(COLOR_WINDOWFRAME));
926 /* draw selected symbol */
927 Symbol = ((uFlags & 0xff) == DFCS_SCROLLSIZEGRIP) ? 'p' : 'y';
928 TextOut(dc, myr.left, myr.top, &Symbol, 1);
929 /* restore previous settings */
930 SetTextColor(dc, clrsave);
931 SelectObject(dc, hOldFont);
932 SetBkMode(dc, bkmode);
933 DeleteObject(hFont);
934 return TRUE;
935 default:
936 WARN("Invalid scroll; flags=0x%04x\n", uFlags);
937 return FALSE;
938 }
939 IntDrawRectEdge(dc, r, (uFlags & DFCS_PUSHED) ? EDGE_SUNKEN : EDGE_RAISED, (uFlags&DFCS_FLAT) | BF_MIDDLE | BF_RECT, 1);
940 ZeroMemory(&lf, sizeof(LOGFONTW));
941 UITOOLS_MakeSquareRect(r, &myr);
942 myr.left += 1;
943 myr.top += 1;
944 myr.right -= 1;
945 myr.bottom -= 1;
946 if(uFlags & DFCS_PUSHED)
947 OffsetRect(&myr,1,1);
948 lf.lfHeight = myr.bottom - myr.top;
949 lf.lfWidth = 0;
950 lf.lfWeight = FW_NORMAL;
951 lf.lfCharSet = DEFAULT_CHARSET;
952 lstrcpy(lf.lfFaceName, TEXT("Marlett"));
953 hFont = CreateFontIndirect(&lf);
954 /* save font and text color */
955 hOldFont = SelectObject(dc, hFont);
956 clrsave = GetTextColor(dc);
957 bkmode = GetBkMode(dc);
958 /* set color and drawing mode */
959 SetBkMode(dc, TRANSPARENT);
960 if(uFlags & DFCS_INACTIVE)
961 {
962 /* draw shadow */
963 SetTextColor(dc, GetSysColor(COLOR_BTNHIGHLIGHT));
964 TextOut(dc, myr.left + 1, myr.top + 1, &Symbol, 1);
965 }
966 SetTextColor(dc, GetSysColor((uFlags & DFCS_INACTIVE) ? COLOR_BTNSHADOW : COLOR_BTNTEXT));
967 /* draw selected symbol */
968 TextOut(dc, myr.left, myr.top, &Symbol, 1);
969 /* restore previous settings */
970 SetTextColor(dc, clrsave);
971 SelectObject(dc, hOldFont);
972 SetBkMode(dc, bkmode);
973 DeleteObject(hFont);
974 return TRUE;
975 }
976
977 static BOOL UITOOLS95_DrawFrameMenu(HDC dc, LPRECT r, UINT uFlags)
978 {
979 LOGFONTW lf;
980 HFONT hFont, hOldFont;
981 TCHAR Symbol;
982 switch(uFlags & 0xff)
983 {
984 case DFCS_MENUARROWUP:
985 Symbol = '5';
986 break;
987
988 case DFCS_MENUARROWDOWN:
989 Symbol = '6';
990 break;
991
992 case DFCS_MENUARROW:
993 Symbol = '8';
994 break;
995
996 case DFCS_MENUARROWRIGHT:
997 Symbol = 'w'; // FIXME: needs to confirm
998 break;
999
1000 case DFCS_MENUBULLET:
1001 Symbol = 'h';
1002 break;
1003
1004 case DFCS_MENUCHECK:
1005 Symbol = 'a';
1006 break;
1007
1008 default:
1009 WARN("Invalid menu; flags=0x%04x\n", uFlags);
1010 return FALSE;
1011 }
1012 /* acquire ressources only if valid menu */
1013 ZeroMemory(&lf, sizeof(LOGFONTW));
1014 lf.lfHeight = r->bottom - r->top;
1015 lf.lfWidth = 0;
1016 lf.lfWeight = FW_NORMAL;
1017 lf.lfCharSet = DEFAULT_CHARSET;
1018 lstrcpy(lf.lfFaceName, TEXT("Marlett"));
1019 hFont = CreateFontIndirect(&lf);
1020 /* save font */
1021 hOldFont = SelectObject(dc, hFont);
1022
1023 if ((uFlags & 0xff) == DFCS_MENUARROWUP ||
1024 (uFlags & 0xff) == DFCS_MENUARROWDOWN )
1025 {
1026 #if 0
1027 if (uFlags & DFCS_INACTIVE)
1028 {
1029 /* draw shadow */
1030 SetTextColor(dc, GetSysColor(COLOR_BTNHIGHLIGHT));
1031 TextOut(dc, r->left + 1, r->top + 1, &Symbol, 1);
1032 }
1033 #endif
1034 SetTextColor(dc, GetSysColor((uFlags & DFCS_INACTIVE) ? COLOR_BTNSHADOW : COLOR_BTNTEXT));
1035 }
1036 /* draw selected symbol */
1037 TextOut(dc, r->left, r->top, &Symbol, 1);
1038 /* restore previous settings */
1039 SelectObject(dc, hOldFont);
1040 DeleteObject(hFont);
1041 return TRUE;
1042 }
1043
1044 BOOL
1045 WINAPI
1046 IntGrayString(
1047 HDC hDC,
1048 HBRUSH hBrush,
1049 GRAYSTRINGPROC lpOutputFunc,
1050 LPARAM lpData,
1051 int nCount,
1052 int X,
1053 int Y,
1054 int nWidth,
1055 int nHeight,
1056 BOOL unicode)
1057 {
1058 // AG: Mostly implemented, but probably won't work properly or return
1059 // correct error codes. I doubt it grays strings either... Untested!
1060
1061 BOOL success = FALSE;
1062 HBRUSH hbsave;
1063 HDC MemDC = NULL;
1064 HBITMAP MemBMP = NULL, OldBMP = NULL;
1065 HBRUSH OldBrush = NULL;
1066 HFONT OldFont = NULL;
1067 RECT r;
1068 COLORREF ForeColor, BackColor;
1069
1070 ForeColor = SetTextColor(hDC, RGB(0, 0, 0));
1071 BackColor = SetBkColor(hDC, RGB(255, 255, 255));
1072
1073 if (! hBrush)
1074 {
1075 // The documentation is a little vague on what exactly should happen
1076 // here. Something about using the same brush for window text???
1077 hBrush = (HBRUSH) GetCurrentObject(hDC, OBJ_BRUSH);
1078 }
1079
1080 if ((nCount == -1) && (! lpOutputFunc))
1081 return FALSE;
1082
1083 if (! nCount)
1084 {
1085 // TODO: calculate the length (easy enough)
1086
1087 if (unicode)
1088 nCount = lstrlenW((WCHAR*)lpData);
1089 else
1090 nCount = lstrlenA((CHAR*)lpData);
1091 }
1092
1093 if (! nWidth || ! nHeight)
1094 {
1095 SIZE s;
1096 // TODO: calculate the rect
1097
1098 if (unicode)
1099 success = GetTextExtentPoint32W(hDC, (WCHAR*) lpData, nCount, &s);
1100 else
1101 success = GetTextExtentPoint32A(hDC, (CHAR*) lpData, nCount, &s);
1102
1103 if (! success) goto cleanup;
1104
1105 if (! nWidth) nWidth = s.cx;
1106 if (! nHeight) nHeight = s.cy;
1107 }
1108
1109 SetRect(&r, X, Y, X + nWidth, Y + nHeight);
1110
1111 MemDC = CreateCompatibleDC(hDC);
1112 if (! MemDC) goto cleanup;
1113 MemBMP = CreateBitmap(nWidth, nHeight, 1, 1, NULL);
1114 if (! MemBMP) goto cleanup;
1115 OldBMP = SelectObject(MemDC, MemBMP);
1116 if (! OldBMP) goto cleanup;
1117 OldFont = SelectObject(MemDC, GetCurrentObject(hDC, OBJ_FONT));
1118 if (! OldFont) goto cleanup;
1119 OldBrush = SelectObject(MemDC, hBrush);
1120 if (! OldBrush) goto cleanup;
1121
1122 if (! BitBlt(MemDC, 0, 0, nWidth, nHeight, hDC, X, Y, SRCCOPY)) goto cleanup;
1123
1124 SetTextColor(MemDC, RGB(255, 255, 255));
1125 SetBkColor(MemDC, RGB(0, 0, 0));
1126
1127 if (lpOutputFunc)
1128 {
1129 success = lpOutputFunc(MemDC, lpData, nCount); // Set brush etc first?
1130
1131 if ((nCount == -1) && (! success))
1132 {
1133 // Don't gray (documented behaviour)
1134 success = (BOOL) BitBlt(hDC, X, Y, nWidth, nHeight, MemDC, 0, 0, SRCCOPY);
1135 goto cleanup;
1136 }
1137 }
1138 else
1139 {
1140 if (unicode)
1141 success = TextOutW(MemDC, 0, 0, (WCHAR*) lpData, nCount);
1142 else
1143 success = TextOutA(MemDC, 0, 0, (CHAR*) lpData, nCount);
1144
1145 if (! success) goto cleanup;
1146
1147 hbsave = (HBRUSH)SelectObject(MemDC, gpsi->hbrGray);
1148 PatBlt(MemDC, 0, 0, nWidth, nHeight, 0x000A0329);
1149 SelectObject(MemDC, hbsave);
1150 }
1151
1152 if (! BitBlt(hDC, X, Y, nWidth, nHeight, MemDC, 0, 0, SRCCOPY)) goto cleanup;
1153
1154 cleanup:
1155 SetTextColor(hDC, ForeColor);
1156 SetBkColor(hDC, BackColor);
1157
1158 if (MemDC)
1159 {
1160 if (OldFont) SelectObject(MemDC, OldFont);
1161 if (OldBrush) SelectObject(MemDC, OldBrush);
1162 if (OldBMP) SelectObject(MemDC, OldBMP);
1163 if (MemBMP) DeleteObject(MemBMP);
1164 DeleteDC(MemDC);
1165 }
1166
1167 return success;
1168 }
1169
1170 /**********************************************************************
1171 * PAINTING_DrawStateJam
1172 *
1173 * Jams in the requested type in the dc
1174 */
1175 static BOOL PAINTING_DrawStateJam(HDC hdc, UINT opcode,
1176 DRAWSTATEPROC func, LPARAM lp, WPARAM wp,
1177 LPRECT rc, UINT dtflags, BOOL unicode )
1178 {
1179 HDC memdc;
1180 HBITMAP hbmsave;
1181 BOOL retval;
1182 INT cx = rc->right - rc->left;
1183 INT cy = rc->bottom - rc->top;
1184
1185 switch(opcode)
1186 {
1187 case DST_TEXT:
1188 case DST_PREFIXTEXT:
1189 if(unicode)
1190 return DrawTextW(hdc, (LPWSTR)lp, (INT)wp, rc, dtflags);
1191 else
1192 return DrawTextA(hdc, (LPSTR)lp, (INT)wp, rc, dtflags);
1193
1194 case DST_ICON:
1195 return DrawIconEx(hdc, rc->left, rc->top, (HICON)lp, cx, cy, 0, NULL, DI_NORMAL);
1196
1197 case DST_BITMAP:
1198 memdc = CreateCompatibleDC(hdc);
1199 if(!memdc)
1200 return FALSE;
1201 hbmsave = (HBITMAP)SelectObject(memdc, (HBITMAP)lp);
1202 if(!hbmsave)
1203 {
1204 DeleteDC(memdc);
1205 return FALSE;
1206 }
1207 retval = BitBlt(hdc, rc->left, rc->top, cx, cy, memdc, 0, 0, SRCCOPY);
1208 SelectObject(memdc, hbmsave);
1209 DeleteDC(memdc);
1210 return retval;
1211
1212 case DST_COMPLEX:
1213 if(func)
1214 {
1215 BOOL bRet;
1216 /* DRAWSTATEPROC assumes that it draws at the center of coordinates */
1217
1218 OffsetViewportOrgEx(hdc, rc->left, rc->top, NULL);
1219 bRet = func(hdc, lp, wp, cx, cy);
1220 /* Restore origin */
1221 OffsetViewportOrgEx(hdc, -rc->left, -rc->top, NULL);
1222 return bRet;
1223 }
1224 else
1225 {
1226 return FALSE;
1227 }
1228 }
1229 return FALSE;
1230 }
1231
1232 static BOOL
1233 IntDrawState(HDC hdc, HBRUSH hbr, DRAWSTATEPROC func, LPARAM lp, WPARAM wp,
1234 INT x, INT y, INT cx, INT cy, UINT flags, BOOL unicode)
1235 {
1236 HBITMAP hbm, hbmsave;
1237 HFONT hfsave;
1238 HBRUSH hbsave, hbrtmp = 0;
1239 HDC memdc;
1240 RECT rc;
1241 UINT dtflags = DT_NOCLIP;
1242 COLORREF fg, bg;
1243 UINT opcode = flags & 0xf;
1244 INT len = wp;
1245 BOOL retval, tmp;
1246 LOGFONTW lf;
1247 HFONT hFontOriginal, hNaaFont = NULL;
1248
1249 if((opcode == DST_TEXT || opcode == DST_PREFIXTEXT) && !len) /* The string is '\0' terminated */
1250 {
1251 if(unicode)
1252 len = lstrlenW((LPWSTR)lp);
1253 else
1254 len = lstrlenA((LPSTR)lp);
1255 }
1256
1257 hFontOriginal = GetCurrentObject(hdc, OBJ_FONT);
1258 if (flags & (DSS_MONO | DSS_DISABLED))
1259 {
1260 /* Create a non-antialiased font */
1261 GetObjectW(hFontOriginal, sizeof(lf), &lf);
1262 lf.lfQuality = NONANTIALIASED_QUALITY;
1263 hNaaFont = CreateFontIndirectW(&lf);
1264 }
1265
1266 /* Find out what size the image has if not given by caller */
1267 if(!cx || !cy)
1268 {
1269 SIZE s;
1270 BITMAP bm;
1271
1272 switch(opcode)
1273 {
1274 case DST_TEXT:
1275 case DST_PREFIXTEXT:
1276 if(unicode)
1277 retval = GetTextExtentPoint32W(hdc, (LPWSTR)lp, len, &s);
1278 else
1279 retval = GetTextExtentPoint32A(hdc, (LPSTR)lp, len, &s);
1280 if(!retval)
1281 return FALSE;
1282 break;
1283
1284 case DST_ICON:
1285 if(!get_icon_size((HICON)lp, &s))
1286 return FALSE;
1287 break;
1288
1289 case DST_BITMAP:
1290 if(!GetObjectW((HBITMAP)lp, sizeof(bm), &bm))
1291 return FALSE;
1292 s.cx = bm.bmWidth;
1293 s.cy = bm.bmHeight;
1294 break;
1295
1296 case DST_COMPLEX: /* cx and cy must be set in this mode */
1297 return FALSE;
1298
1299 default:
1300 ERR("Invalid opcode: %u\n", opcode);
1301 return FALSE;
1302 }
1303
1304 if(!cx) cx = s.cx;
1305 if(!cy) cy = s.cy;
1306 }
1307
1308 SetRect(&rc, x, y, x + cx, y + cy);
1309
1310 if(flags & DSS_RIGHT) /* This one is not documented in the win32.hlp file */
1311 dtflags |= DT_RIGHT;
1312 if(opcode == DST_TEXT)
1313 dtflags |= DT_NOPREFIX;
1314 else if(opcode == DST_PREFIXTEXT)
1315 {
1316 if (flags & DSS_HIDEPREFIX)
1317 dtflags |= DT_HIDEPREFIX;
1318 if (flags & DSS_PREFIXONLY)
1319 dtflags |= DT_PREFIXONLY;
1320 }
1321
1322 /* For DSS_NORMAL we just jam in the image and return */
1323 if((flags & 0x79f0) == DSS_NORMAL)
1324 {
1325 return PAINTING_DrawStateJam(hdc, opcode, func, lp, len, &rc, dtflags, unicode);
1326 }
1327
1328 /* For all other states we need to convert the image to B/W in a local bitmap */
1329 /* before it is displayed */
1330 fg = SetTextColor(hdc, RGB(0, 0, 0));
1331 bg = SetBkColor(hdc, RGB(255, 255, 255));
1332 hbm = NULL; hbmsave = NULL;
1333 memdc = NULL; hbsave = NULL;
1334 retval = FALSE; /* assume failure */
1335
1336 /* From here on we must use "goto cleanup" when something goes wrong */
1337 hbm = CreateBitmap(cx, cy, 1, 1, NULL);
1338 if(!hbm) goto cleanup;
1339 memdc = CreateCompatibleDC(hdc);
1340 if(!memdc) goto cleanup;
1341 hbmsave = (HBITMAP)SelectObject(memdc, hbm);
1342 if(!hbmsave) goto cleanup;
1343 SetRect(&rc, 0, 0, cx, cy);
1344 if(!FillRect(memdc, &rc, (HBRUSH)GetStockObject(WHITE_BRUSH))) goto cleanup;
1345 SetBkColor(memdc, RGB(255, 255, 255));
1346 SetTextColor(memdc, RGB(0, 0, 0));
1347 if (hNaaFont)
1348 hfsave = (HFONT)SelectObject(memdc, hNaaFont);
1349 else
1350 hfsave = (HFONT)SelectObject(memdc, hFontOriginal);
1351 SetLayout( memdc, GetLayout( hdc ));
1352
1353 /* DST_COMPLEX may draw text as well,
1354 * so we must be sure that correct font is selected
1355 */
1356 if(!hfsave && (opcode <= DST_PREFIXTEXT)) goto cleanup;
1357 tmp = PAINTING_DrawStateJam(memdc, opcode, func, lp, len, &rc, dtflags, unicode);
1358 if(hfsave) SelectObject(memdc, hfsave);
1359 if (hNaaFont) DeleteObject(hNaaFont);
1360 if(!tmp) goto cleanup;
1361
1362 /* This state cause the image to be dithered */
1363 if(flags & DSS_UNION)
1364 {
1365 hbsave = (HBRUSH)SelectObject(memdc, gpsi->hbrGray);
1366 if(!hbsave) goto cleanup;
1367 tmp = PatBlt(memdc, 0, 0, cx, cy, 0x00FA0089);
1368 SelectObject(memdc, hbsave);
1369 if(!tmp) goto cleanup;
1370 }
1371
1372 if (flags & DSS_DISABLED)
1373 hbrtmp = GetSysColorBrush(COLOR_3DHILIGHT);
1374 else if (flags & DSS_DEFAULT)
1375 hbrtmp = GetSysColorBrush(COLOR_3DSHADOW);
1376
1377 /* Draw light or dark shadow */
1378 if (flags & (DSS_DISABLED|DSS_DEFAULT))
1379 {
1380 if(!hbrtmp) goto cleanup;
1381 hbsave = (HBRUSH)SelectObject(hdc, hbrtmp);
1382 if(!hbsave) goto cleanup;
1383 if(!BitBlt(hdc, x+1, y+1, cx, cy, memdc, 0, 0, 0x00B8074A)) goto cleanup;
1384 SelectObject(hdc, hbsave);
1385 }
1386
1387 if (flags & DSS_DISABLED)
1388 {
1389 hbr = hbrtmp = GetSysColorBrush(COLOR_3DSHADOW);
1390 if(!hbrtmp) goto cleanup;
1391 }
1392 else if (!hbr)
1393 {
1394 hbr = (HBRUSH)GetStockObject(BLACK_BRUSH);
1395 }
1396
1397 hbsave = (HBRUSH)SelectObject(hdc, hbr);
1398
1399 if(!BitBlt(hdc, x, y, cx, cy, memdc, 0, 0, 0x00B8074A)) goto cleanup;
1400
1401 retval = TRUE; /* We succeeded */
1402
1403 cleanup:
1404 SetTextColor(hdc, fg);
1405 SetBkColor(hdc, bg);
1406
1407 if(hbsave) SelectObject(hdc, hbsave);
1408 if(hbmsave) SelectObject(memdc, hbmsave);
1409 if(hbm) DeleteObject(hbm);
1410 if(memdc) DeleteDC(memdc);
1411
1412 return retval;
1413 }
1414
1415 /*
1416 * @implemented
1417 */
1418 BOOL WINAPI
1419 RealDrawFrameControl(HDC hDC, LPRECT rc, UINT uType, UINT uState)
1420 {
1421 if (GetMapMode(hDC) != MM_TEXT)
1422 return FALSE;
1423
1424 switch(uType)
1425 {
1426 case DFC_BUTTON:
1427 return UITOOLS95_DrawFrameButton(hDC, rc, uState);
1428 case DFC_CAPTION:
1429 return UITOOLS95_DrawFrameCaption(hDC, rc, uState);
1430 case DFC_MENU:
1431 return UITOOLS95_DrawFrameMenu(hDC, rc, uState);
1432 #if 0
1433 case DFC_POPUPMENU:
1434 UNIMPLEMENTED;
1435 break;
1436 #endif
1437 case DFC_SCROLL:
1438 return UITOOLS95_DrawFrameScroll(hDC, rc, uState);
1439 }
1440 return FALSE;
1441 }
1442
1443 BOOL WINAPI
1444 DrawFrameControl(HDC hDC, LPRECT rc, UINT uType, UINT uState)
1445 {
1446 BOOL Hook, Ret = FALSE;
1447
1448 LoadUserApiHook();
1449
1450 Hook = BeginIfHookedUserApiHook();
1451
1452 /* Bypass SEH and go direct. */
1453 if (!Hook) return RealDrawFrameControl(hDC, rc, uType, uState);
1454
1455 _SEH2_TRY
1456 {
1457 Ret = guah.DrawFrameControl(hDC, rc, uType, uState);
1458 }
1459 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1460 {
1461 }
1462 _SEH2_END;
1463
1464 EndUserApiHook();
1465
1466 return Ret;
1467 }
1468
1469 /*
1470 * @implemented
1471 */
1472 BOOL WINAPI
1473 DrawEdge(HDC hDC, LPRECT rc, UINT edge, UINT flags)
1474 {
1475 if (flags & BF_DIAGONAL)
1476 return IntDrawDiagEdge(hDC, rc, edge, flags);
1477 else
1478 return IntDrawRectEdge(hDC, rc, edge, flags, 1);
1479 }
1480
1481 /*
1482 * @implemented
1483 */
1484 BOOL WINAPI
1485 GrayStringA(HDC hDC, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc, LPARAM lpData,
1486 int nCount, int X, int Y, int nWidth, int nHeight)
1487 {
1488 return IntGrayString(hDC, hBrush, lpOutputFunc, lpData, nCount, X, Y, nWidth, nHeight, FALSE);
1489 }
1490
1491 /*
1492 * @implemented
1493 */
1494 BOOL WINAPI
1495 GrayStringW(HDC hDC, HBRUSH hBrush, GRAYSTRINGPROC lpOutputFunc, LPARAM lpData,
1496 int nCount, int X, int Y, int nWidth, int nHeight)
1497 {
1498 return IntGrayString(hDC, hBrush, lpOutputFunc, lpData, nCount, X, Y, nWidth, nHeight, TRUE);
1499 }
1500
1501 /*
1502 * @implemented
1503 */
1504 BOOL WINAPI
1505 InvertRect(HDC hDC, CONST RECT *lprc)
1506 {
1507 return PatBlt(hDC, lprc->left, lprc->top, lprc->right - lprc->left,
1508 lprc->bottom - lprc->top, DSTINVERT);
1509 }
1510
1511 /*
1512 * @implemented
1513 */
1514 INT WINAPI
1515 FrameRect(HDC hDC, CONST RECT *lprc, HBRUSH hbr)
1516 {
1517 HBRUSH oldbrush;
1518 RECT r = *lprc;
1519
1520 if (IsRectEmpty(&r)) return 0;
1521 if (!(oldbrush = SelectObject(hDC, hbr))) return 0;
1522
1523 PatBlt(hDC, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
1524 PatBlt(hDC, r.right - 1, r.top, 1, r.bottom - r.top, PATCOPY);
1525 PatBlt(hDC, r.left, r.top, r.right - r.left, 1, PATCOPY);
1526 PatBlt(hDC, r.left, r.bottom - 1, r.right - r.left, 1, PATCOPY);
1527
1528 SelectObject(hDC, oldbrush);
1529 return TRUE;
1530 }
1531
1532 /*
1533 * @implemented
1534 */
1535 BOOL WINAPI
1536 FlashWindow(HWND hWnd, BOOL bInvert)
1537 {
1538 FLASHWINFO FlashWndInfo;
1539
1540 FlashWndInfo.cbSize = sizeof(FLASHWINFO);
1541 FlashWndInfo.hwnd = hWnd;
1542 FlashWndInfo.dwFlags = !bInvert ? 0 : (FLASHW_TRAY | FLASHW_CAPTION);
1543 FlashWndInfo.uCount = 1;
1544 FlashWndInfo.dwTimeout = 0;
1545
1546 return NtUserFlashWindowEx(&FlashWndInfo);
1547 }
1548
1549 /*
1550 * @implemented
1551 */
1552 INT WINAPI
1553 FillRect(HDC hDC, CONST RECT *lprc, HBRUSH hbr)
1554 {
1555 BOOL Ret;
1556 HBRUSH prevhbr = NULL;
1557
1558 /* Select brush if specified */
1559 if (hbr)
1560 {
1561 /* Handle system colors */
1562 if (hbr <= (HBRUSH)(COLOR_MENUBAR + 1))
1563 hbr = GetSysColorBrush(PtrToUlong(hbr) - 1);
1564
1565 prevhbr = SelectObject(hDC, hbr);
1566 if (prevhbr == NULL)
1567 return (INT)FALSE;
1568 }
1569
1570 Ret = PatBlt(hDC, lprc->left, lprc->top, lprc->right - lprc->left,
1571 lprc->bottom - lprc->top, PATCOPY);
1572
1573 /* Select old brush */
1574 if (prevhbr)
1575 SelectObject(hDC, prevhbr);
1576
1577 return (INT)Ret;
1578 }
1579
1580 /*
1581 * @implemented
1582 */
1583 BOOL WINAPI
1584 DrawFocusRect(HDC hdc, CONST RECT *rect)
1585 {
1586 HGDIOBJ OldObj;
1587 UINT cx, cy;
1588
1589 NtUserSystemParametersInfo(SPI_GETFOCUSBORDERWIDTH, 0, &cx, 0);
1590 NtUserSystemParametersInfo(SPI_GETFOCUSBORDERHEIGHT, 0, &cy, 0);
1591
1592 OldObj = SelectObject(hdc, gpsi->hbrGray);
1593
1594 /* top */
1595 PatBlt(hdc, rect->left, rect->top, rect->right - rect->left, cy, PATINVERT);
1596 /* bottom */
1597 PatBlt(hdc, rect->left, rect->bottom - cy, rect->right - rect->left, cy, PATINVERT);
1598 /* left */
1599 PatBlt(hdc, rect->left, rect->top + cy, cx, rect->bottom - rect->top - (2 * cy), PATINVERT);
1600 /* right */
1601 PatBlt(hdc, rect->right - cx, rect->top + cy, cx, rect->bottom - rect->top - (2 * cy), PATINVERT);
1602
1603 SelectObject(hdc, OldObj);
1604 return TRUE;
1605 }
1606
1607 /*
1608 * @implemented
1609 */
1610 BOOL WINAPI
1611 DrawStateA(HDC hDC, HBRUSH hBrush, DRAWSTATEPROC lpOutputFunc, LPARAM lData,
1612 WPARAM wData, int x, int y, int cx, int cy, UINT fuFlags)
1613 {
1614 return IntDrawState(hDC, hBrush, lpOutputFunc, lData, wData, x, y, cx, cy, fuFlags, FALSE);
1615 }
1616
1617 /*
1618 * @implemented
1619 */
1620 BOOL WINAPI
1621 DrawStateW(HDC hDC, HBRUSH hBrush, DRAWSTATEPROC lpOutputFunc, LPARAM lData,
1622 WPARAM wData, int x, int y, int cx, int cy, UINT fuFlags)
1623 {
1624 return IntDrawState(hDC, hBrush, lpOutputFunc, lData, wData, x, y, cx, cy, fuFlags, TRUE);
1625 }
A free Windows-compatible Operating System