?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed warnings.
[wine.git] / windows / nonclient.c
blob1ca2b3362650a05251208fe2a70eee4d10fa1d3b
1 /*
2 * Non-client area window functions
3 *
4 * Copyright 1994 Alexandre Julliard
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "config.h"
22
23 #include "windef.h"
24 #include "wingdi.h"
25 #include "wine/winuser16.h"
26 #include "win.h"
27 #include "user.h"
28 #include "dce.h"
29 #include "controls.h"
30 #include "cursoricon.h"
31 #include "winpos.h"
32 #include "hook.h"
33 #include "nonclient.h"
34 #include "wine/debug.h"
35 #include "shellapi.h"
36 #include "bitmap.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(nonclient);
39 WINE_DECLARE_DEBUG_CHANNEL(shell);
40
41 BOOL NC_DrawGrayButton(HDC hdc, int x, int y);
42
43 static HBITMAP hbitmapClose;
44
45 static const BYTE lpGrayMask[] = { 0xAA, 0xA0,
46 0x55, 0x50,
47 0xAA, 0xA0,
48 0x55, 0x50,
49 0xAA, 0xA0,
50 0x55, 0x50,
51 0xAA, 0xA0,
52 0x55, 0x50,
53 0xAA, 0xA0,
54 0x55, 0x50};
55
56 #define SC_ABOUTWINE (SC_SCREENSAVE+1)
57 #define SC_PUTMARK (SC_SCREENSAVE+2)
58
59 /* Some useful macros */
60 #define HAS_DLGFRAME(style,exStyle) \
61 (((exStyle) & WS_EX_DLGMODALFRAME) || \
62 (((style) & WS_DLGFRAME) && !((style) & WS_THICKFRAME)))
63
64 #define HAS_THICKFRAME(style,exStyle) \
65 (((style) & WS_THICKFRAME) && \
66 !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
67
68 #define HAS_THINFRAME(style) \
69 (((style) & WS_BORDER) || !((style) & (WS_CHILD | WS_POPUP)))
70
71 #define HAS_BIGFRAME(style,exStyle) \
72 (((style) & (WS_THICKFRAME | WS_DLGFRAME)) || \
73 ((exStyle) & WS_EX_DLGMODALFRAME))
74
75 #define HAS_STATICOUTERFRAME(style,exStyle) \
76 (((exStyle) & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) == \
77 WS_EX_STATICEDGE)
78
79 #define HAS_ANYFRAME(style,exStyle) \
80 (((style) & (WS_THICKFRAME | WS_DLGFRAME | WS_BORDER)) || \
81 ((exStyle) & WS_EX_DLGMODALFRAME) || \
82 !((style) & (WS_CHILD | WS_POPUP)))
83
84 #define HAS_MENU(w) (!((w)->dwStyle & WS_CHILD) && ((w)->wIDmenu != 0))
85
86
87 /***********************************************************************
88 * NC_AdjustRect
89 *
90 * Compute the size of the window rectangle from the size of the
91 * client rectangle.
92 */
93 static void NC_AdjustRect( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
94 {
95 if (TWEAK_WineLook > WIN31_LOOK)
96 ERR("Called in Win95 mode. Aiee! Please report this.\n" );
97
98 if(style & WS_ICONIC) return;
99
100 if (HAS_THICKFRAME( style, exStyle ))
101 InflateRect( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
102 else if (HAS_DLGFRAME( style, exStyle ))
103 InflateRect( rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
104 else if (HAS_THINFRAME( style ))
105 InflateRect( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
106
107 if ((style & WS_CAPTION) == WS_CAPTION)
108 rect->top -= GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
109
110 if (menu) rect->top -= GetSystemMetrics(SM_CYMENU) + GetSystemMetrics(SM_CYBORDER);
111
112 if (style & WS_VSCROLL) {
113 rect->right += GetSystemMetrics(SM_CXVSCROLL) - 1;
114 if(!HAS_ANYFRAME( style, exStyle ))
115 rect->right++;
116 }
117
118 if (style & WS_HSCROLL) {
119 rect->bottom += GetSystemMetrics(SM_CYHSCROLL) - 1;
120 if(!HAS_ANYFRAME( style, exStyle ))
121 rect->bottom++;
122 }
123 }
124
125
126 /******************************************************************************
127 * NC_AdjustRectOuter95
128 *
129 * Computes the size of the "outside" parts of the window based on the
130 * parameters of the client area.
131 *
132 + PARAMS
133 * LPRECT16 rect
134 * DWORD style
135 * BOOL menu
136 * DWORD exStyle
137 *
138 * NOTES
139 * "Outer" parts of a window means the whole window frame, caption and
140 * menu bar. It does not include "inner" parts of the frame like client
141 * edge, static edge or scroll bars.
142 *
143 * Revision history
144 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
145 * Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
146 *
147 * 20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
148 * Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
149 * NC_AdjustRectInner95 and added handling of Win95 styles.
150 *
151 * 28-Jul-1999 Ove Kåven (ovek@arcticnet.no)
152 * Streamlined window style checks.
153 *
154 *****************************************************************************/
155
156 static void
157 NC_AdjustRectOuter95 (LPRECT rect, DWORD style, BOOL menu, DWORD exStyle)
158 {
159 int adjust;
160 if(style & WS_ICONIC) return;
161
162 if ((exStyle & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) ==
163 WS_EX_STATICEDGE)
164 {
165 adjust = 1; /* for the outer frame always present */
166 }
167 else
168 {
169 adjust = 0;
170 if ((exStyle & WS_EX_DLGMODALFRAME) ||
171 (style & (WS_THICKFRAME|WS_DLGFRAME))) adjust = 2; /* outer */
172 }
173 if (style & WS_THICKFRAME)
174 adjust += ( GetSystemMetrics (SM_CXFRAME)
175 - GetSystemMetrics (SM_CXDLGFRAME)); /* The resize border */
176 if ((style & (WS_BORDER|WS_DLGFRAME)) ||
177 (exStyle & WS_EX_DLGMODALFRAME))
178 adjust++; /* The other border */
179
180 InflateRect (rect, adjust, adjust);
181
182 if ((style & WS_CAPTION) == WS_CAPTION)
183 {
184 if (exStyle & WS_EX_TOOLWINDOW)
185 rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
186 else
187 rect->top -= GetSystemMetrics(SM_CYCAPTION);
188 }
189 if (menu) rect->top -= GetSystemMetrics(SM_CYMENU);
190 }
191
192
193 /******************************************************************************
194 * NC_AdjustRectInner95
195 *
196 * Computes the size of the "inside" part of the window based on the
197 * parameters of the client area.
198 *
199 + PARAMS
200 * LPRECT16 rect
201 * DWORD style
202 * DWORD exStyle
203 *
204 * NOTES
205 * "Inner" part of a window means the window frame inside of the flat
206 * window frame. It includes the client edge, the static edge and the
207 * scroll bars.
208 *
209 * Revision history
210 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
211 * Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
212 *
213 * 20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
214 * Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
215 * NC_AdjustRectInner95 and added handling of Win95 styles.
216 *
217 *****************************************************************************/
218
219 static void
220 NC_AdjustRectInner95 (LPRECT rect, DWORD style, DWORD exStyle)
221 {
222 if(style & WS_ICONIC) return;
223
224 if (exStyle & WS_EX_CLIENTEDGE)
225 InflateRect(rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
226
227 if (style & WS_VSCROLL) rect->right += GetSystemMetrics(SM_CXVSCROLL);
228 if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
229 }
230
231
232
233 static HICON NC_IconForWindow( HWND hwnd )
234 {
235 HICON hIcon = (HICON) GetClassLongA( hwnd, GCL_HICONSM );
236 if (!hIcon) hIcon = (HICON) GetClassLongA( hwnd, GCL_HICON );
237
238 /* If there is no hIcon specified and this is a modal dialog,
239 * get the default one.
240 */
241 if (!hIcon && (GetWindowLongA( hwnd, GWL_STYLE ) & DS_MODALFRAME))
242 hIcon = LoadImageA(0, IDI_WINLOGOA, IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
243 return hIcon;
244 }
245
246 /***********************************************************************
247 * DrawCaption (USER32.@) Draws a caption bar
248 *
249 * PARAMS
250 * hwnd [I]
251 * hdc [I]
252 * lpRect [I]
253 * uFlags [I]
254 *
255 * RETURNS
256 * Success:
257 * Failure:
258 */
259
260 BOOL WINAPI
261 DrawCaption (HWND hwnd, HDC hdc, const RECT *lpRect, UINT uFlags)
262 {
263 return DrawCaptionTempA (hwnd, hdc, lpRect, 0, 0, NULL, uFlags & 0x1F);
264 }
265
266
267 /***********************************************************************
268 * DrawCaptionTempA (USER32.@)
269 */
270 BOOL WINAPI DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
271 HICON hIcon, LPCSTR str, UINT uFlags)
272 {
273 LPWSTR strW;
274 INT len;
275 BOOL ret = FALSE;
276
277 if (!(uFlags & DC_TEXT) || !str)
278 return DrawCaptionTempW( hwnd, hdc, rect, hFont, hIcon, NULL, uFlags );
279
280 len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
281 if ((strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
282 {
283 MultiByteToWideChar( CP_ACP, 0, str, -1, strW, len );
284 ret = DrawCaptionTempW (hwnd, hdc, rect, hFont, hIcon, strW, uFlags);
285 HeapFree( GetProcessHeap (), 0, strW );
286 }
287 return ret;
288 }
289
290
291 /***********************************************************************
292 * DrawCaptionTempW (USER32.@)
293 */
294 BOOL WINAPI DrawCaptionTempW (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
295 HICON hIcon, LPCWSTR str, UINT uFlags)
296 {
297 RECT rc = *rect;
298
299 TRACE("(%08x,%08x,%p,%08x,%08x,%s,%08x)\n",
300 hwnd, hdc, rect, hFont, hIcon, debugstr_w(str), uFlags);
301
302 /* drawing background */
303 if (uFlags & DC_INBUTTON) {
304 FillRect (hdc, &rc, GetSysColorBrush (COLOR_3DFACE));
305
306 if (uFlags & DC_ACTIVE) {
307 HBRUSH hbr = SelectObject (hdc, CACHE_GetPattern55AABrush ());
308 PatBlt (hdc, rc.left, rc.top,
309 rc.right-rc.left, rc.bottom-rc.top, 0xFA0089);
310 SelectObject (hdc, hbr);
311 }
312 }
313 else {
314 FillRect (hdc, &rc, GetSysColorBrush ((uFlags & DC_ACTIVE) ?
315 COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
316 }
317
318
319 /* drawing icon */
320 if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP)) {
321 POINT pt;
322
323 pt.x = rc.left + 2;
324 pt.y = (rc.bottom + rc.top - GetSystemMetrics(SM_CYSMICON)) / 2;
325
326 if (!hIcon) hIcon = NC_IconForWindow(hwnd);
327 DrawIconEx (hdc, pt.x, pt.y, hIcon, GetSystemMetrics(SM_CXSMICON),
328 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
329 rc.left += (rc.bottom - rc.top);
330 }
331
332 /* drawing text */
333 if (uFlags & DC_TEXT) {
334 HFONT hOldFont;
335
336 if (uFlags & DC_INBUTTON)
337 SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
338 else if (uFlags & DC_ACTIVE)
339 SetTextColor (hdc, GetSysColor (COLOR_CAPTIONTEXT));
340 else
341 SetTextColor (hdc, GetSysColor (COLOR_INACTIVECAPTIONTEXT));
342
343 SetBkMode (hdc, TRANSPARENT);
344
345 if (hFont)
346 hOldFont = SelectObject (hdc, hFont);
347 else {
348 NONCLIENTMETRICSA nclm;
349 HFONT hNewFont;
350 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
351 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
352 hNewFont = CreateFontIndirectA ((uFlags & DC_SMALLCAP) ?
353 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
354 hOldFont = SelectObject (hdc, hNewFont);
355 }
356
357 if (str)
358 DrawTextW (hdc, str, -1, &rc,
359 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
360 else {
361 WCHAR szText[128];
362 INT nLen;
363 nLen = GetWindowTextW (hwnd, szText, 128);
364 DrawTextW (hdc, szText, nLen, &rc,
365 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
366 }
367
368 if (hFont)
369 SelectObject (hdc, hOldFont);
370 else
371 DeleteObject (SelectObject (hdc, hOldFont));
372 }
373
374 /* drawing focus ??? */
375 if (uFlags & 0x2000)
376 FIXME("undocumented flag (0x2000)!\n");
377
378 return 0;
379 }
380
381
382 /***********************************************************************
383 * AdjustWindowRect (USER.102)
384 */
385 BOOL16 WINAPI AdjustWindowRect16( LPRECT16 rect, DWORD style, BOOL16 menu )
386 {
387 return AdjustWindowRectEx16( rect, style, menu, 0 );
388 }
389
390
391 /***********************************************************************
392 * AdjustWindowRect (USER32.@)
393 */
394 BOOL WINAPI AdjustWindowRect( LPRECT rect, DWORD style, BOOL menu )
395 {
396 return AdjustWindowRectEx( rect, style, menu, 0 );
397 }
398
399
400 /***********************************************************************
401 * AdjustWindowRectEx (USER.454)
402 */
403 BOOL16 WINAPI AdjustWindowRectEx16( LPRECT16 rect, DWORD style,
404 BOOL16 menu, DWORD exStyle )
405 {
406 RECT rect32;
407 BOOL ret;
408
409 CONV_RECT16TO32( rect, &rect32 );
410 ret = AdjustWindowRectEx( &rect32, style, menu, exStyle );
411 CONV_RECT32TO16( &rect32, rect );
412 return ret;
413 }
414
415
416 /***********************************************************************
417 * AdjustWindowRectEx (USER32.@)
418 */
419 BOOL WINAPI AdjustWindowRectEx( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
420 {
421 /* Correct the window style */
422 style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD);
423 exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
424 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
425 if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
426
427 TRACE("(%d,%d)-(%d,%d) %08lx %d %08lx\n",
428 rect->left, rect->top, rect->right, rect->bottom,
429 style, menu, exStyle );
430
431 if (TWEAK_WineLook == WIN31_LOOK)
432 NC_AdjustRect( rect, style, menu, exStyle );
433 else
434 {
435 NC_AdjustRectOuter95( rect, style, menu, exStyle );
436 NC_AdjustRectInner95( rect, style, exStyle );
437 }
438 return TRUE;
439 }
440
441
442 /***********************************************************************
443 * NC_HandleNCCalcSize
444 *
445 * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
446 */
447 LONG NC_HandleNCCalcSize( HWND hwnd, RECT *winRect )
448 {
449 RECT tmpRect = { 0, 0, 0, 0 };
450 LONG result = 0;
451 LONG cls_style = GetClassLongA(hwnd, GCL_STYLE);
452 LONG style = GetWindowLongA( hwnd, GWL_STYLE );
453 LONG exStyle = GetWindowLongA( hwnd, GWL_EXSTYLE );
454
455 if (cls_style & CS_VREDRAW) result |= WVR_VREDRAW;
456 if (cls_style & CS_HREDRAW) result |= WVR_HREDRAW;
457
458 if (!IsIconic(hwnd))
459 {
460 if (TWEAK_WineLook == WIN31_LOOK)
461 NC_AdjustRect( &tmpRect, style, FALSE, exStyle );
462 else
463 NC_AdjustRectOuter95( &tmpRect, style, FALSE, exStyle );
464
465 winRect->left -= tmpRect.left;
466 winRect->top -= tmpRect.top;
467 winRect->right -= tmpRect.right;
468 winRect->bottom -= tmpRect.bottom;
469
470 if (!(style & WS_CHILD) && GetMenu(hwnd))
471 {
472 TRACE("Calling GetMenuBarHeight with HWND 0x%x, width %d, "
473 "at (%d, %d).\n", hwnd,
474 winRect->right - winRect->left,
475 -tmpRect.left, -tmpRect.top );
476
477 winRect->top +=
478 MENU_GetMenuBarHeight( hwnd,
479 winRect->right - winRect->left,
480 -tmpRect.left, -tmpRect.top ) + 1;
481 }
482
483 if (TWEAK_WineLook > WIN31_LOOK) {
484 SetRect(&tmpRect, 0, 0, 0, 0);
485 NC_AdjustRectInner95 (&tmpRect, style, exStyle);
486 winRect->left -= tmpRect.left;
487 winRect->top -= tmpRect.top;
488 winRect->right -= tmpRect.right;
489 winRect->bottom -= tmpRect.bottom;
490 }
491
492 if (winRect->top > winRect->bottom)
493 winRect->bottom = winRect->top;
494
495 if (winRect->left > winRect->right)
496 winRect->right = winRect->left;
497 }
498 return result;
499 }
500
501
502 /***********************************************************************
503 * NC_GetInsideRect
504 *
505 * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
506 * but without the borders (if any).
507 * The rectangle is in window coordinates (for drawing with GetWindowDC()).
508 */
509 void NC_GetInsideRect( HWND hwnd, RECT *rect )
510 {
511 WND * wndPtr = WIN_FindWndPtr( hwnd );
512
513 rect->top = rect->left = 0;
514 rect->right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
515 rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
516
517 if (wndPtr->dwStyle & WS_ICONIC) goto END;
518
519 /* Remove frame from rectangle */
520 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
521 {
522 InflateRect( rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
523 }
524 else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
525 {
526 InflateRect( rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
527 /* FIXME: this isn't in NC_AdjustRect? why not? */
528 if ((TWEAK_WineLook == WIN31_LOOK) && (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME))
529 InflateRect( rect, -1, 0 );
530 }
531 else if (HAS_THINFRAME( wndPtr->dwStyle ))
532 {
533 InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
534 }
535
536 /* We have additional border information if the window
537 * is a child (but not an MDI child) */
538 if (TWEAK_WineLook != WIN31_LOOK)
539 {
540 if ( (wndPtr->dwStyle & WS_CHILD) &&
541 ( (wndPtr->dwExStyle & WS_EX_MDICHILD) == 0 ) )
542 {
543 if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
544 InflateRect (rect, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYEDGE));
545 if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
546 InflateRect (rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
547 }
548 }
549
550 END:
551 WIN_ReleaseWndPtr(wndPtr);
552 return;
553 }
554
555
556 /***********************************************************************
557 * NC_DoNCHitTest
558 *
559 * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
560 */
561
562 static LONG NC_DoNCHitTest (WND *wndPtr, POINT pt )
563 {
564 RECT rect;
565
566 TRACE("hwnd=%04x pt=%ld,%ld\n", wndPtr->hwndSelf, pt.x, pt.y );
567
568 GetWindowRect(wndPtr->hwndSelf, &rect );
569 if (!PtInRect( &rect, pt )) return HTNOWHERE;
570
571 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
572
573 /* Check borders */
574 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
575 {
576 InflateRect( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
577 if (!PtInRect( &rect, pt ))
578 {
579 /* Check top sizing border */
580 if (pt.y < rect.top)
581 {
582 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
583 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
584 return HTTOP;
585 }
586 /* Check bottom sizing border */
587 if (pt.y >= rect.bottom)
588 {
589 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
590 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
591 return HTBOTTOM;
592 }
593 /* Check left sizing border */
594 if (pt.x < rect.left)
595 {
596 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
597 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
598 return HTLEFT;
599 }
600 /* Check right sizing border */
601 if (pt.x >= rect.right)
602 {
603 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
604 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
605 return HTRIGHT;
606 }
607 }
608 }
609 else /* No thick frame */
610 {
611 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
612 InflateRect(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
613 else if (HAS_THINFRAME( wndPtr->dwStyle ))
614 InflateRect(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
615 if (!PtInRect( &rect, pt )) return HTBORDER;
616 }
617
618 /* Check caption */
619
620 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
621 {
622 rect.top += GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
623 if (!PtInRect( &rect, pt ))
624 {
625 /* Check system menu */
626 if ((wndPtr->dwStyle & WS_SYSMENU) && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
627 rect.left += GetSystemMetrics(SM_CXSIZE);
628 if (pt.x <= rect.left) return HTSYSMENU;
629
630 /* Check maximize box */
631 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
632 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
633
634 if (pt.x >= rect.right) return HTMAXBUTTON;
635 /* Check minimize box */
636 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
637 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
638 if (pt.x >= rect.right) return HTMINBUTTON;
639 return HTCAPTION;
640 }
641 }
642
643 /* Check client area */
644
645 ScreenToClient( wndPtr->hwndSelf, &pt );
646 GetClientRect( wndPtr->hwndSelf, &rect );
647 if (PtInRect( &rect, pt )) return HTCLIENT;
648
649 /* Check vertical scroll bar */
650
651 if (wndPtr->dwStyle & WS_VSCROLL)
652 {
653 rect.right += GetSystemMetrics(SM_CXVSCROLL);
654 if (PtInRect( &rect, pt )) return HTVSCROLL;
655 }
656
657 /* Check horizontal scroll bar */
658
659 if (wndPtr->dwStyle & WS_HSCROLL)
660 {
661 rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
662 if (PtInRect( &rect, pt ))
663 {
664 /* Check size box */
665 if ((wndPtr->dwStyle & WS_VSCROLL) &&
666 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
667 return HTSIZE;
668 return HTHSCROLL;
669 }
670 }
671
672 /* Check menu bar */
673
674 if (HAS_MENU(wndPtr))
675 {
676 if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
677 return HTMENU;
678 }
679
680 /* Has to return HTNOWHERE if nothing was found
681 Could happen when a window has a customized non client area */
682 return HTNOWHERE;
683 }
684
685
686 /***********************************************************************
687 * NC_DoNCHitTest95
688 *
689 * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
690 *
691 * FIXME: Just a modified copy of the Win 3.1 version.
692 */
693
694 static LONG NC_DoNCHitTest95 (WND *wndPtr, POINT pt )
695 {
696 RECT rect;
697
698 TRACE("hwnd=%04x pt=%ld,%ld\n", wndPtr->hwndSelf, pt.x, pt.y );
699
700 GetWindowRect(wndPtr->hwndSelf, &rect );
701 if (!PtInRect( &rect, pt )) return HTNOWHERE;
702
703 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
704
705 /* Check borders */
706 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
707 {
708 InflateRect( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
709 if (!PtInRect( &rect, pt ))
710 {
711 /* Check top sizing border */
712 if (pt.y < rect.top)
713 {
714 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
715 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
716 return HTTOP;
717 }
718 /* Check bottom sizing border */
719 if (pt.y >= rect.bottom)
720 {
721 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
722 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
723 return HTBOTTOM;
724 }
725 /* Check left sizing border */
726 if (pt.x < rect.left)
727 {
728 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
729 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
730 return HTLEFT;
731 }
732 /* Check right sizing border */
733 if (pt.x >= rect.right)
734 {
735 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
736 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
737 return HTRIGHT;
738 }
739 }
740 }
741 else /* No thick frame */
742 {
743 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
744 InflateRect(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
745 else if (HAS_THINFRAME( wndPtr->dwStyle ))
746 InflateRect(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
747 if (!PtInRect( &rect, pt )) return HTBORDER;
748 }
749
750 /* Check caption */
751
752 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
753 {
754 if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
755 rect.top += GetSystemMetrics(SM_CYSMCAPTION) - 1;
756 else
757 rect.top += GetSystemMetrics(SM_CYCAPTION) - 1;
758 if (!PtInRect( &rect, pt ))
759 {
760 /* Check system menu */
761 if ((wndPtr->dwStyle & WS_SYSMENU) && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
762 {
763 if (NC_IconForWindow(wndPtr->hwndSelf))
764 rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
765 }
766 if (pt.x < rect.left) return HTSYSMENU;
767
768 /* Check close button */
769 if (wndPtr->dwStyle & WS_SYSMENU)
770 rect.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
771 if (pt.x > rect.right) return HTCLOSE;
772
773 /* Check maximize box */
774 /* In win95 there is automatically a Maximize button when there is a minimize one*/
775 if ((wndPtr->dwStyle & WS_MAXIMIZEBOX)|| (wndPtr->dwStyle & WS_MINIMIZEBOX))
776 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
777 if (pt.x > rect.right) return HTMAXBUTTON;
778
779 /* Check minimize box */
780 /* In win95 there is automatically a Maximize button when there is a Maximize one*/
781 if ((wndPtr->dwStyle & WS_MINIMIZEBOX)||(wndPtr->dwStyle & WS_MAXIMIZEBOX))
782 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
783
784 if (pt.x > rect.right) return HTMINBUTTON;
785 return HTCAPTION;
786 }
787 }
788
789 /* Check client area */
790
791 ScreenToClient( wndPtr->hwndSelf, &pt );
792 GetClientRect( wndPtr->hwndSelf, &rect );
793 if (PtInRect( &rect, pt )) return HTCLIENT;
794
795 /* Check vertical scroll bar */
796
797 if (wndPtr->dwStyle & WS_VSCROLL)
798 {
799 rect.right += GetSystemMetrics(SM_CXVSCROLL);
800 if (PtInRect( &rect, pt )) return HTVSCROLL;
801 }
802
803 /* Check horizontal scroll bar */
804
805 if (wndPtr->dwStyle & WS_HSCROLL)
806 {
807 rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
808 if (PtInRect( &rect, pt ))
809 {
810 /* Check size box */
811 if ((wndPtr->dwStyle & WS_VSCROLL) &&
812 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
813 return HTSIZE;
814 return HTHSCROLL;
815 }
816 }
817
818 /* Check menu bar */
819
820 if (HAS_MENU(wndPtr))
821 {
822 if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
823 return HTMENU;
824 }
825
826 /* Has to return HTNOWHERE if nothing was found
827 Could happen when a window has a customized non client area */
828 return HTNOWHERE;
829 }
830
831
832 /***********************************************************************
833 * NC_HandleNCHitTest
834 *
835 * Handle a WM_NCHITTEST message. Called from DefWindowProc().
836 */
837 LONG NC_HandleNCHitTest (HWND hwnd , POINT pt)
838 {
839 LONG retvalue;
840 WND *wndPtr = WIN_FindWndPtr (hwnd);
841
842 if (!wndPtr)
843 return HTERROR;
844
845 if (TWEAK_WineLook == WIN31_LOOK)
846 retvalue = NC_DoNCHitTest (wndPtr, pt);
847 else
848 retvalue = NC_DoNCHitTest95 (wndPtr, pt);
849 WIN_ReleaseWndPtr(wndPtr);
850 return retvalue;
851 }
852
853
854 /***********************************************************************
855 * NC_DrawSysButton
856 */
857 void NC_DrawSysButton( HWND hwnd, HDC hdc, BOOL down )
858 {
859 RECT rect;
860 HDC hdcMem;
861 HBITMAP hbitmap;
862
863 NC_GetInsideRect( hwnd, &rect );
864 hdcMem = CreateCompatibleDC( hdc );
865 hbitmap = SelectObject( hdcMem, hbitmapClose );
866 BitBlt(hdc, rect.left, rect.top, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
867 hdcMem, (GetWindowLongA(hwnd,GWL_STYLE) & WS_CHILD) ? GetSystemMetrics(SM_CXSIZE) : 0, 0,
868 down ? NOTSRCCOPY : SRCCOPY );
869 SelectObject( hdcMem, hbitmap );
870 DeleteDC( hdcMem );
871 }
872
873
874 /***********************************************************************
875 * NC_DrawMaxButton
876 */
877 static void NC_DrawMaxButton( HWND hwnd, HDC16 hdc, BOOL down )
878 {
879 RECT rect;
880 UINT flags = IsZoomed(hwnd) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMAX;
881
882 NC_GetInsideRect( hwnd, &rect );
883 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE) + 1;
884 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
885 rect.top += 1;
886 rect.right -= 1;
887 if (down) flags |= DFCS_PUSHED;
888 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
889 }
890
891
892 /***********************************************************************
893 * NC_DrawMinButton
894 */
895 static void NC_DrawMinButton( HWND hwnd, HDC16 hdc, BOOL down )
896 {
897 RECT rect;
898 UINT flags = DFCS_CAPTIONMIN;
899 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
900
901 NC_GetInsideRect( hwnd, &rect );
902 if (style & (WS_MAXIMIZEBOX|WS_MINIMIZEBOX))
903 rect.right -= GetSystemMetrics(SM_CXSIZE) - 2;
904 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE) + 1;
905 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
906 rect.top += 1;
907 rect.right -= 1;
908 if (down) flags |= DFCS_PUSHED;
909 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
910 }
911
912
913 /******************************************************************************
914 *
915 * void NC_DrawSysButton95(
916 * HWND hwnd,
917 * HDC hdc,
918 * BOOL down )
919 *
920 * Draws the Win95 system icon.
921 *
922 * Revision history
923 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
924 * Original implementation from NC_DrawSysButton source.
925 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
926 * Fixed most bugs.
927 *
928 *****************************************************************************/
929
930 BOOL
931 NC_DrawSysButton95 (HWND hwnd, HDC hdc, BOOL down)
932 {
933 HICON hIcon = NC_IconForWindow( hwnd );
934
935 if (hIcon)
936 {
937 RECT rect;
938 NC_GetInsideRect( hwnd, &rect );
939 DrawIconEx (hdc, rect.left + 2, rect.top + 2, hIcon,
940 GetSystemMetrics(SM_CXSMICON),
941 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
942 }
943 return (hIcon != 0);
944 }
945
946
947 /******************************************************************************
948 *
949 * void NC_DrawCloseButton95(
950 * HWND hwnd,
951 * HDC hdc,
952 * BOOL down,
953 * BOOL bGrayed )
954 *
955 * Draws the Win95 close button.
956 *
957 * If bGrayed is true, then draw a disabled Close button
958 *
959 * Revision history
960 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
961 * Original implementation from NC_DrawSysButton95 source.
962 *
963 *****************************************************************************/
964
965 static void NC_DrawCloseButton95 (HWND hwnd, HDC hdc, BOOL down, BOOL bGrayed)
966 {
967 RECT rect;
968
969 NC_GetInsideRect( hwnd, &rect );
970
971 /* A tool window has a smaller Close button */
972 if (GetWindowLongA( hwnd, GWL_EXSTYLE ) & WS_EX_TOOLWINDOW)
973 {
974 INT iBmpHeight = 11; /* Windows does not use SM_CXSMSIZE and SM_CYSMSIZE */
975 INT iBmpWidth = 11; /* it uses 11x11 for the close button in tool window */
976 INT iCaptionHeight = GetSystemMetrics(SM_CYSMCAPTION);
977
978 rect.top = rect.top + (iCaptionHeight - 1 - iBmpHeight) / 2;
979 rect.left = rect.right - (iCaptionHeight + 1 + iBmpWidth) / 2;
980 rect.bottom = rect.top + iBmpHeight;
981 rect.right = rect.left + iBmpWidth;
982 }
983 else
984 {
985 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE) - 1;
986 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
987 rect.top += 2;
988 rect.right -= 2;
989 }
990 DrawFrameControl( hdc, &rect, DFC_CAPTION,
991 (DFCS_CAPTIONCLOSE |
992 (down ? DFCS_PUSHED : 0) |
993 (bGrayed ? DFCS_INACTIVE : 0)) );
994 }
995
996 /******************************************************************************
997 * NC_DrawMaxButton95
998 *
999 * Draws the maximize button for Win95 style windows.
1000 * If bGrayed is true, then draw a disabled Maximize button
1001 */
1002 static void NC_DrawMaxButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1003 {
1004 RECT rect;
1005 UINT flags = IsZoomed(hwnd) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMAX;
1006
1007 NC_GetInsideRect( hwnd, &rect );
1008 if (GetWindowLongA( hwnd, GWL_STYLE) & WS_SYSMENU)
1009 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1010 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
1011 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
1012 rect.top += 2;
1013 rect.right -= 2;
1014 if (down) flags |= DFCS_PUSHED;
1015 if (bGrayed) flags |= DFCS_INACTIVE;
1016 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
1017 }
1018
1019 /******************************************************************************
1020 * NC_DrawMinButton95
1021 *
1022 * Draws the minimize button for Win95 style windows.
1023 * If bGrayed is true, then draw a disabled Minimize button
1024 */
1025 static void NC_DrawMinButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1026 {
1027 RECT rect;
1028 UINT flags = DFCS_CAPTIONMIN;
1029 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
1030
1031 NC_GetInsideRect( hwnd, &rect );
1032 if (style & WS_SYSMENU)
1033 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1034 if (style & (WS_MAXIMIZEBOX|WS_MINIMIZEBOX))
1035 rect.right -= GetSystemMetrics(SM_CXSIZE) - 2;
1036 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
1037 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
1038 rect.top += 2;
1039 rect.right -= 2;
1040 if (down) flags |= DFCS_PUSHED;
1041 if (bGrayed) flags |= DFCS_INACTIVE;
1042 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
1043 }
1044
1045 /***********************************************************************
1046 * NC_DrawFrame
1047 *
1048 * Draw a window frame inside the given rectangle, and update the rectangle.
1049 * The correct pen for the frame must be selected in the DC.
1050 */
1051 static void NC_DrawFrame( HDC hdc, RECT *rect, BOOL dlgFrame,
1052 BOOL active )
1053 {
1054 INT width, height;
1055
1056 if (TWEAK_WineLook != WIN31_LOOK)
1057 ERR("Called in Win95 mode. Aiee! Please report this.\n" );
1058
1059 if (dlgFrame)
1060 {
1061 width = GetSystemMetrics(SM_CXDLGFRAME) - 1;
1062 height = GetSystemMetrics(SM_CYDLGFRAME) - 1;
1063 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1064 COLOR_INACTIVECAPTION) );
1065 }
1066 else
1067 {
1068 width = GetSystemMetrics(SM_CXFRAME) - 2;
1069 height = GetSystemMetrics(SM_CYFRAME) - 2;
1070 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1071 COLOR_INACTIVEBORDER) );
1072 }
1073
1074 /* Draw frame */
1075 PatBlt( hdc, rect->left, rect->top,
1076 rect->right - rect->left, height, PATCOPY );
1077 PatBlt( hdc, rect->left, rect->top,
1078 width, rect->bottom - rect->top, PATCOPY );
1079 PatBlt( hdc, rect->left, rect->bottom - 1,
1080 rect->right - rect->left, -height, PATCOPY );
1081 PatBlt( hdc, rect->right - 1, rect->top,
1082 -width, rect->bottom - rect->top, PATCOPY );
1083
1084 if (dlgFrame)
1085 {
1086 InflateRect( rect, -width, -height );
1087 }
1088 else
1089 {
1090 INT decYOff = GetSystemMetrics(SM_CXFRAME) + GetSystemMetrics(SM_CXSIZE) - 1;
1091 INT decXOff = GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYSIZE) - 1;
1092
1093 /* Draw inner rectangle */
1094
1095 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1096 Rectangle( hdc, rect->left + width, rect->top + height,
1097 rect->right - width , rect->bottom - height );
1098
1099 /* Draw the decorations */
1100
1101 MoveToEx( hdc, rect->left, rect->top + decYOff, NULL );
1102 LineTo( hdc, rect->left + width, rect->top + decYOff );
1103 MoveToEx( hdc, rect->right - 1, rect->top + decYOff, NULL );
1104 LineTo( hdc, rect->right - width - 1, rect->top + decYOff );
1105 MoveToEx( hdc, rect->left, rect->bottom - decYOff, NULL );
1106 LineTo( hdc, rect->left + width, rect->bottom - decYOff );
1107 MoveToEx( hdc, rect->right - 1, rect->bottom - decYOff, NULL );
1108 LineTo( hdc, rect->right - width - 1, rect->bottom - decYOff );
1109
1110 MoveToEx( hdc, rect->left + decXOff, rect->top, NULL );
1111 LineTo( hdc, rect->left + decXOff, rect->top + height);
1112 MoveToEx( hdc, rect->left + decXOff, rect->bottom - 1, NULL );
1113 LineTo( hdc, rect->left + decXOff, rect->bottom - height - 1 );
1114 MoveToEx( hdc, rect->right - decXOff, rect->top, NULL );
1115 LineTo( hdc, rect->right - decXOff, rect->top + height );
1116 MoveToEx( hdc, rect->right - decXOff, rect->bottom - 1, NULL );
1117 LineTo( hdc, rect->right - decXOff, rect->bottom - height - 1 );
1118
1119 InflateRect( rect, -width - 1, -height - 1 );
1120 }
1121 }
1122
1123
1124 /******************************************************************************
1125 *
1126 * void NC_DrawFrame95(
1127 * HDC hdc,
1128 * RECT *rect,
1129 * BOOL active,
1130 * DWORD style,
1131 * DWORD exStyle )
1132 *
1133 * Draw a window frame inside the given rectangle, and update the rectangle.
1134 *
1135 * Bugs
1136 * Many. First, just what IS a frame in Win95? Note that the 3D look
1137 * on the outer edge is handled by NC_DoNCPaint95. As is the inner
1138 * edge. The inner rectangle just inside the frame is handled by the
1139 * Caption code.
1140 *
1141 * In short, for most people, this function should be a nop (unless
1142 * you LIKE thick borders in Win95/NT4.0 -- I've been working with
1143 * them lately, but just to get this code right). Even so, it doesn't
1144 * appear to be so. It's being worked on...
1145 *
1146 * Revision history
1147 * 06-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1148 * Original implementation (based on NC_DrawFrame)
1149 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1150 * Some minor fixes.
1151 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1152 * Fixed a fix or something.
1153 *
1154 *****************************************************************************/
1155
1156 static void NC_DrawFrame95(
1157 HDC hdc,
1158 RECT *rect,
1159 BOOL active,
1160 DWORD style,
1161 DWORD exStyle)
1162 {
1163 INT width, height;
1164
1165 /* Firstly the "thick" frame */
1166 if (style & WS_THICKFRAME)
1167 {
1168 width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXDLGFRAME);
1169 height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYDLGFRAME);
1170
1171 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1172 COLOR_INACTIVEBORDER) );
1173 /* Draw frame */
1174 PatBlt( hdc, rect->left, rect->top,
1175 rect->right - rect->left, height, PATCOPY );
1176 PatBlt( hdc, rect->left, rect->top,
1177 width, rect->bottom - rect->top, PATCOPY );
1178 PatBlt( hdc, rect->left, rect->bottom - 1,
1179 rect->right - rect->left, -height, PATCOPY );
1180 PatBlt( hdc, rect->right - 1, rect->top,
1181 -width, rect->bottom - rect->top, PATCOPY );
1182
1183 InflateRect( rect, -width, -height );
1184 }
1185
1186 /* Now the other bit of the frame */
1187 if ((style & (WS_BORDER|WS_DLGFRAME)) ||
1188 (exStyle & WS_EX_DLGMODALFRAME))
1189 {
1190 width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
1191 height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
1192 /* This should give a value of 1 that should also work for a border */
1193
1194 SelectObject( hdc, GetSysColorBrush(
1195 (exStyle & (WS_EX_DLGMODALFRAME|WS_EX_CLIENTEDGE)) ?
1196 COLOR_3DFACE :
1197 (exStyle & WS_EX_STATICEDGE) ?
1198 COLOR_WINDOWFRAME :
1199 (style & (WS_DLGFRAME|WS_THICKFRAME)) ?
1200 COLOR_3DFACE :
1201 /* else */
1202 COLOR_WINDOWFRAME));
1203
1204 /* Draw frame */
1205 PatBlt( hdc, rect->left, rect->top,
1206 rect->right - rect->left, height, PATCOPY );
1207 PatBlt( hdc, rect->left, rect->top,
1208 width, rect->bottom - rect->top, PATCOPY );
1209 PatBlt( hdc, rect->left, rect->bottom - 1,
1210 rect->right - rect->left, -height, PATCOPY );
1211 PatBlt( hdc, rect->right - 1, rect->top,
1212 -width, rect->bottom - rect->top, PATCOPY );
1213
1214 InflateRect( rect, -width, -height );
1215 }
1216 }
1217
1218
1219 /***********************************************************************
1220 * NC_DrawCaption
1221 *
1222 * Draw the window caption.
1223 * The correct pen for the window frame must be selected in the DC.
1224 */
1225 static void NC_DrawCaption( HDC hdc, RECT *rect, HWND hwnd,
1226 DWORD style, BOOL active )
1227 {
1228 RECT r = *rect;
1229 char buffer[256];
1230
1231 if (!hbitmapClose)
1232 {
1233 if (!(hbitmapClose = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_OLD_CLOSE) ))) return;
1234 }
1235
1236 if (GetWindowLongA( hwnd, GWL_EXSTYLE) & WS_EX_DLGMODALFRAME)
1237 {
1238 HBRUSH hbrushOld = SelectObject(hdc, GetSysColorBrush(COLOR_WINDOW) );
1239 PatBlt( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
1240 PatBlt( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
1241 PatBlt( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
1242 r.left++;
1243 r.right--;
1244 SelectObject( hdc, hbrushOld );
1245 }
1246 MoveToEx( hdc, r.left, r.bottom, NULL );
1247 LineTo( hdc, r.right, r.bottom );
1248
1249 if (style & WS_SYSMENU)
1250 {
1251 NC_DrawSysButton( hwnd, hdc, FALSE );
1252 r.left += GetSystemMetrics(SM_CXSIZE) + 1;
1253 MoveToEx( hdc, r.left - 1, r.top, NULL );
1254 LineTo( hdc, r.left - 1, r.bottom );
1255 }
1256 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION) );
1257 if (style & WS_MAXIMIZEBOX)
1258 {
1259 NC_DrawMaxButton( hwnd, hdc, FALSE );
1260 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1261 }
1262 if (style & WS_MINIMIZEBOX)
1263 {
1264 NC_DrawMinButton( hwnd, hdc, FALSE );
1265 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1266 }
1267
1268 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) ))
1269 {
1270 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1271 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1272 SetBkMode( hdc, TRANSPARENT );
1273 DrawTextA( hdc, buffer, -1, &r,
1274 DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX );
1275 }
1276 }
1277
1278
1279 /******************************************************************************
1280 *
1281 * NC_DrawCaption95(
1282 * HDC hdc,
1283 * RECT *rect,
1284 * HWND hwnd,
1285 * DWORD style,
1286 * BOOL active )
1287 *
1288 * Draw the window caption for Win95 style windows.
1289 * The correct pen for the window frame must be selected in the DC.
1290 *
1291 * Bugs
1292 * Hey, a function that finally works! Well, almost.
1293 * It's being worked on.
1294 *
1295 * Revision history
1296 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1297 * Original implementation.
1298 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1299 * Some minor fixes.
1300 *
1301 *****************************************************************************/
1302
1303 static void NC_DrawCaption95(
1304 HDC hdc,
1305 RECT *rect,
1306 HWND hwnd,
1307 DWORD style,
1308 DWORD exStyle,
1309 BOOL active )
1310 {
1311 RECT r = *rect;
1312 char buffer[256];
1313 HPEN hPrevPen;
1314 HMENU hSysMenu;
1315
1316 hPrevPen = SelectObject( hdc, SYSCOLOR_GetPen(
1317 ((exStyle & (WS_EX_STATICEDGE|WS_EX_CLIENTEDGE|
1318 WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE) ?
1319 COLOR_WINDOWFRAME : COLOR_3DFACE) );
1320 MoveToEx( hdc, r.left, r.bottom - 1, NULL );
1321 LineTo( hdc, r.right, r.bottom - 1 );
1322 SelectObject( hdc, hPrevPen );
1323 r.bottom--;
1324
1325 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1326 COLOR_INACTIVECAPTION) );
1327
1328 if ((style & WS_SYSMENU) && !(exStyle & WS_EX_TOOLWINDOW)) {
1329 if (NC_DrawSysButton95 (hwnd, hdc, FALSE))
1330 r.left += GetSystemMetrics(SM_CYCAPTION) - 1;
1331 }
1332
1333 if (style & WS_SYSMENU)
1334 {
1335 UINT state;
1336
1337 /* Go get the sysmenu */
1338 hSysMenu = GetSystemMenu(hwnd, FALSE);
1339 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1340
1341 /* Draw a grayed close button if disabled and a normal one if SC_CLOSE is not there */
1342 NC_DrawCloseButton95 (hwnd, hdc, FALSE,
1343 ((((state & MF_DISABLED) || (state & MF_GRAYED))) && (state != 0xFFFFFFFF)));
1344 r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
1345
1346 if ((style & WS_MAXIMIZEBOX) || (style & WS_MINIMIZEBOX))
1347 {
1348 /* In win95 the two buttons are always there */
1349 /* But if the menu item is not in the menu they're disabled*/
1350
1351 NC_DrawMaxButton95( hwnd, hdc, FALSE, (!(style & WS_MAXIMIZEBOX)));
1352 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1353
1354 NC_DrawMinButton95( hwnd, hdc, FALSE, (!(style & WS_MINIMIZEBOX)));
1355 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1356 }
1357 }
1358
1359 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) )) {
1360 NONCLIENTMETRICSA nclm;
1361 HFONT hFont, hOldFont;
1362 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
1363 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
1364 if (exStyle & WS_EX_TOOLWINDOW)
1365 hFont = CreateFontIndirectA (&nclm.lfSmCaptionFont);
1366 else
1367 hFont = CreateFontIndirectA (&nclm.lfCaptionFont);
1368 hOldFont = SelectObject (hdc, hFont);
1369 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1370 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1371 SetBkMode( hdc, TRANSPARENT );
1372 r.left += 2;
1373 DrawTextA( hdc, buffer, -1, &r,
1374 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
1375 DeleteObject (SelectObject (hdc, hOldFont));
1376 }
1377 }
1378
1379
1380
1381 /***********************************************************************
1382 * NC_DoNCPaint
1383 *
1384 * Paint the non-client area. clip is currently unused.
1385 */
1386 static void NC_DoNCPaint( HWND hwnd, HRGN clip, BOOL suppress_menupaint )
1387 {
1388 HDC hdc;
1389 RECT rect;
1390 BOOL active;
1391 WND *wndPtr;
1392 DWORD dwStyle, dwExStyle;
1393 WORD flags;
1394 RECT rectClient, rectWindow;
1395 int has_menu;
1396
1397 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return;
1398 has_menu = HAS_MENU(wndPtr);
1399 dwStyle = wndPtr->dwStyle;
1400 dwExStyle = wndPtr->dwExStyle;
1401 flags = wndPtr->flags;
1402 rectClient = wndPtr->rectClient;
1403 rectWindow = wndPtr->rectWindow;
1404 WIN_ReleasePtr( wndPtr );
1405
1406 if ( dwStyle & WS_MINIMIZE ||
1407 !WIN_IsWindowDrawable( hwnd, 0 )) return; /* Nothing to do */
1408
1409 active = flags & WIN_NCACTIVATED;
1410
1411 TRACE("%04x %d\n", hwnd, active );
1412
1413 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1414 ((clip > 1) ? (DCX_INTERSECTRGN | DCX_KEEPCLIPRGN): 0) ))) return;
1415
1416 if (ExcludeVisRect16( hdc, rectClient.left-rectWindow.left,
1417 rectClient.top-rectWindow.top,
1418 rectClient.right-rectWindow.left,
1419 rectClient.bottom-rectWindow.top )
1420 == NULLREGION)
1421 {
1422 ReleaseDC( hwnd, hdc );
1423 return;
1424 }
1425
1426 rect.top = rect.left = 0;
1427 rect.right = rectWindow.right - rectWindow.left;
1428 rect.bottom = rectWindow.bottom - rectWindow.top;
1429
1430 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1431
1432 if (HAS_ANYFRAME( dwStyle, dwExStyle ))
1433 {
1434 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1435 Rectangle( hdc, 0, 0, rect.right, rect.bottom );
1436 InflateRect( &rect, -1, -1 );
1437 }
1438
1439 if (HAS_THICKFRAME( dwStyle, dwExStyle ))
1440 NC_DrawFrame(hdc, &rect, FALSE, active );
1441 else if (HAS_DLGFRAME( dwStyle, dwExStyle ))
1442 NC_DrawFrame( hdc, &rect, TRUE, active );
1443
1444 if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1445 {
1446 RECT r = rect;
1447 r.bottom = rect.top + GetSystemMetrics(SM_CYSIZE);
1448 rect.top += GetSystemMetrics(SM_CYSIZE) + GetSystemMetrics(SM_CYBORDER);
1449 NC_DrawCaption( hdc, &r, hwnd, dwStyle, active );
1450 }
1451
1452 if (has_menu)
1453 {
1454 RECT r = rect;
1455 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU); /* default height */
1456 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
1457 }
1458
1459 /* Draw the scroll-bars */
1460
1461 if (dwStyle & WS_VSCROLL)
1462 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1463 if (dwStyle & WS_HSCROLL)
1464 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1465
1466 /* Draw the "size-box" */
1467
1468 if ((dwStyle & WS_VSCROLL) && (dwStyle & WS_HSCROLL))
1469 {
1470 RECT r = rect;
1471 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1472 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1473 if(wndPtr->dwStyle & WS_BORDER) {
1474 r.left++;
1475 r.top++;
1476 }
1477 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1478 }
1479
1480 ReleaseDC( hwnd, hdc );
1481 }
1482
1483
1484 /******************************************************************************
1485 *
1486 * void NC_DoNCPaint95(
1487 * HWND hwnd,
1488 * HRGN clip,
1489 * BOOL suppress_menupaint )
1490 *
1491 * Paint the non-client area for Win95 windows. The clip region is
1492 * currently ignored.
1493 *
1494 * Bugs
1495 * grep -E -A10 -B5 \(95\)\|\(Bugs\)\|\(FIXME\) windows/nonclient.c \
1496 * misc/tweak.c controls/menu.c # :-)
1497 *
1498 * Revision history
1499 * 03-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1500 * Original implementation
1501 * 10-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1502 * Fixed some bugs.
1503 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1504 * Streamlined window style checks.
1505 *
1506 *****************************************************************************/
1507
1508 static void NC_DoNCPaint95(
1509 HWND hwnd,
1510 HRGN clip,
1511 BOOL suppress_menupaint )
1512 {
1513 HDC hdc;
1514 RECT rfuzz, rect, rectClip;
1515 BOOL active;
1516 WND *wndPtr;
1517 DWORD dwStyle, dwExStyle;
1518 WORD flags;
1519 RECT rectClient, rectWindow;
1520 int has_menu;
1521
1522 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return;
1523 has_menu = HAS_MENU(wndPtr);
1524 dwStyle = wndPtr->dwStyle;
1525 dwExStyle = wndPtr->dwExStyle;
1526 flags = wndPtr->flags;
1527 rectClient = wndPtr->rectClient;
1528 rectWindow = wndPtr->rectWindow;
1529 WIN_ReleasePtr( wndPtr );
1530
1531 if ( dwStyle & WS_MINIMIZE ||
1532 !WIN_IsWindowDrawable( hwnd, 0 )) return; /* Nothing to do */
1533
1534 active = flags & WIN_NCACTIVATED;
1535
1536 TRACE("%04x %d\n", hwnd, active );
1537
1538 /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
1539 the call to GetDCEx implying that it is allowed not to use it either.
1540 However, the suggested GetDCEx( , DCX_WINDOW | DCX_INTERSECTRGN)
1541 will cause clipRgn to be deleted after ReleaseDC().
1542 Now, how is the "system" supposed to tell what happened?
1543 */
1544
1545 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1546 ((clip > 1) ?(DCX_INTERSECTRGN | DCX_KEEPCLIPRGN) : 0) ))) return;
1547
1548
1549 if (ExcludeVisRect16( hdc, rectClient.left-rectWindow.left,
1550 rectClient.top-rectWindow.top,
1551 rectClient.right-rectWindow.left,
1552 rectClient.bottom-rectWindow.top )
1553 == NULLREGION)
1554 {
1555 ReleaseDC( hwnd, hdc );
1556 return;
1557 }
1558
1559 rect.top = rect.left = 0;
1560 rect.right = rectWindow.right - rectWindow.left;
1561 rect.bottom = rectWindow.bottom - rectWindow.top;
1562
1563 if( clip > 1 )
1564 GetRgnBox( clip, &rectClip );
1565 else
1566 {
1567 clip = 0;
1568 rectClip = rect;
1569 }
1570
1571 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1572
1573 if (HAS_STATICOUTERFRAME(dwStyle, dwExStyle)) {
1574 DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1575 }
1576 else if (HAS_BIGFRAME( dwStyle, dwExStyle)) {
1577 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1578 }
1579
1580 NC_DrawFrame95(hdc, &rect, active, dwStyle, dwExStyle );
1581
1582 if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1583 {
1584 RECT r = rect;
1585 if (dwExStyle & WS_EX_TOOLWINDOW) {
1586 r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
1587 rect.top += GetSystemMetrics(SM_CYSMCAPTION);
1588 }
1589 else {
1590 r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
1591 rect.top += GetSystemMetrics(SM_CYCAPTION);
1592 }
1593 if( !clip || IntersectRect( &rfuzz, &r, &rectClip ) )
1594 NC_DrawCaption95 (hdc, &r, hwnd, dwStyle,
1595 dwExStyle, active);
1596 }
1597
1598 if (has_menu)
1599 {
1600 RECT r = rect;
1601 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
1602
1603 TRACE("Calling DrawMenuBar with rect (%d, %d)-(%d, %d)\n",
1604 r.left, r.top, r.right, r.bottom);
1605
1606 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
1607 }
1608
1609 TRACE("After MenuBar, rect is (%d, %d)-(%d, %d).\n",
1610 rect.left, rect.top, rect.right, rect.bottom );
1611
1612 if (dwExStyle & WS_EX_CLIENTEDGE)
1613 DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1614
1615 /* Draw the scroll-bars */
1616
1617 if (dwStyle & WS_VSCROLL)
1618 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1619 if (dwStyle & WS_HSCROLL)
1620 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1621
1622 /* Draw the "size-box" */
1623 if ((dwStyle & WS_VSCROLL) && (dwStyle & WS_HSCROLL))
1624 {
1625 RECT r = rect;
1626 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1627 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1628 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1629 }
1630
1631 ReleaseDC( hwnd, hdc );
1632 }
1633
1634
1635
1636
1637 /***********************************************************************
1638 * NC_HandleNCPaint
1639 *
1640 * Handle a WM_NCPAINT message. Called from DefWindowProc().
1641 */
1642 LONG NC_HandleNCPaint( HWND hwnd , HRGN clip)
1643 {
1644 DWORD dwStyle = GetWindowLongW( hwnd, GWL_STYLE );
1645
1646 if( dwStyle & WS_VISIBLE )
1647 {
1648 if( dwStyle & WS_MINIMIZE )
1649 WINPOS_RedrawIconTitle( hwnd );
1650 else if (TWEAK_WineLook == WIN31_LOOK)
1651 NC_DoNCPaint( hwnd, clip, FALSE );
1652 else
1653 NC_DoNCPaint95( hwnd, clip, FALSE );
1654 }
1655 return 0;
1656 }
1657
1658
1659 /***********************************************************************
1660 * NC_HandleNCActivate
1661 *
1662 * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1663 */
1664 LONG NC_HandleNCActivate( HWND hwnd, WPARAM wParam )
1665 {
1666 WND* wndPtr = WIN_FindWndPtr( hwnd );
1667
1668 /* Lotus Notes draws menu descriptions in the caption of its main
1669 * window. When it wants to restore original "system" view, it just
1670 * sends WM_NCACTIVATE message to itself. Any optimizations here in
1671 * attempt to minimize redrawings lead to a not restored caption.
1672 */
1673 if (wndPtr)
1674 {
1675 if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1676 else wndPtr->flags &= ~WIN_NCACTIVATED;
1677 WIN_ReleaseWndPtr(wndPtr);
1678
1679 if (IsIconic(hwnd)) WINPOS_RedrawIconTitle( hwnd );
1680 else if (TWEAK_WineLook == WIN31_LOOK)
1681 NC_DoNCPaint( hwnd, (HRGN)1, FALSE );
1682 else
1683 NC_DoNCPaint95( hwnd, (HRGN)1, FALSE );
1684 }
1685 return TRUE;
1686 }
1687
1688
1689 /***********************************************************************
1690 * NC_HandleSetCursor
1691 *
1692 * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1693 */
1694 LONG NC_HandleSetCursor( HWND hwnd, WPARAM wParam, LPARAM lParam )
1695 {
1696 hwnd = WIN_GetFullHandle( (HWND)wParam );
1697
1698 switch(LOWORD(lParam))
1699 {
1700 case HTERROR:
1701 {
1702 WORD msg = HIWORD( lParam );
1703 if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1704 (msg == WM_RBUTTONDOWN))
1705 MessageBeep(0);
1706 }
1707 break;
1708
1709 case HTCLIENT:
1710 {
1711 HCURSOR hCursor = GetClassLongA(hwnd, GCL_HCURSOR);
1712 if(hCursor) {
1713 SetCursor(hCursor);
1714 return TRUE;
1715 }
1716 return FALSE;
1717 }
1718
1719 case HTLEFT:
1720 case HTRIGHT:
1721 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZEWEA ) );
1722
1723 case HTTOP:
1724 case HTBOTTOM:
1725 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZENSA ) );
1726
1727 case HTTOPLEFT:
1728 case HTBOTTOMRIGHT:
1729 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZENWSEA ) );
1730
1731 case HTTOPRIGHT:
1732 case HTBOTTOMLEFT:
1733 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZENESWA ) );
1734 }
1735
1736 /* Default cursor: arrow */
1737 return (LONG)SetCursor( LoadCursorA( 0, IDC_ARROWA ) );
1738 }
1739
1740 /***********************************************************************
1741 * NC_GetSysPopupPos
1742 */
1743 void NC_GetSysPopupPos( HWND hwnd, RECT* rect )
1744 {
1745 if (IsIconic(hwnd)) GetWindowRect( hwnd, rect );
1746 else
1747 {
1748 WND *wndPtr = WIN_FindWndPtr( hwnd );
1749 if (!wndPtr) return;
1750
1751 NC_GetInsideRect( hwnd, rect );
1752 OffsetRect( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
1753 if (wndPtr->dwStyle & WS_CHILD)
1754 ClientToScreen( GetParent(hwnd), (POINT *)rect );
1755 if (TWEAK_WineLook == WIN31_LOOK) {
1756 rect->right = rect->left + GetSystemMetrics(SM_CXSIZE);
1757 rect->bottom = rect->top + GetSystemMetrics(SM_CYSIZE);
1758 }
1759 else {
1760 rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
1761 rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
1762 }
1763 WIN_ReleaseWndPtr( wndPtr );
1764 }
1765 }
1766
1767 /***********************************************************************
1768 * NC_TrackMinMaxBox95
1769 *
1770 * Track a mouse button press on the minimize or maximize box.
1771 *
1772 * The big difference between 3.1 and 95 is the disabled button state.
1773 * In win95 the system button can be disabled, so it can ignore the mouse
1774 * event.
1775 *
1776 */
1777 static void NC_TrackMinMaxBox95( HWND hwnd, WORD wParam )
1778 {
1779 MSG msg;
1780 HDC hdc = GetWindowDC( hwnd );
1781 BOOL pressed = TRUE;
1782 UINT state;
1783 DWORD wndStyle = GetWindowLongA( hwnd, GWL_STYLE);
1784 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1785
1786 void (*paintButton)(HWND, HDC16, BOOL, BOOL);
1787
1788 if (wParam == HTMINBUTTON)
1789 {
1790 /* If the style is not present, do nothing */
1791 if (!(wndStyle & WS_MINIMIZEBOX))
1792 return;
1793
1794 /* Check if the sysmenu item for minimize is there */
1795 state = GetMenuState(hSysMenu, SC_MINIMIZE, MF_BYCOMMAND);
1796
1797 paintButton = &NC_DrawMinButton95;
1798 }
1799 else
1800 {
1801 /* If the style is not present, do nothing */
1802 if (!(wndStyle & WS_MAXIMIZEBOX))
1803 return;
1804
1805 /* Check if the sysmenu item for maximize is there */
1806 state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
1807
1808 paintButton = &NC_DrawMaxButton95;
1809 }
1810
1811 SetCapture( hwnd );
1812
1813 (*paintButton)( hwnd, hdc, TRUE, FALSE);
1814
1815 while(1)
1816 {
1817 BOOL oldstate = pressed;
1818
1819 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1820 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1821
1822 if(msg.message == WM_LBUTTONUP)
1823 break;
1824
1825 if(msg.message != WM_MOUSEMOVE)
1826 continue;
1827
1828 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1829 if (pressed != oldstate)
1830 (*paintButton)( hwnd, hdc, pressed, FALSE);
1831 }
1832
1833 if(pressed)
1834 (*paintButton)(hwnd, hdc, FALSE, FALSE);
1835
1836 ReleaseCapture();
1837 ReleaseDC( hwnd, hdc );
1838
1839 /* If the item minimize or maximize of the sysmenu are not there */
1840 /* or if the style is not present, do nothing */
1841 if ((!pressed) || (state == 0xFFFFFFFF))
1842 return;
1843
1844 if (wParam == HTMINBUTTON)
1845 SendMessageA( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1846 else
1847 SendMessageA( hwnd, WM_SYSCOMMAND,
1848 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1849 }
1850
1851 /***********************************************************************
1852 * NC_TrackMinMaxBox
1853 *
1854 * Track a mouse button press on the minimize or maximize box.
1855 */
1856 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
1857 {
1858 MSG msg;
1859 HDC hdc = GetWindowDC( hwnd );
1860 BOOL pressed = TRUE;
1861 void (*paintButton)(HWND, HDC16, BOOL);
1862
1863 SetCapture( hwnd );
1864
1865 if (wParam == HTMINBUTTON)
1866 paintButton = &NC_DrawMinButton;
1867 else
1868 paintButton = &NC_DrawMaxButton;
1869
1870 (*paintButton)( hwnd, hdc, TRUE);
1871
1872 while(1)
1873 {
1874 BOOL oldstate = pressed;
1875
1876 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1877 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1878
1879 if(msg.message == WM_LBUTTONUP)
1880 break;
1881
1882 if(msg.message != WM_MOUSEMOVE)
1883 continue;
1884
1885 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1886 if (pressed != oldstate)
1887 (*paintButton)( hwnd, hdc, pressed);
1888 }
1889
1890 if(pressed)
1891 (*paintButton)( hwnd, hdc, FALSE);
1892
1893 ReleaseCapture();
1894 ReleaseDC( hwnd, hdc );
1895
1896 if (!pressed) return;
1897
1898 if (wParam == HTMINBUTTON)
1899 SendMessageA( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1900 else
1901 SendMessageA( hwnd, WM_SYSCOMMAND,
1902 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1903 }
1904
1905
1906 /***********************************************************************
1907 * NC_TrackCloseButton95
1908 *
1909 * Track a mouse button press on the Win95 close button.
1910 */
1911 static void
1912 NC_TrackCloseButton95 (HWND hwnd, WORD wParam)
1913 {
1914 MSG msg;
1915 HDC hdc;
1916 BOOL pressed = TRUE;
1917 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1918 UINT state;
1919
1920 if(hSysMenu == 0)
1921 return;
1922
1923 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1924
1925 /* If the item close of the sysmenu is disabled or not there do nothing */
1926 if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
1927 return;
1928
1929 hdc = GetWindowDC( hwnd );
1930
1931 SetCapture( hwnd );
1932
1933 NC_DrawCloseButton95 (hwnd, hdc, TRUE, FALSE);
1934
1935 while(1)
1936 {
1937 BOOL oldstate = pressed;
1938
1939 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1940 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1941
1942 if(msg.message == WM_LBUTTONUP)
1943 break;
1944
1945 if(msg.message != WM_MOUSEMOVE)
1946 continue;
1947
1948 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1949 if (pressed != oldstate)
1950 NC_DrawCloseButton95 (hwnd, hdc, pressed, FALSE);
1951 }
1952
1953 if(pressed)
1954 NC_DrawCloseButton95 (hwnd, hdc, FALSE, FALSE);
1955
1956 ReleaseCapture();
1957 ReleaseDC( hwnd, hdc );
1958 if (!pressed) return;
1959
1960 SendMessageA( hwnd, WM_SYSCOMMAND, SC_CLOSE, MAKELONG(msg.pt.x,msg.pt.y) );
1961 }
1962
1963
1964 /***********************************************************************
1965 * NC_TrackScrollBar
1966 *
1967 * Track a mouse button press on the horizontal or vertical scroll-bar.
1968 */
1969 static void NC_TrackScrollBar( HWND hwnd, WPARAM wParam, POINT pt )
1970 {
1971 INT scrollbar;
1972
1973 if ((wParam & 0xfff0) == SC_HSCROLL)
1974 {
1975 if ((wParam & 0x0f) != HTHSCROLL) return;
1976 scrollbar = SB_HORZ;
1977 }
1978 else /* SC_VSCROLL */
1979 {
1980 if ((wParam & 0x0f) != HTVSCROLL) return;
1981 scrollbar = SB_VERT;
1982 }
1983 SCROLL_TrackScrollBar( hwnd, scrollbar, pt );
1984 }
1985
1986
1987 /***********************************************************************
1988 * NC_HandleNCLButtonDown
1989 *
1990 * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
1991 */
1992 LONG NC_HandleNCLButtonDown( HWND hwnd, WPARAM wParam, LPARAM lParam )
1993 {
1994 LONG style = GetWindowLongA( hwnd, GWL_STYLE );
1995
1996 switch(wParam) /* Hit test */
1997 {
1998 case HTCAPTION:
1999 {
2000 HWND top = GetAncestor( hwnd, GA_ROOT );
2001
2002 if( WINPOS_SetActiveWindow(top, TRUE, TRUE) || (GetActiveWindow() == top) )
2003 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
2004 break;
2005 }
2006
2007 case HTSYSMENU:
2008 if( style & WS_SYSMENU )
2009 {
2010 if( !(style & WS_MINIMIZE) )
2011 {
2012 HDC hDC = GetWindowDC(hwnd);
2013 if (TWEAK_WineLook == WIN31_LOOK)
2014 NC_DrawSysButton( hwnd, hDC, TRUE );
2015 else
2016 NC_DrawSysButton95( hwnd, hDC, TRUE );
2017 ReleaseDC( hwnd, hDC );
2018 }
2019 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
2020 }
2021 break;
2022
2023 case HTMENU:
2024 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
2025 break;
2026
2027 case HTHSCROLL:
2028 SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2029 break;
2030
2031 case HTVSCROLL:
2032 SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2033 break;
2034
2035 case HTMINBUTTON:
2036 case HTMAXBUTTON:
2037 if (TWEAK_WineLook == WIN31_LOOK)
2038 NC_TrackMinMaxBox( hwnd, wParam );
2039 else
2040 NC_TrackMinMaxBox95( hwnd, wParam );
2041 break;
2042
2043 case HTCLOSE:
2044 if (TWEAK_WineLook >= WIN95_LOOK)
2045 NC_TrackCloseButton95 (hwnd, wParam);
2046 break;
2047
2048 case HTLEFT:
2049 case HTRIGHT:
2050 case HTTOP:
2051 case HTTOPLEFT:
2052 case HTTOPRIGHT:
2053 case HTBOTTOM:
2054 case HTBOTTOMLEFT:
2055 case HTBOTTOMRIGHT:
2056 /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */
2057 SendMessageW( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - 2, lParam);
2058 break;
2059
2060 case HTBORDER:
2061 break;
2062 }
2063 return 0;
2064 }
2065
2066
2067 /***********************************************************************
2068 * NC_HandleNCLButtonDblClk
2069 *
2070 * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
2071 */
2072 LONG NC_HandleNCLButtonDblClk( HWND hwnd, WPARAM wParam, LPARAM lParam )
2073 {
2074 /*
2075 * if this is an icon, send a restore since we are handling
2076 * a double click
2077 */
2078 if (IsIconic(hwnd))
2079 {
2080 SendMessageW( hwnd, WM_SYSCOMMAND, SC_RESTORE, lParam );
2081 return 0;
2082 }
2083
2084 switch(wParam) /* Hit test */
2085 {
2086 case HTCAPTION:
2087 /* stop processing if WS_MAXIMIZEBOX is missing */
2088 if (GetWindowLongA( hwnd, GWL_STYLE ) & WS_MAXIMIZEBOX)
2089 SendMessageW( hwnd, WM_SYSCOMMAND,
2090 IsZoomed(hwnd) ? SC_RESTORE : SC_MAXIMIZE, lParam );
2091 break;
2092
2093 case HTSYSMENU:
2094 if (!(GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE))
2095 SendMessageW( hwnd, WM_SYSCOMMAND, SC_CLOSE, lParam );
2096 break;
2097
2098 case HTHSCROLL:
2099 SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2100 break;
2101
2102 case HTVSCROLL:
2103 SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2104 break;
2105 }
2106 return 0;
2107 }
2108
2109
2110 /***********************************************************************
2111 * NC_HandleSysCommand
2112 *
2113 * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
2114 */
2115 LONG NC_HandleSysCommand( HWND hwnd, WPARAM wParam, LPARAM lParam )
2116 {
2117 TRACE("Handling WM_SYSCOMMAND %x %lx\n", wParam, lParam );
2118
2119 switch (wParam & 0xfff0)
2120 {
2121 case SC_SIZE:
2122 case SC_MOVE:
2123 if (USER_Driver.pSysCommandSizeMove)
2124 USER_Driver.pSysCommandSizeMove( hwnd, wParam );
2125 break;
2126
2127 case SC_MINIMIZE:
2128 if (hwnd == GetForegroundWindow())
2129 ShowOwnedPopups(hwnd,FALSE);
2130 ShowWindow( hwnd, SW_MINIMIZE );
2131 break;
2132
2133 case SC_MAXIMIZE:
2134 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2135 ShowOwnedPopups(hwnd,TRUE);
2136 ShowWindow( hwnd, SW_MAXIMIZE );
2137 break;
2138
2139 case SC_RESTORE:
2140 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2141 ShowOwnedPopups(hwnd,TRUE);
2142 ShowWindow( hwnd, SW_RESTORE );
2143 break;
2144
2145 case SC_CLOSE:
2146 return SendMessageA( hwnd, WM_CLOSE, 0, 0 );
2147
2148 case SC_VSCROLL:
2149 case SC_HSCROLL:
2150 {
2151 POINT pt;
2152 pt.x = SLOWORD(lParam);
2153 pt.y = SHIWORD(lParam);
2154 NC_TrackScrollBar( hwnd, wParam, pt );
2155 }
2156 break;
2157
2158 case SC_MOUSEMENU:
2159 {
2160 POINT pt;
2161 pt.x = SLOWORD(lParam);
2162 pt.y = SHIWORD(lParam);
2163 MENU_TrackMouseMenuBar( hwnd, wParam & 0x000F, pt );
2164 }
2165 break;
2166
2167 case SC_KEYMENU:
2168 MENU_TrackKbdMenuBar( hwnd, wParam, LOWORD(lParam) );
2169 break;
2170
2171 case SC_TASKLIST:
2172 WinExec( "taskman.exe", SW_SHOWNORMAL );
2173 break;
2174
2175 case SC_SCREENSAVE:
2176 if (wParam == SC_ABOUTWINE)
2177 {
2178 HMODULE hmodule = LoadLibraryA( "shell32.dll" );
2179 if (hmodule)
2180 {
2181 FARPROC aboutproc = GetProcAddress( hmodule, "ShellAboutA" );
2182 if (aboutproc) aboutproc( hwnd, PACKAGE_NAME, PACKAGE_STRING, 0 );
2183 FreeLibrary( hmodule );
2184 }
2185 }
2186 else
2187 if (wParam == SC_PUTMARK)
2188 TRACE_(shell)("Mark requested by user\n");
2189 break;
2190
2191 case SC_HOTKEY:
2192 case SC_ARRANGE:
2193 case SC_NEXTWINDOW:
2194 case SC_PREVWINDOW:
2195 FIXME("unimplemented!\n");
2196 break;
2197 }
2198 return 0;
2199 }
2200
2201 /*************************************************************
2202 * NC_DrawGrayButton
2203 *
2204 * Stub for the grayed button of the caption
2205 *
2206 *************************************************************/
2207
2208 BOOL NC_DrawGrayButton(HDC hdc, int x, int y)
2209 {
2210 HBITMAP hMaskBmp;
2211 HDC hdcMask = CreateCompatibleDC (0);
2212 HBRUSH hOldBrush;
2213
2214 hMaskBmp = CreateBitmap (12, 10, 1, 1, lpGrayMask);
2215
2216 if(hMaskBmp == 0)
2217 return FALSE;
2218
2219 SelectObject (hdcMask, hMaskBmp);
2220
2221 /* Draw the grayed bitmap using the mask */
2222 hOldBrush = SelectObject (hdc, RGB(128, 128, 128));
2223 BitBlt (hdc, x, y, 12, 10,
2224 hdcMask, 0, 0, 0xB8074A);
2225
2226 /* Clean up */
2227 SelectObject (hdc, hOldBrush);
2228 DeleteObject(hMaskBmp);
2229 DeleteDC (hdcMask);
2230
2231 return TRUE;
2232 }
Windows API implementation