?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winemac: Activate an app if it sets focus on a window shortly after a hot key is...
[wine.git] / dlls / user32 / nonclient.c
blobda9c6bd735c8814366ffd8f70f6889105fd1f51a
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22
23 #include <stdarg.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "wingdi.h"
28 #include "winnls.h"
29 #include "win.h"
30 #include "user_private.h"
31 #include "controls.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(nonclient);
35
36 #define SC_ABOUTWINE (SC_SCREENSAVE+1)
37
38 /* Some useful macros */
39 #define HAS_DLGFRAME(style,exStyle) \
40 (((exStyle) & WS_EX_DLGMODALFRAME) || \
41 (((style) & WS_DLGFRAME) && !((style) & WS_THICKFRAME)))
42
43 #define HAS_THICKFRAME(style,exStyle) \
44 (((style) & WS_THICKFRAME) && \
45 !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
46
47 #define HAS_THINFRAME(style) \
48 (((style) & WS_BORDER) || !((style) & (WS_CHILD | WS_POPUP)))
49
50 #define HAS_BIGFRAME(style,exStyle) \
51 (((style) & (WS_THICKFRAME | WS_DLGFRAME)) || \
52 ((exStyle) & WS_EX_DLGMODALFRAME))
53
54 #define HAS_STATICOUTERFRAME(style,exStyle) \
55 (((exStyle) & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) == \
56 WS_EX_STATICEDGE)
57
58 #define HAS_ANYFRAME(style,exStyle) \
59 (((style) & (WS_THICKFRAME | WS_DLGFRAME | WS_BORDER)) || \
60 ((exStyle) & WS_EX_DLGMODALFRAME) || \
61 !((style) & (WS_CHILD | WS_POPUP)))
62
63 #define HAS_MENU(hwnd,style) ((((style) & (WS_CHILD | WS_POPUP)) != WS_CHILD) && GetMenu(hwnd))
64
65
66 /******************************************************************************
67 * NC_AdjustRectOuter
68 *
69 * Computes the size of the "outside" parts of the window based on the
70 * parameters of the client area.
71 *
72 * PARAMS
73 * LPRECT rect
74 * DWORD style
75 * BOOL menu
76 * DWORD exStyle
77 *
78 * NOTES
79 * "Outer" parts of a window means the whole window frame, caption and
80 * menu bar. It does not include "inner" parts of the frame like client
81 * edge, static edge or scroll bars.
82 *
83 *****************************************************************************/
84
85 static void
86 NC_AdjustRectOuter (LPRECT rect, DWORD style, BOOL menu, DWORD exStyle)
87 {
88 int adjust;
89
90 if ((exStyle & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) ==
91 WS_EX_STATICEDGE)
92 {
93 adjust = 1; /* for the outer frame always present */
94 }
95 else
96 {
97 adjust = 0;
98 if ((exStyle & WS_EX_DLGMODALFRAME) ||
99 (style & (WS_THICKFRAME|WS_DLGFRAME))) adjust = 2; /* outer */
100 }
101 if ((style & WS_THICKFRAME) && !(exStyle & WS_EX_DLGMODALFRAME))
102 adjust += ( GetSystemMetrics (SM_CXFRAME)
103 - GetSystemMetrics (SM_CXDLGFRAME)); /* The resize border */
104 if ((style & (WS_BORDER|WS_DLGFRAME)) ||
105 (exStyle & WS_EX_DLGMODALFRAME))
106 adjust++; /* The other border */
107
108 InflateRect (rect, adjust, adjust);
109
110 if ((style & WS_CAPTION) == WS_CAPTION)
111 {
112 if (exStyle & WS_EX_TOOLWINDOW)
113 rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
114 else
115 rect->top -= GetSystemMetrics(SM_CYCAPTION);
116 }
117 if (menu) rect->top -= GetSystemMetrics(SM_CYMENU);
118 }
119
120
121 /******************************************************************************
122 * NC_AdjustRectInner
123 *
124 * Computes the size of the "inside" part of the window based on the
125 * parameters of the client area.
126 *
127 * PARAMS
128 * LPRECT rect
129 * DWORD style
130 * DWORD exStyle
131 *
132 * NOTES
133 * "Inner" part of a window means the window frame inside of the flat
134 * window frame. It includes the client edge, the static edge and the
135 * scroll bars.
136 *
137 *****************************************************************************/
138
139 static void
140 NC_AdjustRectInner (LPRECT rect, DWORD style, DWORD exStyle)
141 {
142 if (exStyle & WS_EX_CLIENTEDGE)
143 InflateRect(rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
144
145 if (style & WS_VSCROLL)
146 {
147 if((exStyle & WS_EX_LEFTSCROLLBAR) != 0)
148 rect->left -= GetSystemMetrics(SM_CXVSCROLL);
149 else
150 rect->right += GetSystemMetrics(SM_CXVSCROLL);
151 }
152 if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
153 }
154
155
156
157 static HICON NC_IconForWindow( HWND hwnd )
158 {
159 HICON hIcon = 0;
160 WND *wndPtr = WIN_GetPtr( hwnd );
161
162 if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
163 {
164 hIcon = wndPtr->hIconSmall;
165 if (!hIcon) hIcon = wndPtr->hIcon;
166 WIN_ReleasePtr( wndPtr );
167 }
168 if (!hIcon) hIcon = (HICON) GetClassLongPtrW( hwnd, GCLP_HICONSM );
169 if (!hIcon) hIcon = (HICON) GetClassLongPtrW( hwnd, GCLP_HICON );
170
171 /* If there is no hIcon specified and this is a modal dialog,
172 * get the default one.
173 */
174 if (!hIcon && (GetWindowLongW( hwnd, GWL_STYLE ) & DS_MODALFRAME))
175 hIcon = LoadImageW(0, (LPCWSTR)IDI_WINLOGO, IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
176 return hIcon;
177 }
178
179 /* Draws the bar part(ie the big rectangle) of the caption */
180 static void NC_DrawCaptionBar (HDC hdc, const RECT *rect, DWORD dwStyle,
181 BOOL active, BOOL gradient)
182 {
183 if (gradient)
184 {
185 TRIVERTEX vertices[4];
186 DWORD colLeft =
187 GetSysColor (active ? COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION);
188 DWORD colRight =
189 GetSysColor (active ? COLOR_GRADIENTACTIVECAPTION
190 : COLOR_GRADIENTINACTIVECAPTION);
191 int buttonsAreaSize = GetSystemMetrics(SM_CYCAPTION) - 1;
192 static GRADIENT_RECT mesh[] = {{0, 1}, {1, 2}, {2, 3}};
193
194 vertices[0].Red = vertices[1].Red = GetRValue (colLeft) << 8;
195 vertices[0].Green = vertices[1].Green = GetGValue (colLeft) << 8;
196 vertices[0].Blue = vertices[1].Blue = GetBValue (colLeft) << 8;
197 vertices[0].Alpha = vertices[1].Alpha = 0xff00;
198 vertices[2].Red = vertices[3].Red = GetRValue (colRight) << 8;
199 vertices[2].Green = vertices[3].Green = GetGValue (colRight) << 8;
200 vertices[2].Blue = vertices[3].Blue = GetBValue (colRight) << 8;
201 vertices[2].Alpha = vertices[3].Alpha = 0xff00;
202
203 if ((dwStyle & WS_SYSMENU)
204 && ((dwStyle & WS_MAXIMIZEBOX) || (dwStyle & WS_MINIMIZEBOX)))
205 buttonsAreaSize += 2 * (GetSystemMetrics(SM_CXSIZE) + 1);
206
207 /* area behind icon; solid filled with left color */
208 vertices[0].x = rect->left;
209 vertices[0].y = rect->top;
210 if (dwStyle & WS_SYSMENU)
211 vertices[1].x = min (rect->left + GetSystemMetrics(SM_CXSMICON), rect->right);
212 else
213 vertices[1].x = vertices[0].x;
214 vertices[1].y = rect->bottom;
215
216 /* area behind text; gradient */
217 vertices[2].x = max (vertices[1].x, rect->right - buttonsAreaSize);
218 vertices[2].y = rect->top;
219
220 /* area behind buttons; solid filled with right color */
221 vertices[3].x = rect->right;
222 vertices[3].y = rect->bottom;
223
224 GdiGradientFill (hdc, vertices, 4, mesh, 3, GRADIENT_FILL_RECT_H);
225 }
226 else
227 FillRect (hdc, rect, GetSysColorBrush (active ?
228 COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
229 }
230
231 /***********************************************************************
232 * DrawCaption (USER32.@) Draws a caption bar
233 *
234 * PARAMS
235 * hwnd [I]
236 * hdc [I]
237 * lpRect [I]
238 * uFlags [I]
239 *
240 * RETURNS
241 * Success:
242 * Failure:
243 */
244
245 BOOL WINAPI
246 DrawCaption (HWND hwnd, HDC hdc, const RECT *lpRect, UINT uFlags)
247 {
248 return DrawCaptionTempW (hwnd, hdc, lpRect, 0, 0, NULL, uFlags & 0x103F);
249 }
250
251
252 /***********************************************************************
253 * DrawCaptionTempA (USER32.@)
254 */
255 BOOL WINAPI DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
256 HICON hIcon, LPCSTR str, UINT uFlags)
257 {
258 LPWSTR strW;
259 INT len;
260 BOOL ret = FALSE;
261
262 if (!(uFlags & DC_TEXT) || !str)
263 return DrawCaptionTempW( hwnd, hdc, rect, hFont, hIcon, NULL, uFlags );
264
265 len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
266 if ((strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
267 {
268 MultiByteToWideChar( CP_ACP, 0, str, -1, strW, len );
269 ret = DrawCaptionTempW (hwnd, hdc, rect, hFont, hIcon, strW, uFlags);
270 HeapFree( GetProcessHeap (), 0, strW );
271 }
272 return ret;
273 }
274
275
276 /***********************************************************************
277 * DrawCaptionTempW (USER32.@)
278 */
279 BOOL WINAPI DrawCaptionTempW (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
280 HICON hIcon, LPCWSTR str, UINT uFlags)
281 {
282 RECT rc = *rect;
283
284 TRACE("(%p,%p,%p,%p,%p,%s,%08x)\n",
285 hwnd, hdc, rect, hFont, hIcon, debugstr_w(str), uFlags);
286
287 /* drawing background */
288 if (uFlags & DC_INBUTTON) {
289 FillRect (hdc, &rc, GetSysColorBrush (COLOR_3DFACE));
290
291 if (uFlags & DC_ACTIVE) {
292 HBRUSH hbr = SelectObject (hdc, SYSCOLOR_55AABrush);
293 PatBlt (hdc, rc.left, rc.top,
294 rc.right-rc.left, rc.bottom-rc.top, 0xFA0089);
295 SelectObject (hdc, hbr);
296 }
297 }
298 else {
299 DWORD style = GetWindowLongW (hwnd, GWL_STYLE);
300 NC_DrawCaptionBar (hdc, &rc, style, uFlags & DC_ACTIVE, uFlags & DC_GRADIENT);
301 }
302
303
304 /* drawing icon */
305 if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP)) {
306 POINT pt;
307
308 pt.x = rc.left + 2;
309 pt.y = (rc.bottom + rc.top - GetSystemMetrics(SM_CYSMICON)) / 2;
310
311 if (!hIcon) hIcon = NC_IconForWindow(hwnd);
312 DrawIconEx (hdc, pt.x, pt.y, hIcon, GetSystemMetrics(SM_CXSMICON),
313 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
314 rc.left += (rc.bottom - rc.top);
315 }
316
317 /* drawing text */
318 if (uFlags & DC_TEXT) {
319 HFONT hOldFont;
320
321 if (uFlags & DC_INBUTTON)
322 SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
323 else if (uFlags & DC_ACTIVE)
324 SetTextColor (hdc, GetSysColor (COLOR_CAPTIONTEXT));
325 else
326 SetTextColor (hdc, GetSysColor (COLOR_INACTIVECAPTIONTEXT));
327
328 SetBkMode (hdc, TRANSPARENT);
329
330 if (hFont)
331 hOldFont = SelectObject (hdc, hFont);
332 else {
333 NONCLIENTMETRICSW nclm;
334 HFONT hNewFont;
335 nclm.cbSize = sizeof(NONCLIENTMETRICSW);
336 SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
337 hNewFont = CreateFontIndirectW ((uFlags & DC_SMALLCAP) ?
338 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
339 hOldFont = SelectObject (hdc, hNewFont);
340 }
341
342 if (str)
343 DrawTextW (hdc, str, -1, &rc,
344 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
345 else {
346 WCHAR szText[128];
347 INT nLen;
348 nLen = GetWindowTextW (hwnd, szText, 128);
349 DrawTextW (hdc, szText, nLen, &rc,
350 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
351 }
352
353 if (hFont)
354 SelectObject (hdc, hOldFont);
355 else
356 DeleteObject (SelectObject (hdc, hOldFont));
357 }
358
359 /* drawing focus ??? */
360 if (uFlags & 0x2000)
361 FIXME("undocumented flag (0x2000)!\n");
362
363 return 0;
364 }
365
366
367 /***********************************************************************
368 * AdjustWindowRect (USER32.@)
369 */
370 BOOL WINAPI DECLSPEC_HOTPATCH AdjustWindowRect( LPRECT rect, DWORD style, BOOL menu )
371 {
372 return AdjustWindowRectEx( rect, style, menu, 0 );
373 }
374
375
376 /***********************************************************************
377 * AdjustWindowRectEx (USER32.@)
378 */
379 BOOL WINAPI DECLSPEC_HOTPATCH AdjustWindowRectEx( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
380 {
381 if (style & WS_ICONIC) return TRUE;
382 style &= ~(WS_HSCROLL | WS_VSCROLL);
383
384 TRACE("(%s) %08x %d %08x\n", wine_dbgstr_rect(rect), style, menu, exStyle );
385
386 NC_AdjustRectOuter( rect, style, menu, exStyle );
387 NC_AdjustRectInner( rect, style, exStyle );
388
389 return TRUE;
390 }
391
392
393 /***********************************************************************
394 * NC_HandleNCCalcSize
395 *
396 * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
397 */
398 LRESULT NC_HandleNCCalcSize( HWND hwnd, WPARAM wparam, RECT *winRect )
399 {
400 RECT tmpRect = { 0, 0, 0, 0 };
401 LRESULT result = 0;
402 LONG cls_style = GetClassLongW(hwnd, GCL_STYLE);
403 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
404 LONG exStyle = GetWindowLongW( hwnd, GWL_EXSTYLE );
405
406 if (winRect == NULL)
407 return 0;
408
409 if (cls_style & CS_VREDRAW) result |= WVR_VREDRAW;
410 if (cls_style & CS_HREDRAW) result |= WVR_HREDRAW;
411
412 if (!(style & WS_ICONIC))
413 {
414 NC_AdjustRectOuter( &tmpRect, style, FALSE, exStyle );
415
416 winRect->left -= tmpRect.left;
417 winRect->top -= tmpRect.top;
418 winRect->right -= tmpRect.right;
419 winRect->bottom -= tmpRect.bottom;
420
421 if (((style & (WS_CHILD | WS_POPUP)) != WS_CHILD) && GetMenu(hwnd))
422 {
423 TRACE("Calling GetMenuBarHeight with hwnd %p, width %d, at (%d, %d).\n",
424 hwnd, winRect->right - winRect->left, -tmpRect.left, -tmpRect.top );
425
426 winRect->top +=
427 MENU_GetMenuBarHeight( hwnd,
428 winRect->right - winRect->left,
429 -tmpRect.left, -tmpRect.top );
430 }
431
432 if( exStyle & WS_EX_CLIENTEDGE)
433 if( winRect->right - winRect->left > 2 * GetSystemMetrics(SM_CXEDGE) &&
434 winRect->bottom - winRect->top > 2 * GetSystemMetrics(SM_CYEDGE))
435 InflateRect( winRect, - GetSystemMetrics(SM_CXEDGE),
436 - GetSystemMetrics(SM_CYEDGE));
437
438 if (style & WS_VSCROLL)
439 if (winRect->right - winRect->left >= GetSystemMetrics(SM_CXVSCROLL))
440 {
441 /* rectangle is in screen coords when wparam is false */
442 if (!wparam && (exStyle & WS_EX_LAYOUTRTL)) exStyle ^= WS_EX_LEFTSCROLLBAR;
443
444 if((exStyle & WS_EX_LEFTSCROLLBAR) != 0)
445 winRect->left += GetSystemMetrics(SM_CXVSCROLL);
446 else
447 winRect->right -= GetSystemMetrics(SM_CXVSCROLL);
448 }
449
450 if (style & WS_HSCROLL)
451 if( winRect->bottom - winRect->top > GetSystemMetrics(SM_CYHSCROLL))
452 winRect->bottom -= GetSystemMetrics(SM_CYHSCROLL);
453
454 if (winRect->top > winRect->bottom)
455 winRect->bottom = winRect->top;
456
457 if (winRect->left > winRect->right)
458 winRect->right = winRect->left;
459 }
460 return result;
461 }
462
463
464 /***********************************************************************
465 * NC_GetInsideRect
466 *
467 * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
468 * but without the borders (if any).
469 */
470 static void NC_GetInsideRect( HWND hwnd, enum coords_relative relative, RECT *rect,
471 DWORD style, DWORD ex_style )
472 {
473 WIN_GetRectangles( hwnd, relative, rect, NULL );
474
475 if (style & WS_ICONIC) return;
476
477 /* Remove frame from rectangle */
478 if (HAS_THICKFRAME( style, ex_style ))
479 {
480 InflateRect( rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
481 }
482 else if (HAS_DLGFRAME( style, ex_style ))
483 {
484 InflateRect( rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
485 }
486 else if (HAS_THINFRAME( style ))
487 {
488 InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
489 }
490
491 /* We have additional border information if the window
492 * is a child (but not an MDI child) */
493 if ((style & WS_CHILD) && !(ex_style & WS_EX_MDICHILD))
494 {
495 if (ex_style & WS_EX_CLIENTEDGE)
496 InflateRect (rect, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYEDGE));
497 if (ex_style & WS_EX_STATICEDGE)
498 InflateRect (rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
499 }
500 }
501
502
503 /***********************************************************************
504 * NC_HandleNCHitTest
505 *
506 * Handle a WM_NCHITTEST message. Called from DefWindowProc().
507 */
508 LRESULT NC_HandleNCHitTest( HWND hwnd, POINT pt )
509 {
510 RECT rect, rcClient;
511 DWORD style, ex_style;
512
513 TRACE("hwnd=%p pt=%d,%d\n", hwnd, pt.x, pt.y );
514
515 WIN_GetRectangles( hwnd, COORDS_SCREEN, &rect, &rcClient );
516 if (!PtInRect( &rect, pt )) return HTNOWHERE;
517
518 style = GetWindowLongW( hwnd, GWL_STYLE );
519 ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
520 if (style & WS_MINIMIZE) return HTCAPTION;
521
522 if (PtInRect( &rcClient, pt )) return HTCLIENT;
523
524 /* Check borders */
525 if (HAS_THICKFRAME( style, ex_style ))
526 {
527 InflateRect( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
528 if (!PtInRect( &rect, pt ))
529 {
530 /* Check top sizing border */
531 if (pt.y < rect.top)
532 {
533 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
534 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
535 return HTTOP;
536 }
537 /* Check bottom sizing border */
538 if (pt.y >= rect.bottom)
539 {
540 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
541 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
542 return HTBOTTOM;
543 }
544 /* Check left sizing border */
545 if (pt.x < rect.left)
546 {
547 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
548 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
549 return HTLEFT;
550 }
551 /* Check right sizing border */
552 if (pt.x >= rect.right)
553 {
554 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
555 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
556 return HTRIGHT;
557 }
558 }
559 }
560 else /* No thick frame */
561 {
562 if (HAS_DLGFRAME( style, ex_style ))
563 InflateRect(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
564 else if (HAS_THINFRAME( style ))
565 InflateRect(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
566 if (!PtInRect( &rect, pt )) return HTBORDER;
567 }
568
569 /* Check caption */
570
571 if ((style & WS_CAPTION) == WS_CAPTION)
572 {
573 if (ex_style & WS_EX_TOOLWINDOW)
574 rect.top += GetSystemMetrics(SM_CYSMCAPTION) - 1;
575 else
576 rect.top += GetSystemMetrics(SM_CYCAPTION) - 1;
577 if (!PtInRect( &rect, pt ))
578 {
579 BOOL min_or_max_box = (style & WS_SYSMENU) && (style & (WS_MINIMIZEBOX|WS_MAXIMIZEBOX));
580 if (ex_style & WS_EX_LAYOUTRTL)
581 {
582 /* Check system menu */
583 if ((style & WS_SYSMENU) && !(ex_style & WS_EX_TOOLWINDOW) && NC_IconForWindow(hwnd))
584 {
585 rect.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
586 if (pt.x > rect.right) return HTSYSMENU;
587 }
588
589 /* Check close button */
590 if (style & WS_SYSMENU)
591 {
592 rect.left += GetSystemMetrics(SM_CYCAPTION);
593 if (pt.x < rect.left) return HTCLOSE;
594 }
595
596 /* Check maximize box */
597 /* In win95 there is automatically a Maximize button when there is a minimize one*/
598 if (min_or_max_box && !(ex_style & WS_EX_TOOLWINDOW))
599 {
600 rect.left += GetSystemMetrics(SM_CXSIZE);
601 if (pt.x < rect.left) return HTMAXBUTTON;
602 }
603
604 /* Check minimize box */
605 if (min_or_max_box && !(ex_style & WS_EX_TOOLWINDOW))
606 {
607 rect.left += GetSystemMetrics(SM_CXSIZE);
608 if (pt.x < rect.left) return HTMINBUTTON;
609 }
610 }
611 else
612 {
613 /* Check system menu */
614 if ((style & WS_SYSMENU) && !(ex_style & WS_EX_TOOLWINDOW) && NC_IconForWindow(hwnd))
615 {
616 rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
617 if (pt.x < rect.left) return HTSYSMENU;
618 }
619
620 /* Check close button */
621 if (style & WS_SYSMENU)
622 {
623 rect.right -= GetSystemMetrics(SM_CYCAPTION);
624 if (pt.x > rect.right) return HTCLOSE;
625 }
626
627 /* Check maximize box */
628 /* In win95 there is automatically a Maximize button when there is a minimize one*/
629 if (min_or_max_box && !(ex_style & WS_EX_TOOLWINDOW))
630 {
631 rect.right -= GetSystemMetrics(SM_CXSIZE);
632 if (pt.x > rect.right) return HTMAXBUTTON;
633 }
634
635 /* Check minimize box */
636 if (min_or_max_box && !(ex_style & WS_EX_TOOLWINDOW))
637 {
638 rect.right -= GetSystemMetrics(SM_CXSIZE);
639 if (pt.x > rect.right) return HTMINBUTTON;
640 }
641 }
642 return HTCAPTION;
643 }
644 }
645
646 /* Check menu bar */
647
648 if (HAS_MENU( hwnd, style ) && (pt.y < rcClient.top) &&
649 (pt.x >= rcClient.left) && (pt.x < rcClient.right))
650 return HTMENU;
651
652 /* Check vertical scroll bar */
653
654 if (ex_style & WS_EX_LAYOUTRTL) ex_style ^= WS_EX_LEFTSCROLLBAR;
655 if (style & WS_VSCROLL)
656 {
657 if((ex_style & WS_EX_LEFTSCROLLBAR) != 0)
658 rcClient.left -= GetSystemMetrics(SM_CXVSCROLL);
659 else
660 rcClient.right += GetSystemMetrics(SM_CXVSCROLL);
661 if (PtInRect( &rcClient, pt )) return HTVSCROLL;
662 }
663
664 /* Check horizontal scroll bar */
665
666 if (style & WS_HSCROLL)
667 {
668 rcClient.bottom += GetSystemMetrics(SM_CYHSCROLL);
669 if (PtInRect( &rcClient, pt ))
670 {
671 /* Check size box */
672 if ((style & WS_VSCROLL) &&
673 ((((ex_style & WS_EX_LEFTSCROLLBAR) != 0) && (pt.x <= rcClient.left + GetSystemMetrics(SM_CXVSCROLL))) ||
674 (((ex_style & WS_EX_LEFTSCROLLBAR) == 0) && (pt.x >= rcClient.right - GetSystemMetrics(SM_CXVSCROLL)))))
675 return HTSIZE;
676 return HTHSCROLL;
677 }
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 *
688 * NC_DrawSysButton
689 *
690 * Draws the system icon.
691 *
692 *****************************************************************************/
693 BOOL NC_DrawSysButton (HWND hwnd, HDC hdc, BOOL down)
694 {
695 HICON hIcon = NC_IconForWindow( hwnd );
696
697 if (hIcon)
698 {
699 RECT rect;
700 POINT pt;
701 DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
702 DWORD ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
703
704 NC_GetInsideRect( hwnd, COORDS_WINDOW, &rect, style, ex_style );
705 pt.x = rect.left + 2;
706 pt.y = (rect.top + GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYSMICON)) / 2;
707 DrawIconEx (hdc, pt.x, pt.y, hIcon,
708 GetSystemMetrics(SM_CXSMICON),
709 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
710 }
711 return (hIcon != 0);
712 }
713
714
715 /******************************************************************************
716 *
717 * NC_DrawCloseButton
718 *
719 * Draws the close button.
720 *
721 * If bGrayed is true, then draw a disabled Close button
722 *
723 *****************************************************************************/
724
725 static void NC_DrawCloseButton (HWND hwnd, HDC hdc, BOOL down, BOOL bGrayed)
726 {
727 RECT rect;
728 DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
729 DWORD ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
730
731 NC_GetInsideRect( hwnd, COORDS_WINDOW, &rect, style, ex_style );
732
733 /* A tool window has a smaller Close button */
734 if (ex_style & WS_EX_TOOLWINDOW)
735 {
736 INT iBmpHeight = 11; /* Windows does not use SM_CXSMSIZE and SM_CYSMSIZE */
737 INT iBmpWidth = 11; /* it uses 11x11 for the close button in tool window */
738 INT iCaptionHeight = GetSystemMetrics(SM_CYSMCAPTION);
739
740 rect.top = rect.top + (iCaptionHeight - 1 - iBmpHeight) / 2;
741 rect.left = rect.right - (iCaptionHeight + 1 + iBmpWidth) / 2;
742 rect.bottom = rect.top + iBmpHeight;
743 rect.right = rect.left + iBmpWidth;
744 }
745 else
746 {
747 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
748 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 2;
749 rect.top += 2;
750 rect.right -= 2;
751 }
752 DrawFrameControl( hdc, &rect, DFC_CAPTION,
753 (DFCS_CAPTIONCLOSE |
754 (down ? DFCS_PUSHED : 0) |
755 (bGrayed ? DFCS_INACTIVE : 0)) );
756 }
757
758 /******************************************************************************
759 * NC_DrawMaxButton
760 *
761 * Draws the maximize button for windows.
762 * If bGrayed is true, then draw a disabled Maximize button
763 */
764 static void NC_DrawMaxButton(HWND hwnd,HDC hdc,BOOL down, BOOL bGrayed)
765 {
766 RECT rect;
767 UINT flags;
768 DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
769 DWORD ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
770
771 /* never draw maximize box when window has WS_EX_TOOLWINDOW style */
772 if (ex_style & WS_EX_TOOLWINDOW) return;
773
774 flags = (style & WS_MAXIMIZE) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMAX;
775
776 NC_GetInsideRect( hwnd, COORDS_WINDOW, &rect, style, ex_style );
777 if (style & WS_SYSMENU)
778 rect.right -= GetSystemMetrics(SM_CXSIZE);
779 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
780 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 2;
781 rect.top += 2;
782 rect.right -= 2;
783 if (down) flags |= DFCS_PUSHED;
784 if (bGrayed) flags |= DFCS_INACTIVE;
785 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
786 }
787
788 /******************************************************************************
789 * NC_DrawMinButton
790 *
791 * Draws the minimize button for windows.
792 * If bGrayed is true, then draw a disabled Minimize button
793 */
794 static void NC_DrawMinButton(HWND hwnd,HDC hdc,BOOL down, BOOL bGrayed)
795 {
796 RECT rect;
797 UINT flags = DFCS_CAPTIONMIN;
798 DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
799 DWORD ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
800
801 /* never draw minimize box when window has WS_EX_TOOLWINDOW style */
802 if (ex_style & WS_EX_TOOLWINDOW) return;
803
804 NC_GetInsideRect( hwnd, COORDS_WINDOW, &rect, style, ex_style );
805 if (style & WS_SYSMENU)
806 rect.right -= GetSystemMetrics(SM_CXSIZE);
807 if (style & (WS_MAXIMIZEBOX|WS_MINIMIZEBOX))
808 rect.right -= GetSystemMetrics(SM_CXSIZE) - 2;
809 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
810 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 2;
811 rect.top += 2;
812 rect.right -= 2;
813 if (down) flags |= DFCS_PUSHED;
814 if (bGrayed) flags |= DFCS_INACTIVE;
815 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
816 }
817
818 /******************************************************************************
819 *
820 * NC_DrawFrame
821 *
822 * Draw a window frame inside the given rectangle, and update the rectangle.
823 *
824 * Bugs
825 * Many. First, just what IS a frame in Win95? Note that the 3D look
826 * on the outer edge is handled by NC_DoNCPaint. As is the inner
827 * edge. The inner rectangle just inside the frame is handled by the
828 * Caption code.
829 *
830 * In short, for most people, this function should be a nop (unless
831 * you LIKE thick borders in Win95/NT4.0 -- I've been working with
832 * them lately, but just to get this code right). Even so, it doesn't
833 * appear to be so. It's being worked on...
834 *
835 *****************************************************************************/
836
837 static void NC_DrawFrame( HDC hdc, RECT *rect, BOOL active, DWORD style, DWORD exStyle)
838 {
839 INT width, height;
840
841 /* Firstly the "thick" frame */
842 if (style & WS_THICKFRAME)
843 {
844 width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXDLGFRAME);
845 height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYDLGFRAME);
846
847 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
848 COLOR_INACTIVEBORDER) );
849 /* Draw frame */
850 PatBlt( hdc, rect->left, rect->top,
851 rect->right - rect->left, height, PATCOPY );
852 PatBlt( hdc, rect->left, rect->top,
853 width, rect->bottom - rect->top, PATCOPY );
854 PatBlt( hdc, rect->left, rect->bottom - 1,
855 rect->right - rect->left, -height, PATCOPY );
856 PatBlt( hdc, rect->right - 1, rect->top,
857 -width, rect->bottom - rect->top, PATCOPY );
858
859 InflateRect( rect, -width, -height );
860 }
861
862 /* Now the other bit of the frame */
863 if ((style & (WS_BORDER|WS_DLGFRAME)) ||
864 (exStyle & WS_EX_DLGMODALFRAME))
865 {
866 width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
867 height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
868 /* This should give a value of 1 that should also work for a border */
869
870 SelectObject( hdc, GetSysColorBrush(
871 (exStyle & (WS_EX_DLGMODALFRAME|WS_EX_CLIENTEDGE)) ?
872 COLOR_3DFACE :
873 (exStyle & WS_EX_STATICEDGE) ?
874 COLOR_WINDOWFRAME :
875 (style & (WS_DLGFRAME|WS_THICKFRAME)) ?
876 COLOR_3DFACE :
877 /* else */
878 COLOR_WINDOWFRAME));
879
880 /* Draw frame */
881 PatBlt( hdc, rect->left, rect->top,
882 rect->right - rect->left, height, PATCOPY );
883 PatBlt( hdc, rect->left, rect->top,
884 width, rect->bottom - rect->top, PATCOPY );
885 PatBlt( hdc, rect->left, rect->bottom - 1,
886 rect->right - rect->left, -height, PATCOPY );
887 PatBlt( hdc, rect->right - 1, rect->top,
888 -width, rect->bottom - rect->top, PATCOPY );
889
890 InflateRect( rect, -width, -height );
891 }
892 }
893
894
895 /******************************************************************************
896 *
897 * NC_DrawCaption
898 *
899 * Draw the window caption for windows.
900 * The correct pen for the window frame must be selected in the DC.
901 *
902 *****************************************************************************/
903
904 static void NC_DrawCaption( HDC hdc, RECT *rect, HWND hwnd, DWORD style,
905 DWORD exStyle, BOOL active )
906 {
907 RECT r = *rect;
908 WCHAR buffer[256];
909 HPEN hPrevPen;
910 HMENU hSysMenu;
911 BOOL gradient = FALSE;
912
913 hPrevPen = SelectObject( hdc, SYSCOLOR_GetPen(
914 ((exStyle & (WS_EX_STATICEDGE|WS_EX_CLIENTEDGE|
915 WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE) ?
916 COLOR_WINDOWFRAME : COLOR_3DFACE) );
917 MoveToEx( hdc, r.left, r.bottom - 1, NULL );
918 LineTo( hdc, r.right, r.bottom - 1 );
919 SelectObject( hdc, hPrevPen );
920 r.bottom--;
921
922 SystemParametersInfoW (SPI_GETGRADIENTCAPTIONS, 0, &gradient, 0);
923 NC_DrawCaptionBar (hdc, &r, style, active, gradient);
924
925 if ((style & WS_SYSMENU) && !(exStyle & WS_EX_TOOLWINDOW)) {
926 if (NC_DrawSysButton (hwnd, hdc, FALSE))
927 r.left += GetSystemMetrics(SM_CXSMICON) + 2;
928 }
929
930 if (style & WS_SYSMENU)
931 {
932 UINT state;
933
934 /* Go get the sysmenu */
935 hSysMenu = GetSystemMenu(hwnd, FALSE);
936 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
937
938 /* Draw a grayed close button if disabled or if SC_CLOSE is not there */
939 NC_DrawCloseButton (hwnd, hdc, FALSE,
940 (state & (MF_DISABLED | MF_GRAYED)) || (state == 0xFFFFFFFF));
941 r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
942
943 if ((style & WS_MAXIMIZEBOX) || (style & WS_MINIMIZEBOX))
944 {
945 /* In win95 the two buttons are always there */
946 /* But if the menu item is not in the menu they're disabled*/
947
948 NC_DrawMaxButton( hwnd, hdc, FALSE, (!(style & WS_MAXIMIZEBOX)));
949 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
950
951 NC_DrawMinButton( hwnd, hdc, FALSE, (!(style & WS_MINIMIZEBOX)));
952 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
953 }
954 }
955
956 if (GetWindowTextW( hwnd, buffer, sizeof(buffer)/sizeof(WCHAR) ))
957 {
958 NONCLIENTMETRICSW nclm;
959 HFONT hFont, hOldFont;
960 nclm.cbSize = sizeof(nclm);
961 SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
962 if (exStyle & WS_EX_TOOLWINDOW)
963 hFont = CreateFontIndirectW (&nclm.lfSmCaptionFont);
964 else
965 hFont = CreateFontIndirectW (&nclm.lfCaptionFont);
966 hOldFont = SelectObject (hdc, hFont);
967 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
968 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
969 SetBkMode( hdc, TRANSPARENT );
970 r.left += 2;
971 DrawTextW( hdc, buffer, -1, &r,
972 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
973 DeleteObject (SelectObject (hdc, hOldFont));
974 }
975 }
976
977
978 /******************************************************************************
979 * NC_DoNCPaint
980 *
981 * Paint the non-client area for windows.
982 */
983 static void NC_DoNCPaint( HWND hwnd, HRGN clip )
984 {
985 HDC hdc;
986 RECT rfuzz, rect, rectClip;
987 BOOL active;
988 WND *wndPtr;
989 DWORD dwStyle, dwExStyle;
990 WORD flags;
991 HRGN hrgn;
992 RECT rectClient;
993
994 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return;
995 dwStyle = wndPtr->dwStyle;
996 dwExStyle = wndPtr->dwExStyle;
997 flags = wndPtr->flags;
998 WIN_ReleasePtr( wndPtr );
999
1000 if ( dwStyle & WS_MINIMIZE ||
1001 !WIN_IsWindowDrawable( hwnd, 0 )) return; /* Nothing to do */
1002
1003 active = flags & WIN_NCACTIVATED;
1004
1005 TRACE("%p %d\n", hwnd, active );
1006
1007 /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
1008 the call to GetDCEx implying that it is allowed not to use it either.
1009 However, the suggested GetDCEx( , DCX_WINDOW | DCX_INTERSECTRGN)
1010 will cause clipRgn to be deleted after ReleaseDC().
1011 Now, how is the "system" supposed to tell what happened?
1012 */
1013
1014 WIN_GetRectangles( hwnd, COORDS_SCREEN, NULL, &rectClient );
1015 hrgn = CreateRectRgnIndirect( &rectClient );
1016
1017 if (clip > (HRGN)1)
1018 {
1019 CombineRgn( hrgn, clip, hrgn, RGN_DIFF );
1020 hdc = GetDCEx( hwnd, hrgn, DCX_USESTYLE | DCX_WINDOW | DCX_INTERSECTRGN );
1021 }
1022 else
1023 {
1024 hdc = GetDCEx( hwnd, hrgn, DCX_USESTYLE | DCX_WINDOW | DCX_EXCLUDERGN );
1025 }
1026
1027 if (!hdc) return;
1028
1029 WIN_GetRectangles( hwnd, COORDS_WINDOW, &rect, NULL );
1030 GetClipBox( hdc, &rectClip );
1031
1032 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1033
1034 if (HAS_STATICOUTERFRAME(dwStyle, dwExStyle)) {
1035 DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1036 }
1037 else if (HAS_BIGFRAME( dwStyle, dwExStyle)) {
1038 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1039 }
1040
1041 NC_DrawFrame(hdc, &rect, active, dwStyle, dwExStyle );
1042
1043 if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1044 {
1045 RECT r = rect;
1046 if (dwExStyle & WS_EX_TOOLWINDOW) {
1047 r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
1048 rect.top += GetSystemMetrics(SM_CYSMCAPTION);
1049 }
1050 else {
1051 r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
1052 rect.top += GetSystemMetrics(SM_CYCAPTION);
1053 }
1054 if( IntersectRect( &rfuzz, &r, &rectClip ) )
1055 NC_DrawCaption(hdc, &r, hwnd, dwStyle, dwExStyle, active);
1056 }
1057
1058 if (HAS_MENU( hwnd, dwStyle ))
1059 {
1060 RECT r = rect;
1061 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
1062
1063 TRACE("Calling DrawMenuBar with rect (%s)\n", wine_dbgstr_rect(&r));
1064
1065 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd ) + 1;
1066 }
1067
1068 TRACE("After MenuBar, rect is (%s).\n", wine_dbgstr_rect(&rect));
1069
1070 if (dwExStyle & WS_EX_CLIENTEDGE)
1071 DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1072
1073 /* Draw the scroll-bars */
1074
1075 if (dwStyle & WS_VSCROLL)
1076 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1077 if (dwStyle & WS_HSCROLL)
1078 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1079
1080 /* Draw the "size-box" */
1081 if ((dwStyle & WS_VSCROLL) && (dwStyle & WS_HSCROLL))
1082 {
1083 RECT r = rect;
1084 if((dwExStyle & WS_EX_LEFTSCROLLBAR) != 0)
1085 r.right = r.left + GetSystemMetrics(SM_CXVSCROLL) + 1;
1086 else
1087 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1088 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1089 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1090 }
1091
1092 ReleaseDC( hwnd, hdc );
1093 }
1094
1095
1096
1097
1098 /***********************************************************************
1099 * NC_HandleNCPaint
1100 *
1101 * Handle a WM_NCPAINT message. Called from DefWindowProc().
1102 */
1103 LRESULT NC_HandleNCPaint( HWND hwnd , HRGN clip)
1104 {
1105 DWORD dwStyle = GetWindowLongW( hwnd, GWL_STYLE );
1106
1107 if( dwStyle & WS_VISIBLE )
1108 {
1109 if( dwStyle & WS_MINIMIZE )
1110 WINPOS_RedrawIconTitle( hwnd );
1111 else
1112 NC_DoNCPaint( hwnd, clip );
1113 }
1114 return 0;
1115 }
1116
1117
1118 /***********************************************************************
1119 * NC_HandleNCActivate
1120 *
1121 * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1122 */
1123 LRESULT NC_HandleNCActivate( HWND hwnd, WPARAM wParam, LPARAM lParam )
1124 {
1125 WND* wndPtr = WIN_GetPtr( hwnd );
1126
1127 if (!wndPtr || wndPtr == WND_OTHER_PROCESS) return FALSE;
1128
1129 /* Lotus Notes draws menu descriptions in the caption of its main
1130 * window. When it wants to restore original "system" view, it just
1131 * sends WM_NCACTIVATE message to itself. Any optimizations here in
1132 * attempt to minimize redrawings lead to a not restored caption.
1133 */
1134 if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1135 else wndPtr->flags &= ~WIN_NCACTIVATED;
1136 WIN_ReleasePtr( wndPtr );
1137
1138 /* This isn't documented but is reproducible in at least XP SP2 and
1139 * Outlook 2007 depends on it
1140 */
1141 if (lParam != -1)
1142 {
1143 if (IsIconic(hwnd))
1144 WINPOS_RedrawIconTitle( hwnd );
1145 else
1146 NC_DoNCPaint( hwnd, (HRGN)1 );
1147 }
1148
1149 return TRUE;
1150 }
1151
1152
1153 /***********************************************************************
1154 * NC_HandleSetCursor
1155 *
1156 * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1157 */
1158 LRESULT NC_HandleSetCursor( HWND hwnd, WPARAM wParam, LPARAM lParam )
1159 {
1160 hwnd = WIN_GetFullHandle( (HWND)wParam );
1161
1162 switch((short)LOWORD(lParam))
1163 {
1164 case HTERROR:
1165 {
1166 WORD msg = HIWORD( lParam );
1167 if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1168 (msg == WM_RBUTTONDOWN) || (msg == WM_XBUTTONDOWN))
1169 MessageBeep(0);
1170 }
1171 break;
1172
1173 case HTCLIENT:
1174 {
1175 HCURSOR hCursor = (HCURSOR)GetClassLongPtrW(hwnd, GCLP_HCURSOR);
1176 if(hCursor) {
1177 SetCursor(hCursor);
1178 return TRUE;
1179 }
1180 return FALSE;
1181 }
1182
1183 case HTLEFT:
1184 case HTRIGHT:
1185 return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZEWE ) );
1186
1187 case HTTOP:
1188 case HTBOTTOM:
1189 return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENS ) );
1190
1191 case HTTOPLEFT:
1192 case HTBOTTOMRIGHT:
1193 return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENWSE ) );
1194
1195 case HTTOPRIGHT:
1196 case HTBOTTOMLEFT:
1197 return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENESW ) );
1198 }
1199
1200 /* Default cursor: arrow */
1201 return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_ARROW ) );
1202 }
1203
1204 /***********************************************************************
1205 * NC_GetSysPopupPos
1206 */
1207 void NC_GetSysPopupPos( HWND hwnd, RECT* rect )
1208 {
1209 if (IsIconic(hwnd)) GetWindowRect( hwnd, rect );
1210 else
1211 {
1212 DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
1213 DWORD ex_style = GetWindowLongW( hwnd, GWL_EXSTYLE );
1214
1215 NC_GetInsideRect( hwnd, COORDS_CLIENT, rect, style, ex_style );
1216 rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
1217 rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
1218 MapWindowPoints( hwnd, 0, (POINT *)rect, 2 );
1219 }
1220 }
1221
1222 /***********************************************************************
1223 * NC_TrackMinMaxBox
1224 *
1225 * Track a mouse button press on the minimize or maximize box.
1226 *
1227 * The big difference between 3.1 and 95 is the disabled button state.
1228 * In win95 the system button can be disabled, so it can ignore the mouse
1229 * event.
1230 *
1231 */
1232 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
1233 {
1234 MSG msg;
1235 HDC hdc = GetWindowDC( hwnd );
1236 BOOL pressed = TRUE;
1237 UINT state;
1238 DWORD wndStyle = GetWindowLongW( hwnd, GWL_STYLE);
1239 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1240
1241 void (*paintButton)(HWND, HDC, BOOL, BOOL);
1242
1243 if (wParam == HTMINBUTTON)
1244 {
1245 /* If the style is not present, do nothing */
1246 if (!(wndStyle & WS_MINIMIZEBOX))
1247 return;
1248
1249 /* Check if the sysmenu item for minimize is there */
1250 state = GetMenuState(hSysMenu, SC_MINIMIZE, MF_BYCOMMAND);
1251
1252 paintButton = NC_DrawMinButton;
1253 }
1254 else
1255 {
1256 /* If the style is not present, do nothing */
1257 if (!(wndStyle & WS_MAXIMIZEBOX))
1258 return;
1259
1260 /* Check if the sysmenu item for maximize is there */
1261 state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
1262
1263 paintButton = NC_DrawMaxButton;
1264 }
1265
1266 SetCapture( hwnd );
1267
1268 (*paintButton)( hwnd, hdc, TRUE, FALSE);
1269
1270 while(1)
1271 {
1272 BOOL oldstate = pressed;
1273
1274 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1275 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1276
1277 if(msg.message == WM_LBUTTONUP)
1278 break;
1279
1280 if(msg.message != WM_MOUSEMOVE)
1281 continue;
1282
1283 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1284 if (pressed != oldstate)
1285 (*paintButton)( hwnd, hdc, pressed, FALSE);
1286 }
1287
1288 if(pressed)
1289 (*paintButton)(hwnd, hdc, FALSE, FALSE);
1290
1291 ReleaseCapture();
1292 ReleaseDC( hwnd, hdc );
1293
1294 /* If the item minimize or maximize of the sysmenu are not there */
1295 /* or if the style is not present, do nothing */
1296 if ((!pressed) || (state == 0xFFFFFFFF))
1297 return;
1298
1299 if (wParam == HTMINBUTTON)
1300 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1301 else
1302 SendMessageW( hwnd, WM_SYSCOMMAND,
1303 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1304 }
1305
1306 /***********************************************************************
1307 * NC_TrackCloseButton
1308 *
1309 * Track a mouse button press on the Win95 close button.
1310 */
1311 static void NC_TrackCloseButton (HWND hwnd, WPARAM wParam, LPARAM lParam)
1312 {
1313 MSG msg;
1314 HDC hdc;
1315 BOOL pressed = TRUE;
1316 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1317 UINT state;
1318
1319 if(hSysMenu == 0)
1320 return;
1321
1322 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1323
1324 /* If the item close of the sysmenu is disabled or not there do nothing */
1325 if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
1326 return;
1327
1328 hdc = GetWindowDC( hwnd );
1329
1330 SetCapture( hwnd );
1331
1332 NC_DrawCloseButton (hwnd, hdc, TRUE, FALSE);
1333
1334 while(1)
1335 {
1336 BOOL oldstate = pressed;
1337
1338 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1339 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1340
1341 if(msg.message == WM_LBUTTONUP)
1342 break;
1343
1344 if(msg.message != WM_MOUSEMOVE)
1345 continue;
1346
1347 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1348 if (pressed != oldstate)
1349 NC_DrawCloseButton (hwnd, hdc, pressed, FALSE);
1350 }
1351
1352 if(pressed)
1353 NC_DrawCloseButton (hwnd, hdc, FALSE, FALSE);
1354
1355 ReleaseCapture();
1356 ReleaseDC( hwnd, hdc );
1357 if (!pressed) return;
1358
1359 SendMessageW( hwnd, WM_SYSCOMMAND, SC_CLOSE, lParam );
1360 }
1361
1362
1363 /***********************************************************************
1364 * NC_TrackScrollBar
1365 *
1366 * Track a mouse button press on the horizontal or vertical scroll-bar.
1367 */
1368 static void NC_TrackScrollBar( HWND hwnd, WPARAM wParam, POINT pt )
1369 {
1370 INT scrollbar;
1371
1372 if ((wParam & 0xfff0) == SC_HSCROLL)
1373 {
1374 if ((wParam & 0x0f) != HTHSCROLL) return;
1375 scrollbar = SB_HORZ;
1376 }
1377 else /* SC_VSCROLL */
1378 {
1379 if ((wParam & 0x0f) != HTVSCROLL) return;
1380 scrollbar = SB_VERT;
1381 }
1382 SCROLL_TrackScrollBar( hwnd, scrollbar, pt );
1383 }
1384
1385
1386 /***********************************************************************
1387 * NC_HandleNCLButtonDown
1388 *
1389 * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
1390 */
1391 LRESULT NC_HandleNCLButtonDown( HWND hwnd, WPARAM wParam, LPARAM lParam )
1392 {
1393 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
1394
1395 switch(wParam) /* Hit test */
1396 {
1397 case HTCAPTION:
1398 {
1399 HWND top = GetAncestor( hwnd, GA_ROOT );
1400
1401 if (FOCUS_MouseActivate( top ) || (GetActiveWindow() == top))
1402 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
1403 break;
1404 }
1405
1406 case HTSYSMENU:
1407 if( style & WS_SYSMENU )
1408 {
1409 if( !(style & WS_MINIMIZE) )
1410 {
1411 HDC hDC = GetWindowDC(hwnd);
1412 NC_DrawSysButton( hwnd, hDC, TRUE );
1413 ReleaseDC( hwnd, hDC );
1414 }
1415 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
1416 }
1417 break;
1418
1419 case HTMENU:
1420 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
1421 break;
1422
1423 case HTHSCROLL:
1424 SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
1425 break;
1426
1427 case HTVSCROLL:
1428 SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
1429 break;
1430
1431 case HTMINBUTTON:
1432 case HTMAXBUTTON:
1433 NC_TrackMinMaxBox( hwnd, wParam );
1434 break;
1435
1436 case HTCLOSE:
1437 NC_TrackCloseButton (hwnd, wParam, lParam);
1438 break;
1439
1440 case HTLEFT:
1441 case HTRIGHT:
1442 case HTTOP:
1443 case HTTOPLEFT:
1444 case HTTOPRIGHT:
1445 case HTBOTTOM:
1446 case HTBOTTOMLEFT:
1447 case HTBOTTOMRIGHT:
1448 /* Old comment:
1449 * "make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU"
1450 * This was previously done by setting wParam=SC_SIZE + wParam - 2
1451 */
1452 /* But that is not what WinNT does. Instead it sends this. This
1453 * is easy to differentiate from HTSYSMENU, because HTSYSMENU adds
1454 * SC_MOUSEMENU into wParam.
1455 */
1456 SendMessageW( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - (HTLEFT-WMSZ_LEFT), lParam);
1457 break;
1458
1459 case HTBORDER:
1460 break;
1461 }
1462 return 0;
1463 }
1464
1465
1466 /***********************************************************************
1467 * NC_HandleNCRButtonDown
1468 *
1469 * Handle a WM_NCRBUTTONDOWN message. Called from DefWindowProc().
1470 */
1471 LRESULT NC_HandleNCRButtonDown( HWND hwnd, WPARAM wParam, LPARAM lParam )
1472 {
1473 MSG msg;
1474 INT hittest = wParam;
1475
1476 switch (hittest)
1477 {
1478 case HTCAPTION:
1479 case HTSYSMENU:
1480 if (!GetSystemMenu( hwnd, FALSE )) break;
1481
1482 SetCapture( hwnd );
1483 for (;;)
1484 {
1485 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1486 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1487 if (msg.message == WM_RBUTTONUP)
1488 {
1489 hittest = NC_HandleNCHitTest( hwnd, msg.pt );
1490 break;
1491 }
1492 }
1493 ReleaseCapture();
1494 if (hittest == HTCAPTION || hittest == HTSYSMENU)
1495 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, msg.lParam );
1496 break;
1497 }
1498 return 0;
1499 }
1500
1501
1502 /***********************************************************************
1503 * NC_HandleNCLButtonDblClk
1504 *
1505 * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
1506 */
1507 LRESULT NC_HandleNCLButtonDblClk( HWND hwnd, WPARAM wParam, LPARAM lParam )
1508 {
1509 /*
1510 * if this is an icon, send a restore since we are handling
1511 * a double click
1512 */
1513 if (IsIconic(hwnd))
1514 {
1515 SendMessageW( hwnd, WM_SYSCOMMAND, SC_RESTORE, lParam );
1516 return 0;
1517 }
1518
1519 switch(wParam) /* Hit test */
1520 {
1521 case HTCAPTION:
1522 /* stop processing if WS_MAXIMIZEBOX is missing */
1523 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MAXIMIZEBOX)
1524 SendMessageW( hwnd, WM_SYSCOMMAND,
1525 IsZoomed(hwnd) ? SC_RESTORE : SC_MAXIMIZE, lParam );
1526 break;
1527
1528 case HTSYSMENU:
1529 {
1530 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1531 UINT state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1532
1533 /* If the item close of the sysmenu is disabled or not there do nothing */
1534 if ((state & (MF_DISABLED | MF_GRAYED)) || (state == 0xFFFFFFFF))
1535 break;
1536
1537 SendMessageW( hwnd, WM_SYSCOMMAND, SC_CLOSE, lParam );
1538 break;
1539 }
1540
1541 case HTHSCROLL:
1542 SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
1543 break;
1544
1545 case HTVSCROLL:
1546 SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
1547 break;
1548 }
1549 return 0;
1550 }
1551
1552
1553 /***********************************************************************
1554 * NC_HandleSysCommand
1555 *
1556 * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
1557 */
1558 LRESULT NC_HandleSysCommand( HWND hwnd, WPARAM wParam, LPARAM lParam )
1559 {
1560 TRACE("hwnd %p WM_SYSCOMMAND %lx %lx\n", hwnd, wParam, lParam );
1561
1562 if (!IsWindowEnabled( hwnd )) return 0;
1563
1564 if (HOOK_CallHooks( WH_CBT, HCBT_SYSCOMMAND, wParam, lParam, TRUE ))
1565 return 0;
1566
1567 if (!USER_Driver->pSysCommand( hwnd, wParam, lParam ))
1568 return 0;
1569
1570 switch (wParam & 0xfff0)
1571 {
1572 case SC_SIZE:
1573 case SC_MOVE:
1574 WINPOS_SysCommandSizeMove( hwnd, wParam );
1575 break;
1576
1577 case SC_MINIMIZE:
1578 if (hwnd == GetActiveWindow())
1579 ShowOwnedPopups(hwnd,FALSE);
1580 ShowWindow( hwnd, SW_MINIMIZE );
1581 break;
1582
1583 case SC_MAXIMIZE:
1584 if (IsIconic(hwnd) && hwnd == GetActiveWindow())
1585 ShowOwnedPopups(hwnd,TRUE);
1586 ShowWindow( hwnd, SW_MAXIMIZE );
1587 break;
1588
1589 case SC_RESTORE:
1590 if (IsIconic(hwnd) && hwnd == GetActiveWindow())
1591 ShowOwnedPopups(hwnd,TRUE);
1592 ShowWindow( hwnd, SW_RESTORE );
1593 break;
1594
1595 case SC_CLOSE:
1596 return SendMessageW( hwnd, WM_CLOSE, 0, 0 );
1597
1598 case SC_VSCROLL:
1599 case SC_HSCROLL:
1600 {
1601 POINT pt;
1602 pt.x = (short)LOWORD(lParam);
1603 pt.y = (short)HIWORD(lParam);
1604 NC_TrackScrollBar( hwnd, wParam, pt );
1605 }
1606 break;
1607
1608 case SC_MOUSEMENU:
1609 {
1610 POINT pt;
1611 pt.x = (short)LOWORD(lParam);
1612 pt.y = (short)HIWORD(lParam);
1613 MENU_TrackMouseMenuBar( hwnd, wParam & 0x000F, pt );
1614 }
1615 break;
1616
1617 case SC_KEYMENU:
1618 MENU_TrackKbdMenuBar( hwnd, wParam, (WCHAR)lParam );
1619 break;
1620
1621 case SC_TASKLIST:
1622 WinExec( "taskman.exe", SW_SHOWNORMAL );
1623 break;
1624
1625 case SC_SCREENSAVE:
1626 if (wParam == SC_ABOUTWINE)
1627 {
1628 HMODULE hmodule = LoadLibraryA( "shell32.dll" );
1629 if (hmodule)
1630 {
1631 BOOL (WINAPI *aboutproc)(HWND, LPCSTR, LPCSTR, HICON);
1632
1633 aboutproc = (void *)GetProcAddress( hmodule, "ShellAboutA" );
1634 if (aboutproc) aboutproc( hwnd, PACKAGE_STRING, NULL, 0 );
1635 FreeLibrary( hmodule );
1636 }
1637 }
1638 break;
1639
1640 case SC_HOTKEY:
1641 case SC_ARRANGE:
1642 case SC_NEXTWINDOW:
1643 case SC_PREVWINDOW:
1644 FIXME("unimplemented WM_SYSCOMMAND %04lx!\n", wParam);
1645 break;
1646 }
1647 return 0;
1648 }
1649
1650 /***********************************************************************
1651 * GetTitleBarInfo (USER32.@)
1652 * TODO: Handle STATE_SYSTEM_PRESSED
1653 */
1654 BOOL WINAPI GetTitleBarInfo(HWND hwnd, PTITLEBARINFO tbi) {
1655 DWORD dwStyle;
1656 DWORD dwExStyle;
1657
1658 TRACE("(%p %p)\n", hwnd, tbi);
1659
1660 if(!tbi) {
1661 SetLastError(ERROR_NOACCESS);
1662 return FALSE;
1663 }
1664
1665 if(tbi->cbSize != sizeof(TITLEBARINFO)) {
1666 TRACE("Invalid TITLEBARINFO size: %d\n", tbi->cbSize);
1667 SetLastError(ERROR_INVALID_PARAMETER);
1668 return FALSE;
1669 }
1670 dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
1671 dwExStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
1672 NC_GetInsideRect(hwnd, COORDS_SCREEN, &tbi->rcTitleBar, dwStyle, dwExStyle);
1673
1674 tbi->rcTitleBar.bottom = tbi->rcTitleBar.top;
1675 if(dwExStyle & WS_EX_TOOLWINDOW)
1676 tbi->rcTitleBar.bottom += GetSystemMetrics(SM_CYSMCAPTION);
1677 else {
1678 tbi->rcTitleBar.bottom += GetSystemMetrics(SM_CYCAPTION);
1679 tbi->rcTitleBar.left += GetSystemMetrics(SM_CXSIZE);
1680 }
1681
1682 ZeroMemory(tbi->rgstate, sizeof(tbi->rgstate));
1683 /* Does the title bar always have STATE_SYSTEM_FOCUSABLE?
1684 * Under XP it seems to
1685 */
1686 tbi->rgstate[0] = STATE_SYSTEM_FOCUSABLE;
1687 if(dwStyle & WS_CAPTION) {
1688 tbi->rgstate[1] = STATE_SYSTEM_INVISIBLE;
1689 if(dwStyle & WS_SYSMENU) {
1690 if(!(dwStyle & (WS_MINIMIZEBOX|WS_MAXIMIZEBOX))) {
1691 tbi->rgstate[2] = STATE_SYSTEM_INVISIBLE;
1692 tbi->rgstate[3] = STATE_SYSTEM_INVISIBLE;
1693 }
1694 else {
1695 if(!(dwStyle & WS_MINIMIZEBOX))
1696 tbi->rgstate[2] = STATE_SYSTEM_UNAVAILABLE;
1697 if(!(dwStyle & WS_MAXIMIZEBOX))
1698 tbi->rgstate[3] = STATE_SYSTEM_UNAVAILABLE;
1699 }
1700 if(!(dwExStyle & WS_EX_CONTEXTHELP))
1701 tbi->rgstate[4] = STATE_SYSTEM_INVISIBLE;
1702 if(GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE)
1703 tbi->rgstate[5] = STATE_SYSTEM_UNAVAILABLE;
1704 }
1705 else {
1706 tbi->rgstate[2] = STATE_SYSTEM_INVISIBLE;
1707 tbi->rgstate[3] = STATE_SYSTEM_INVISIBLE;
1708 tbi->rgstate[4] = STATE_SYSTEM_INVISIBLE;
1709 tbi->rgstate[5] = STATE_SYSTEM_INVISIBLE;
1710 }
1711 }
1712 else
1713 tbi->rgstate[0] |= STATE_SYSTEM_INVISIBLE;
1714 return TRUE;
1715 }
Windows API implementation