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