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