?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 014043c4937c940c54cd1214c96e33a3b3c8cf7d
[wine/hacks.git] / dlls / user32 / nonclient.c
blobd8a018808310efc07ffecaff3c22cffe76e8bf56
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 #define SC_PUTMARK (SC_SCREENSAVE+2)
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(w) ((((w)->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD) && ((w)->wIDmenu != 0))
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 if(style & WS_ICONIC) return;
90
91 if ((exStyle & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) ==
92 WS_EX_STATICEDGE)
93 {
94 adjust = 1; /* for the outer frame always present */
95 }
96 else
97 {
98 adjust = 0;
99 if ((exStyle & WS_EX_DLGMODALFRAME) ||
100 (style & (WS_THICKFRAME|WS_DLGFRAME))) adjust = 2; /* outer */
101 }
102 if (style & WS_THICKFRAME)
103 adjust += ( GetSystemMetrics (SM_CXFRAME)
104 - GetSystemMetrics (SM_CXDLGFRAME)); /* The resize border */
105 if ((style & (WS_BORDER|WS_DLGFRAME)) ||
106 (exStyle & WS_EX_DLGMODALFRAME))
107 adjust++; /* The other border */
108
109 InflateRect (rect, adjust, adjust);
110
111 if ((style & WS_CAPTION) == WS_CAPTION)
112 {
113 if (exStyle & WS_EX_TOOLWINDOW)
114 rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
115 else
116 rect->top -= GetSystemMetrics(SM_CYCAPTION);
117 }
118 if (menu) rect->top -= GetSystemMetrics(SM_CYMENU);
119 }
120
121
122 /******************************************************************************
123 * NC_AdjustRectInner
124 *
125 * Computes the size of the "inside" part of the window based on the
126 * parameters of the client area.
127 *
128 * PARAMS
129 * LPRECT rect
130 * DWORD style
131 * DWORD exStyle
132 *
133 * NOTES
134 * "Inner" part of a window means the window frame inside of the flat
135 * window frame. It includes the client edge, the static edge and the
136 * scroll bars.
137 *
138 *****************************************************************************/
139
140 static void
141 NC_AdjustRectInner (LPRECT rect, DWORD style, DWORD exStyle)
142 {
143 if(style & WS_ICONIC) return;
144
145 if (exStyle & WS_EX_CLIENTEDGE)
146 InflateRect(rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
147
148 if (style & WS_VSCROLL)
149 {
150 if((exStyle & WS_EX_LEFTSCROLLBAR) != 0)
151 rect->left -= GetSystemMetrics(SM_CXVSCROLL);
152 else
153 rect->right += GetSystemMetrics(SM_CXVSCROLL);
154 }
155 if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
156 }
157
158
159
160 static HICON NC_IconForWindow( HWND hwnd )
161 {
162 HICON hIcon = 0;
163 WND *wndPtr = WIN_GetPtr( hwnd );
164
165 if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
166 {
167 hIcon = wndPtr->hIconSmall;
168 if (!hIcon) hIcon = wndPtr->hIcon;
169 WIN_ReleasePtr( wndPtr );
170 }
171 if (!hIcon) hIcon = (HICON) GetClassLongPtrW( hwnd, GCLP_HICONSM );
172 if (!hIcon) hIcon = (HICON) GetClassLongPtrW( hwnd, GCLP_HICON );
173
174 /* If there is no hIcon specified and this is a modal dialog,
175 * get the default one.
176 */
177 if (!hIcon && (GetWindowLongW( hwnd, GWL_STYLE ) & DS_MODALFRAME))
178 hIcon = LoadImageW(0, (LPCWSTR)IDI_WINLOGO, IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
179 return hIcon;
180 }
181
182 /* Draws the bar part(ie the big rectangle) of the caption */
183 static void NC_DrawCaptionBar (HDC hdc, const RECT *rect, DWORD dwStyle,
184 BOOL active, BOOL gradient)
185 {
186 if (gradient)
187 {
188 TRIVERTEX vertices[6];
189 DWORD colLeft =
190 GetSysColor (active ? COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION);
191 DWORD colRight =
192 GetSysColor (active ? COLOR_GRADIENTACTIVECAPTION
193 : COLOR_GRADIENTINACTIVECAPTION);
194 int v;
195 int buttonsAreaSize = GetSystemMetrics(SM_CYCAPTION) - 1;
196 static GRADIENT_RECT mesh[] = {{0, 1}, {2, 3}, {4, 5}};
197
198 for (v = 0; v < 3; v++)
199 {
200 vertices[v].Red = GetRValue (colLeft) << 8;
201 vertices[v].Green = GetGValue (colLeft) << 8;
202 vertices[v].Blue = GetBValue (colLeft) << 8;
203 vertices[v].Alpha = 0x8000;
204 vertices[v+3].Red = GetRValue (colRight) << 8;
205 vertices[v+3].Green = GetGValue (colRight) << 8;
206 vertices[v+3].Blue = GetBValue (colRight) << 8;
207 vertices[v+3].Alpha = 0x8000;
208 }
209
210 if ((dwStyle & WS_SYSMENU)
211 && ((dwStyle & WS_MAXIMIZEBOX) || (dwStyle & WS_MINIMIZEBOX)))
212 buttonsAreaSize += 2 * (GetSystemMetrics(SM_CXSIZE) + 1);
213
214 /* area behind icon; solid filled with left color */
215 vertices[0].x = rect->left;
216 vertices[0].y = rect->top;
217 if (dwStyle & WS_SYSMENU)
218 vertices[1].x =
219 min (rect->left + GetSystemMetrics(SM_CXSMICON), rect->right);
220 else
221 vertices[1].x = vertices[0].x;
222 vertices[1].y = rect->bottom;
223
224 /* area behind text; gradient */
225 vertices[2].x = vertices[1].x;
226 vertices[2].y = rect->top;
227 vertices[3].x = max (vertices[2].x, rect->right - buttonsAreaSize);
228 vertices[3].y = rect->bottom;
229
230 /* area behind buttons; solid filled with right color */
231 vertices[4].x = vertices[3].x;
232 vertices[4].y = rect->top;
233 vertices[5].x = rect->right;
234 vertices[5].y = rect->bottom;
235
236 GdiGradientFill (hdc, vertices, 6, mesh, 3, GRADIENT_FILL_RECT_H);
237 }
238 else
239 FillRect (hdc, rect, GetSysColorBrush (active ?
240 COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
241 }
242
243 /***********************************************************************
244 * DrawCaption (USER32.@) Draws a caption bar
245 *
246 * PARAMS
247 * hwnd [I]
248 * hdc [I]
249 * lpRect [I]
250 * uFlags [I]
251 *
252 * RETURNS
253 * Success:
254 * Failure:
255 */
256
257 BOOL WINAPI
258 DrawCaption (HWND hwnd, HDC hdc, const RECT *lpRect, UINT uFlags)
259 {
260 return DrawCaptionTempW (hwnd, hdc, lpRect, 0, 0, NULL, uFlags & 0x103F);
261 }
262
263
264 /***********************************************************************
265 * DrawCaptionTempA (USER32.@)
266 */
267 BOOL WINAPI DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
268 HICON hIcon, LPCSTR str, UINT uFlags)
269 {
270 LPWSTR strW;
271 INT len;
272 BOOL ret = FALSE;
273
274 if (!(uFlags & DC_TEXT) || !str)
275 return DrawCaptionTempW( hwnd, hdc, rect, hFont, hIcon, NULL, uFlags );
276
277 len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
278 if ((strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
279 {
280 MultiByteToWideChar( CP_ACP, 0, str, -1, strW, len );
281 ret = DrawCaptionTempW (hwnd, hdc, rect, hFont, hIcon, strW, uFlags);
282 HeapFree( GetProcessHeap (), 0, strW );
283 }
284 return ret;
285 }
286
287
288 /***********************************************************************
289 * DrawCaptionTempW (USER32.@)
290 */
291 BOOL WINAPI DrawCaptionTempW (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
292 HICON hIcon, LPCWSTR str, UINT uFlags)
293 {
294 RECT rc = *rect;
295
296 TRACE("(%p,%p,%p,%p,%p,%s,%08x)\n",
297 hwnd, hdc, rect, hFont, hIcon, debugstr_w(str), uFlags);
298
299 /* drawing background */
300 if (uFlags & DC_INBUTTON) {
301 FillRect (hdc, &rc, GetSysColorBrush (COLOR_3DFACE));
302
303 if (uFlags & DC_ACTIVE) {
304 HBRUSH hbr = SelectObject (hdc, SYSCOLOR_55AABrush);
305 PatBlt (hdc, rc.left, rc.top,
306 rc.right-rc.left, rc.bottom-rc.top, 0xFA0089);
307 SelectObject (hdc, hbr);
308 }
309 }
310 else {
311 DWORD style = GetWindowLongW (hwnd, GWL_STYLE);
312 NC_DrawCaptionBar (hdc, &rc, style, uFlags & DC_ACTIVE, uFlags & DC_GRADIENT);
313 }
314
315
316 /* drawing icon */
317 if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP)) {
318 POINT pt;
319
320 pt.x = rc.left + 2;
321 pt.y = (rc.bottom + rc.top - GetSystemMetrics(SM_CYSMICON)) / 2;
322
323 if (!hIcon) hIcon = NC_IconForWindow(hwnd);
324 DrawIconEx (hdc, pt.x, pt.y, hIcon, GetSystemMetrics(SM_CXSMICON),
325 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
326 rc.left += (rc.bottom - rc.top);
327 }
328
329 /* drawing text */
330 if (uFlags & DC_TEXT) {
331 HFONT hOldFont;
332
333 if (uFlags & DC_INBUTTON)
334 SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
335 else if (uFlags & DC_ACTIVE)
336 SetTextColor (hdc, GetSysColor (COLOR_CAPTIONTEXT));
337 else
338 SetTextColor (hdc, GetSysColor (COLOR_INACTIVECAPTIONTEXT));
339
340 SetBkMode (hdc, TRANSPARENT);
341
342 if (hFont)
343 hOldFont = SelectObject (hdc, hFont);
344 else {
345 NONCLIENTMETRICSW nclm;
346 HFONT hNewFont;
347 nclm.cbSize = sizeof(NONCLIENTMETRICSW);
348 SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
349 hNewFont = CreateFontIndirectW ((uFlags & DC_SMALLCAP) ?
350 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
351 hOldFont = SelectObject (hdc, hNewFont);
352 }
353
354 if (str)
355 DrawTextW (hdc, str, -1, &rc,
356 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
357 else {
358 WCHAR szText[128];
359 INT nLen;
360 nLen = GetWindowTextW (hwnd, szText, 128);
361 DrawTextW (hdc, szText, nLen, &rc,
362 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
363 }
364
365 if (hFont)
366 SelectObject (hdc, hOldFont);
367 else
368 DeleteObject (SelectObject (hdc, hOldFont));
369 }
370
371 /* drawing focus ??? */
372 if (uFlags & 0x2000)
373 FIXME("undocumented flag (0x2000)!\n");
374
375 return 0;
376 }
377
378
379 /***********************************************************************
380 * AdjustWindowRect (USER32.@)
381 */
382 BOOL WINAPI AdjustWindowRect( LPRECT rect, DWORD style, BOOL menu )
383 {
384 return AdjustWindowRectEx( rect, style, menu, 0 );
385 }
386
387
388 /***********************************************************************
389 * AdjustWindowRectEx (USER32.@)
390 */
391 BOOL WINAPI AdjustWindowRectEx( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
392 {
393 /* Correct the window style */
394 style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD);
395 exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
396 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
397 if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
398
399 TRACE("(%s) %08x %d %08x\n", wine_dbgstr_rect(rect), style, menu, exStyle );
400
401 NC_AdjustRectOuter( rect, style, menu, exStyle );
402 NC_AdjustRectInner( rect, style, exStyle );
403
404 return TRUE;
405 }
406
407
408 /***********************************************************************
409 * NC_HandleNCCalcSize
410 *
411 * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
412 */
413 LRESULT NC_HandleNCCalcSize( HWND hwnd, RECT *winRect )
414 {
415 RECT tmpRect = { 0, 0, 0, 0 };
416 LRESULT result = 0;
417 LONG cls_style = GetClassLongW(hwnd, GCL_STYLE);
418 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
419 LONG exStyle = GetWindowLongW( hwnd, GWL_EXSTYLE );
420
421 if (cls_style & CS_VREDRAW) result |= WVR_VREDRAW;
422 if (cls_style & CS_HREDRAW) result |= WVR_HREDRAW;
423
424 if (!IsIconic(hwnd))
425 {
426 NC_AdjustRectOuter( &tmpRect, style, FALSE, exStyle );
427
428 winRect->left -= tmpRect.left;
429 winRect->top -= tmpRect.top;
430 winRect->right -= tmpRect.right;
431 winRect->bottom -= tmpRect.bottom;
432
433 if (((style & (WS_CHILD | WS_POPUP)) != WS_CHILD) && GetMenu(hwnd))
434 {
435 TRACE("Calling GetMenuBarHeight with hwnd %p, width %d, at (%d, %d).\n",
436 hwnd, winRect->right - winRect->left, -tmpRect.left, -tmpRect.top );
437
438 winRect->top +=
439 MENU_GetMenuBarHeight( hwnd,
440 winRect->right - winRect->left,
441 -tmpRect.left, -tmpRect.top );
442 }
443
444 if( exStyle & WS_EX_CLIENTEDGE)
445 if( winRect->right - winRect->left > 2 * GetSystemMetrics(SM_CXEDGE) &&
446 winRect->bottom - winRect->top > 2 * GetSystemMetrics(SM_CYEDGE))
447 InflateRect( winRect, - GetSystemMetrics(SM_CXEDGE),
448 - GetSystemMetrics(SM_CYEDGE));
449
450 if (style & WS_VSCROLL)
451 if( winRect->right - winRect->left >= GetSystemMetrics(SM_CXVSCROLL)){
452 if((exStyle & WS_EX_LEFTSCROLLBAR) != 0)
453 winRect->left += GetSystemMetrics(SM_CXVSCROLL);
454 else
455 winRect->right -= GetSystemMetrics(SM_CXVSCROLL);
456 }
457
458 if (style & WS_HSCROLL)
459 if( winRect->bottom - winRect->top > GetSystemMetrics(SM_CYHSCROLL))
460 winRect->bottom -= GetSystemMetrics(SM_CYHSCROLL);
461
462 if (winRect->top > winRect->bottom)
463 winRect->bottom = winRect->top;
464
465 if (winRect->left > winRect->right)
466 winRect->right = winRect->left;
467 }
468 return result;
469 }
470
471
472 /***********************************************************************
473 * NC_GetInsideRect
474 *
475 * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
476 * but without the borders (if any).
477 * The rectangle is in window coordinates (for drawing with GetWindowDC()).
478 */
479 static void NC_GetInsideRect( HWND hwnd, RECT *rect )
480 {
481 WND *wndPtr = WIN_GetPtr( hwnd );
482
483 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return;
484
485 rect->top = rect->left = 0;
486 rect->right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
487 rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
488
489 if (wndPtr->dwStyle & WS_ICONIC) goto END;
490
491 /* Remove frame from rectangle */
492 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
493 {
494 InflateRect( rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
495 }
496 else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
497 {
498 InflateRect( rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
499 }
500 else if (HAS_THINFRAME( wndPtr->dwStyle ))
501 {
502 InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
503 }
504
505 /* We have additional border information if the window
506 * is a child (but not an MDI child) */
507 if ( (wndPtr->dwStyle & WS_CHILD) &&
508 ( (wndPtr->dwExStyle & WS_EX_MDICHILD) == 0 ) )
509 {
510 if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
511 InflateRect (rect, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYEDGE));
512 if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
513 InflateRect (rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
514 }
515
516 END:
517 WIN_ReleasePtr( wndPtr );
518 }
519
520
521 /***********************************************************************
522 * NC_DoNCHitTest
523 *
524 * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
525 *
526 * FIXME: Just a modified copy of the Win 3.1 version.
527 */
528
529 static LRESULT NC_DoNCHitTest (WND *wndPtr, POINT pt )
530 {
531 RECT rect, rcClient;
532 POINT ptClient;
533
534 TRACE("hwnd=%p pt=%d,%d\n", wndPtr->hwndSelf, pt.x, pt.y );
535
536 GetWindowRect(wndPtr->hwndSelf, &rect );
537 if (!PtInRect( &rect, pt )) return HTNOWHERE;
538
539 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
540
541 /* Check client area */
542 ptClient = pt;
543 ScreenToClient( wndPtr->hwndSelf, &ptClient );
544 GetClientRect( wndPtr->hwndSelf, &rcClient );
545 if (PtInRect( &rcClient, ptClient )) return HTCLIENT;
546
547 /* Check borders */
548 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
549 {
550 InflateRect( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
551 if (!PtInRect( &rect, pt ))
552 {
553 /* Check top sizing border */
554 if (pt.y < rect.top)
555 {
556 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
557 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
558 return HTTOP;
559 }
560 /* Check bottom sizing border */
561 if (pt.y >= rect.bottom)
562 {
563 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
564 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
565 return HTBOTTOM;
566 }
567 /* Check left sizing border */
568 if (pt.x < rect.left)
569 {
570 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
571 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
572 return HTLEFT;
573 }
574 /* Check right sizing border */
575 if (pt.x >= rect.right)
576 {
577 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
578 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
579 return HTRIGHT;
580 }
581 }
582 }
583 else /* No thick frame */
584 {
585 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
586 InflateRect(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
587 else if (HAS_THINFRAME( wndPtr->dwStyle ))
588 InflateRect(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
589 if (!PtInRect( &rect, pt )) return HTBORDER;
590 }
591
592 /* Check caption */
593
594 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
595 {
596 if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
597 rect.top += GetSystemMetrics(SM_CYSMCAPTION) - 1;
598 else
599 rect.top += GetSystemMetrics(SM_CYCAPTION) - 1;
600 if (!PtInRect( &rect, pt ))
601 {
602 BOOL min_or_max_box = (wndPtr->dwStyle & WS_MAXIMIZEBOX) ||
603 (wndPtr->dwStyle & WS_MINIMIZEBOX);
604 /* Check system menu */
605 if ((wndPtr->dwStyle & WS_SYSMENU) && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
606 {
607 if (NC_IconForWindow(wndPtr->hwndSelf))
608 rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
609 }
610 if (pt.x < rect.left) return HTSYSMENU;
611
612 /* Check close button */
613 if (wndPtr->dwStyle & WS_SYSMENU)
614 rect.right -= GetSystemMetrics(SM_CYCAPTION);
615 if (pt.x > rect.right) return HTCLOSE;
616
617 /* Check maximize box */
618 /* In win95 there is automatically a Maximize button when there is a minimize one*/
619 if (min_or_max_box && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
620 rect.right -= GetSystemMetrics(SM_CXSIZE);
621 if (pt.x > rect.right) return HTMAXBUTTON;
622
623 /* Check minimize box */
624 /* In win95 there is automatically a Maximize button when there is a Maximize one*/
625 if (min_or_max_box && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
626 rect.right -= GetSystemMetrics(SM_CXSIZE);
627
628 if (pt.x > rect.right) return HTMINBUTTON;
629 return HTCAPTION;
630 }
631 }
632
633 /* Check vertical scroll bar */
634
635 if (wndPtr->dwStyle & WS_VSCROLL)
636 {
637 if((wndPtr->dwExStyle & WS_EX_LEFTSCROLLBAR) != 0)
638 rcClient.left -= GetSystemMetrics(SM_CXVSCROLL);
639 else
640 rcClient.right += GetSystemMetrics(SM_CXVSCROLL);
641 if (PtInRect( &rcClient, ptClient )) return HTVSCROLL;
642 }
643
644 /* Check horizontal scroll bar */
645
646 if (wndPtr->dwStyle & WS_HSCROLL)
647 {
648 rcClient.bottom += GetSystemMetrics(SM_CYHSCROLL);
649 if (PtInRect( &rcClient, ptClient ))
650 {
651 /* Check size box */
652 if ((wndPtr->dwStyle & WS_VSCROLL) &&
653 ((((wndPtr->dwExStyle & WS_EX_LEFTSCROLLBAR) != 0) && (ptClient.x <= rcClient.left + GetSystemMetrics(SM_CXVSCROLL))) ||
654 (((wndPtr->dwExStyle & WS_EX_LEFTSCROLLBAR) == 0) && (ptClient.x >= rcClient.right - GetSystemMetrics(SM_CXVSCROLL)))))
655 return HTSIZE;
656 return HTHSCROLL;
657 }
658 }
659
660 /* Check menu bar */
661
662 if (HAS_MENU(wndPtr))
663 {
664 if ((ptClient.y < 0) && (ptClient.x >= 0) && (ptClient.x < rcClient.right))
665 return HTMENU;
666 }
667
668 /* Has to return HTNOWHERE if nothing was found
669 Could happen when a window has a customized non client area */
670 return HTNOWHERE;
671 }
672
673
674 /***********************************************************************
675 * NC_HandleNCHitTest
676 *
677 * Handle a WM_NCHITTEST message. Called from DefWindowProc().
678 */
679 LRESULT NC_HandleNCHitTest (HWND hwnd , POINT pt)
680 {
681 LRESULT retvalue;
682 WND *wndPtr = WIN_GetPtr( hwnd );
683
684 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return HTERROR;
685
686 retvalue = NC_DoNCHitTest (wndPtr, pt);
687 WIN_ReleasePtr( wndPtr );
688 return retvalue;
689 }
690
691
692 /******************************************************************************
693 *
694 * NC_DrawSysButton
695 *
696 * Draws the system icon.
697 *
698 *****************************************************************************/
699 BOOL NC_DrawSysButton (HWND hwnd, HDC hdc, BOOL down)
700 {
701 HICON hIcon = NC_IconForWindow( hwnd );
702
703 if (hIcon)
704 {
705 RECT rect;
706 NC_GetInsideRect( hwnd, &rect );
707 DrawIconEx (hdc, rect.left + 2, rect.top + 1, 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
729 NC_GetInsideRect( hwnd, &rect );
730
731 /* A tool window has a smaller Close button */
732 if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_TOOLWINDOW)
733 {
734 INT iBmpHeight = 11; /* Windows does not use SM_CXSMSIZE and SM_CYSMSIZE */
735 INT iBmpWidth = 11; /* it uses 11x11 for the close button in tool window */
736 INT iCaptionHeight = GetSystemMetrics(SM_CYSMCAPTION);
737
738 rect.top = rect.top + (iCaptionHeight - 1 - iBmpHeight) / 2;
739 rect.left = rect.right - (iCaptionHeight + 1 + iBmpWidth) / 2;
740 rect.bottom = rect.top + iBmpHeight;
741 rect.right = rect.left + iBmpWidth;
742 }
743 else
744 {
745 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
746 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 2;
747 rect.top += 2;
748 rect.right -= 2;
749 }
750 DrawFrameControl( hdc, &rect, DFC_CAPTION,
751 (DFCS_CAPTIONCLOSE |
752 (down ? DFCS_PUSHED : 0) |
753 (bGrayed ? DFCS_INACTIVE : 0)) );
754 }
755
756 /******************************************************************************
757 * NC_DrawMaxButton
758 *
759 * Draws the maximize button for windows.
760 * If bGrayed is true, then draw a disabled Maximize button
761 */
762 static void NC_DrawMaxButton(HWND hwnd,HDC hdc,BOOL down, BOOL bGrayed)
763 {
764 RECT rect;
765 UINT flags;
766
767 /* never draw maximize box when window has WS_EX_TOOLWINDOW style */
768 if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_TOOLWINDOW)
769 return;
770
771 flags = IsZoomed(hwnd) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMAX;
772
773 NC_GetInsideRect( hwnd, &rect );
774 if (GetWindowLongW( hwnd, GWL_STYLE) & WS_SYSMENU)
775 rect.right -= GetSystemMetrics(SM_CXSIZE);
776 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
777 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 2;
778 rect.top += 2;
779 rect.right -= 2;
780 if (down) flags |= DFCS_PUSHED;
781 if (bGrayed) flags |= DFCS_INACTIVE;
782 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
783 }
784
785 /******************************************************************************
786 * NC_DrawMinButton
787 *
788 * Draws the minimize button for windows.
789 * If bGrayed is true, then draw a disabled Minimize button
790 */
791 static void NC_DrawMinButton(HWND hwnd,HDC hdc,BOOL down, BOOL bGrayed)
792 {
793 RECT rect;
794 UINT flags = DFCS_CAPTIONMIN;
795 DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
796
797 /* never draw minimize box when window has WS_EX_TOOLWINDOW style */
798 if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_TOOLWINDOW)
799 return;
800
801 NC_GetInsideRect( hwnd, &rect );
802 if (style & WS_SYSMENU)
803 rect.right -= GetSystemMetrics(SM_CXSIZE);
804 if (style & (WS_MAXIMIZEBOX|WS_MINIMIZEBOX))
805 rect.right -= GetSystemMetrics(SM_CXSIZE) - 2;
806 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
807 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 2;
808 rect.top += 2;
809 rect.right -= 2;
810 if (down) flags |= DFCS_PUSHED;
811 if (bGrayed) flags |= DFCS_INACTIVE;
812 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
813 }
814
815 /******************************************************************************
816 *
817 * NC_DrawFrame
818 *
819 * Draw a window frame inside the given rectangle, and update the rectangle.
820 *
821 * Bugs
822 * Many. First, just what IS a frame in Win95? Note that the 3D look
823 * on the outer edge is handled by NC_DoNCPaint. As is the inner
824 * edge. The inner rectangle just inside the frame is handled by the
825 * Caption code.
826 *
827 * In short, for most people, this function should be a nop (unless
828 * you LIKE thick borders in Win95/NT4.0 -- I've been working with
829 * them lately, but just to get this code right). Even so, it doesn't
830 * appear to be so. It's being worked on...
831 *
832 *****************************************************************************/
833
834 static void NC_DrawFrame( HDC hdc, RECT *rect, BOOL active, DWORD style, DWORD exStyle)
835 {
836 INT width, height;
837
838 /* Firstly the "thick" frame */
839 if (style & WS_THICKFRAME)
840 {
841 width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXDLGFRAME);
842 height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYDLGFRAME);
843
844 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
845 COLOR_INACTIVEBORDER) );
846 /* Draw frame */
847 PatBlt( hdc, rect->left, rect->top,
848 rect->right - rect->left, height, PATCOPY );
849 PatBlt( hdc, rect->left, rect->top,
850 width, rect->bottom - rect->top, PATCOPY );
851 PatBlt( hdc, rect->left, rect->bottom - 1,
852 rect->right - rect->left, -height, PATCOPY );
853 PatBlt( hdc, rect->right - 1, rect->top,
854 -width, rect->bottom - rect->top, PATCOPY );
855
856 InflateRect( rect, -width, -height );
857 }
858
859 /* Now the other bit of the frame */
860 if ((style & (WS_BORDER|WS_DLGFRAME)) ||
861 (exStyle & WS_EX_DLGMODALFRAME))
862 {
863 width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
864 height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
865 /* This should give a value of 1 that should also work for a border */
866
867 SelectObject( hdc, GetSysColorBrush(
868 (exStyle & (WS_EX_DLGMODALFRAME|WS_EX_CLIENTEDGE)) ?
869 COLOR_3DFACE :
870 (exStyle & WS_EX_STATICEDGE) ?
871 COLOR_WINDOWFRAME :
872 (style & (WS_DLGFRAME|WS_THICKFRAME)) ?
873 COLOR_3DFACE :
874 /* else */
875 COLOR_WINDOWFRAME));
876
877 /* Draw frame */
878 PatBlt( hdc, rect->left, rect->top,
879 rect->right - rect->left, height, PATCOPY );
880 PatBlt( hdc, rect->left, rect->top,
881 width, rect->bottom - rect->top, PATCOPY );
882 PatBlt( hdc, rect->left, rect->bottom - 1,
883 rect->right - rect->left, -height, PATCOPY );
884 PatBlt( hdc, rect->right - 1, rect->top,
885 -width, rect->bottom - rect->top, PATCOPY );
886
887 InflateRect( rect, -width, -height );
888 }
889 }
890
891
892 /******************************************************************************
893 *
894 * NC_DrawCaption
895 *
896 * Draw the window caption for windows.
897 * The correct pen for the window frame must be selected in the DC.
898 *
899 *****************************************************************************/
900
901 static void NC_DrawCaption( HDC hdc, RECT *rect, HWND hwnd, DWORD style,
902 DWORD exStyle, BOOL active )
903 {
904 RECT r = *rect;
905 WCHAR buffer[256];
906 HPEN hPrevPen;
907 HMENU hSysMenu;
908 BOOL gradient = FALSE;
909
910 hPrevPen = SelectObject( hdc, SYSCOLOR_GetPen(
911 ((exStyle & (WS_EX_STATICEDGE|WS_EX_CLIENTEDGE|
912 WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE) ?
913 COLOR_WINDOWFRAME : COLOR_3DFACE) );
914 MoveToEx( hdc, r.left, r.bottom - 1, NULL );
915 LineTo( hdc, r.right, r.bottom - 1 );
916 SelectObject( hdc, hPrevPen );
917 r.bottom--;
918
919 SystemParametersInfoW (SPI_GETGRADIENTCAPTIONS, 0, &gradient, 0);
920 NC_DrawCaptionBar (hdc, &r, style, active, gradient);
921
922 if ((style & WS_SYSMENU) && !(exStyle & WS_EX_TOOLWINDOW)) {
923 if (NC_DrawSysButton (hwnd, hdc, FALSE))
924 r.left += GetSystemMetrics(SM_CXSMICON) + 2;
925 }
926
927 if (style & WS_SYSMENU)
928 {
929 UINT state;
930
931 /* Go get the sysmenu */
932 hSysMenu = GetSystemMenu(hwnd, FALSE);
933 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
934
935 /* Draw a grayed close button if disabled or if SC_CLOSE is not there */
936 NC_DrawCloseButton (hwnd, hdc, FALSE,
937 (state & (MF_DISABLED | MF_GRAYED)) || (state == 0xFFFFFFFF));
938 r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
939
940 if ((style & WS_MAXIMIZEBOX) || (style & WS_MINIMIZEBOX))
941 {
942 /* In win95 the two buttons are always there */
943 /* But if the menu item is not in the menu they're disabled*/
944
945 NC_DrawMaxButton( hwnd, hdc, FALSE, (!(style & WS_MAXIMIZEBOX)));
946 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
947
948 NC_DrawMinButton( hwnd, hdc, FALSE, (!(style & WS_MINIMIZEBOX)));
949 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
950 }
951 }
952
953 if (GetWindowTextW( hwnd, buffer, sizeof(buffer)/sizeof(WCHAR) ))
954 {
955 NONCLIENTMETRICSW nclm;
956 HFONT hFont, hOldFont;
957 nclm.cbSize = sizeof(nclm);
958 SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
959 if (exStyle & WS_EX_TOOLWINDOW)
960 hFont = CreateFontIndirectW (&nclm.lfSmCaptionFont);
961 else
962 hFont = CreateFontIndirectW (&nclm.lfCaptionFont);
963 hOldFont = SelectObject (hdc, hFont);
964 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
965 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
966 SetBkMode( hdc, TRANSPARENT );
967 r.left += 2;
968 DrawTextW( hdc, buffer, -1, &r,
969 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
970 DeleteObject (SelectObject (hdc, hOldFont));
971 }
972 }
973
974
975 /******************************************************************************
976 * NC_DoNCPaint
977 *
978 * Paint the non-client area for windows.
979 */
980 static void NC_DoNCPaint( HWND hwnd, HRGN clip, BOOL suppress_menupaint )
981 {
982 HDC hdc;
983 RECT rfuzz, rect, rectClip;
984 BOOL active;
985 WND *wndPtr;
986 DWORD dwStyle, dwExStyle;
987 WORD flags;
988 HRGN hrgn;
989 RECT rectClient, rectWindow;
990 int has_menu;
991
992 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return;
993 has_menu = HAS_MENU(wndPtr);
994 dwStyle = wndPtr->dwStyle;
995 dwExStyle = wndPtr->dwExStyle;
996 flags = wndPtr->flags;
997 rectWindow = wndPtr->rectWindow;
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 GetClientRect( hwnd, &rectClient );
1015 MapWindowPoints( hwnd, 0, (POINT *)&rectClient, 2 );
1016 hrgn = CreateRectRgnIndirect( &rectClient );
1017
1018 if (clip > (HRGN)1)
1019 {
1020 CombineRgn( hrgn, clip, hrgn, RGN_DIFF );
1021 hdc = GetDCEx( hwnd, hrgn, DCX_USESTYLE | DCX_WINDOW | DCX_INTERSECTRGN );
1022 }
1023 else
1024 {
1025 hdc = GetDCEx( hwnd, hrgn, DCX_USESTYLE | DCX_WINDOW | DCX_EXCLUDERGN );
1026 }
1027
1028 if (!hdc) return;
1029
1030 rect.top = rect.left = 0;
1031 rect.right = rectWindow.right - rectWindow.left;
1032 rect.bottom = rectWindow.bottom - rectWindow.top;
1033 GetClipBox( hdc, &rectClip );
1034
1035 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1036
1037 if (HAS_STATICOUTERFRAME(dwStyle, dwExStyle)) {
1038 DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1039 }
1040 else if (HAS_BIGFRAME( dwStyle, dwExStyle)) {
1041 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1042 }
1043
1044 NC_DrawFrame(hdc, &rect, active, dwStyle, dwExStyle );
1045
1046 if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1047 {
1048 RECT r = rect;
1049 if (dwExStyle & WS_EX_TOOLWINDOW) {
1050 r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
1051 rect.top += GetSystemMetrics(SM_CYSMCAPTION);
1052 }
1053 else {
1054 r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
1055 rect.top += GetSystemMetrics(SM_CYCAPTION);
1056 }
1057 if( IntersectRect( &rfuzz, &r, &rectClip ) )
1058 NC_DrawCaption(hdc, &r, hwnd, dwStyle, dwExStyle, active);
1059 }
1060
1061 if (has_menu)
1062 {
1063 RECT r = rect;
1064 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
1065
1066 TRACE("Calling DrawMenuBar with rect (%s)\n", wine_dbgstr_rect(&r));
1067
1068 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
1069 }
1070
1071 TRACE("After MenuBar, rect is (%s).\n", wine_dbgstr_rect(&rect));
1072
1073 if (dwExStyle & WS_EX_CLIENTEDGE)
1074 DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1075
1076 /* Draw the scroll-bars */
1077
1078 if (dwStyle & WS_VSCROLL)
1079 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1080 if (dwStyle & WS_HSCROLL)
1081 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1082
1083 /* Draw the "size-box" */
1084 if ((dwStyle & WS_VSCROLL) && (dwStyle & WS_HSCROLL))
1085 {
1086 RECT r = rect;
1087 if((dwExStyle & WS_EX_LEFTSCROLLBAR) != 0)
1088 r.right = r.left + GetSystemMetrics(SM_CXVSCROLL) + 1;
1089 else
1090 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1091 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1092 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1093 }
1094
1095 ReleaseDC( hwnd, hdc );
1096 }
1097
1098
1099
1100
1101 /***********************************************************************
1102 * NC_HandleNCPaint
1103 *
1104 * Handle a WM_NCPAINT message. Called from DefWindowProc().
1105 */
1106 LRESULT NC_HandleNCPaint( HWND hwnd , HRGN clip)
1107 {
1108 DWORD dwStyle = GetWindowLongW( hwnd, GWL_STYLE );
1109
1110 if( dwStyle & WS_VISIBLE )
1111 {
1112 if( dwStyle & WS_MINIMIZE )
1113 WINPOS_RedrawIconTitle( hwnd );
1114 else
1115 NC_DoNCPaint( hwnd, clip, FALSE );
1116 }
1117 return 0;
1118 }
1119
1120
1121 /***********************************************************************
1122 * NC_HandleNCActivate
1123 *
1124 * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1125 */
1126 LRESULT NC_HandleNCActivate( HWND hwnd, WPARAM wParam )
1127 {
1128 WND* wndPtr = WIN_GetPtr( hwnd );
1129
1130 if (!wndPtr || wndPtr == WND_OTHER_PROCESS) return FALSE;
1131
1132 /* Lotus Notes draws menu descriptions in the caption of its main
1133 * window. When it wants to restore original "system" view, it just
1134 * sends WM_NCACTIVATE message to itself. Any optimizations here in
1135 * attempt to minimize redrawings lead to a not restored caption.
1136 */
1137 if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1138 else wndPtr->flags &= ~WIN_NCACTIVATED;
1139 WIN_ReleasePtr( wndPtr );
1140
1141 if (IsIconic(hwnd))
1142 WINPOS_RedrawIconTitle( hwnd );
1143 else
1144 NC_DoNCPaint( hwnd, (HRGN)1, FALSE );
1145
1146 return TRUE;
1147 }
1148
1149
1150 /***********************************************************************
1151 * NC_HandleSetCursor
1152 *
1153 * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1154 */
1155 LRESULT NC_HandleSetCursor( HWND hwnd, WPARAM wParam, LPARAM lParam )
1156 {
1157 hwnd = WIN_GetFullHandle( (HWND)wParam );
1158
1159 switch((short)LOWORD(lParam))
1160 {
1161 case HTERROR:
1162 {
1163 WORD msg = HIWORD( lParam );
1164 if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1165 (msg == WM_RBUTTONDOWN) || (msg == WM_XBUTTONDOWN))
1166 MessageBeep(0);
1167 }
1168 break;
1169
1170 case HTCLIENT:
1171 {
1172 HCURSOR hCursor = (HCURSOR)GetClassLongPtrW(hwnd, GCLP_HCURSOR);
1173 if(hCursor) {
1174 SetCursor(hCursor);
1175 return TRUE;
1176 }
1177 return FALSE;
1178 }
1179
1180 case HTLEFT:
1181 case HTRIGHT:
1182 return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZEWE ) );
1183
1184 case HTTOP:
1185 case HTBOTTOM:
1186 return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENS ) );
1187
1188 case HTTOPLEFT:
1189 case HTBOTTOMRIGHT:
1190 return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENWSE ) );
1191
1192 case HTTOPRIGHT:
1193 case HTBOTTOMLEFT:
1194 return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENESW ) );
1195 }
1196
1197 /* Default cursor: arrow */
1198 return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_ARROW ) );
1199 }
1200
1201 /***********************************************************************
1202 * NC_GetSysPopupPos
1203 */
1204 void NC_GetSysPopupPos( HWND hwnd, RECT* rect )
1205 {
1206 if (IsIconic(hwnd)) GetWindowRect( hwnd, rect );
1207 else
1208 {
1209 WND *wndPtr = WIN_GetPtr( hwnd );
1210 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return;
1211
1212 NC_GetInsideRect( hwnd, rect );
1213 OffsetRect( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
1214 if (wndPtr->dwStyle & WS_CHILD)
1215 ClientToScreen( GetParent(hwnd), (POINT *)rect );
1216 rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
1217 rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
1218 WIN_ReleasePtr( wndPtr );
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, WORD wParam)
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, MAKELONG(msg.pt.x,msg.pt.y) );
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);
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_HandleNCLButtonDblClk
1468 *
1469 * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
1470 */
1471 LRESULT NC_HandleNCLButtonDblClk( HWND hwnd, WPARAM wParam, LPARAM lParam )
1472 {
1473 /*
1474 * if this is an icon, send a restore since we are handling
1475 * a double click
1476 */
1477 if (IsIconic(hwnd))
1478 {
1479 SendMessageW( hwnd, WM_SYSCOMMAND, SC_RESTORE, lParam );
1480 return 0;
1481 }
1482
1483 switch(wParam) /* Hit test */
1484 {
1485 case HTCAPTION:
1486 /* stop processing if WS_MAXIMIZEBOX is missing */
1487 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MAXIMIZEBOX)
1488 SendMessageW( hwnd, WM_SYSCOMMAND,
1489 IsZoomed(hwnd) ? SC_RESTORE : SC_MAXIMIZE, lParam );
1490 break;
1491
1492 case HTSYSMENU:
1493 {
1494 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1495 UINT state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1496
1497 /* If the item close of the sysmenu is disabled or not there do nothing */
1498 if ((state & (MF_DISABLED | MF_GRAYED)) || (state == 0xFFFFFFFF))
1499 break;
1500
1501 SendMessageW( hwnd, WM_SYSCOMMAND, SC_CLOSE, lParam );
1502 break;
1503 }
1504
1505 case HTHSCROLL:
1506 SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
1507 break;
1508
1509 case HTVSCROLL:
1510 SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
1511 break;
1512 }
1513 return 0;
1514 }
1515
1516
1517 /***********************************************************************
1518 * NC_HandleSysCommand
1519 *
1520 * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
1521 */
1522 LRESULT NC_HandleSysCommand( HWND hwnd, WPARAM wParam, LPARAM lParam )
1523 {
1524 TRACE("hwnd %p WM_SYSCOMMAND %lx %lx\n", hwnd, wParam, lParam );
1525
1526 if (!IsWindowEnabled( hwnd )) return 0;
1527
1528 if (HOOK_CallHooks( WH_CBT, HCBT_SYSCOMMAND, wParam, lParam, TRUE ))
1529 return 0;
1530
1531 switch (wParam & 0xfff0)
1532 {
1533 case SC_SIZE:
1534 case SC_MOVE:
1535 USER_Driver->pSysCommandSizeMove( hwnd, wParam );
1536 break;
1537
1538 case SC_MINIMIZE:
1539 if (hwnd == GetForegroundWindow())
1540 ShowOwnedPopups(hwnd,FALSE);
1541 ShowWindow( hwnd, SW_MINIMIZE );
1542 break;
1543
1544 case SC_MAXIMIZE:
1545 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
1546 ShowOwnedPopups(hwnd,TRUE);
1547 ShowWindow( hwnd, SW_MAXIMIZE );
1548 break;
1549
1550 case SC_RESTORE:
1551 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
1552 ShowOwnedPopups(hwnd,TRUE);
1553 ShowWindow( hwnd, SW_RESTORE );
1554 break;
1555
1556 case SC_CLOSE:
1557 return SendMessageW( hwnd, WM_CLOSE, 0, 0 );
1558
1559 case SC_VSCROLL:
1560 case SC_HSCROLL:
1561 {
1562 POINT pt;
1563 pt.x = (short)LOWORD(lParam);
1564 pt.y = (short)HIWORD(lParam);
1565 NC_TrackScrollBar( hwnd, wParam, pt );
1566 }
1567 break;
1568
1569 case SC_MOUSEMENU:
1570 {
1571 POINT pt;
1572 pt.x = (short)LOWORD(lParam);
1573 pt.y = (short)HIWORD(lParam);
1574 MENU_TrackMouseMenuBar( hwnd, wParam & 0x000F, pt );
1575 }
1576 break;
1577
1578 case SC_KEYMENU:
1579 MENU_TrackKbdMenuBar( hwnd, wParam, (WCHAR)lParam );
1580 break;
1581
1582 case SC_TASKLIST:
1583 WinExec( "taskman.exe", SW_SHOWNORMAL );
1584 break;
1585
1586 case SC_SCREENSAVE:
1587 if (wParam == SC_ABOUTWINE)
1588 {
1589 HMODULE hmodule = LoadLibraryA( "shell32.dll" );
1590 if (hmodule)
1591 {
1592 FARPROC aboutproc = GetProcAddress( hmodule, "ShellAboutA" );
1593 if (aboutproc) aboutproc( hwnd, PACKAGE_NAME, PACKAGE_STRING, 0 );
1594 FreeLibrary( hmodule );
1595 }
1596 }
1597 else
1598 if (wParam == SC_PUTMARK)
1599 DPRINTF("Debug mark requested by user\n");
1600 break;
1601
1602 case SC_HOTKEY:
1603 case SC_ARRANGE:
1604 case SC_NEXTWINDOW:
1605 case SC_PREVWINDOW:
1606 FIXME("unimplemented WM_SYSCOMMAND %04lx!\n", wParam);
1607 break;
1608 }
1609 return 0;
1610 }
1611
1612 /***********************************************************************
1613 * GetTitleBarInfo (USER32.@)
1614 * TODO: Handle STATE_SYSTEM_PRESSED
1615 */
1616 BOOL WINAPI GetTitleBarInfo(HWND hwnd, PTITLEBARINFO tbi) {
1617 DWORD dwStyle;
1618 DWORD dwExStyle;
1619 RECT wndRect;
1620
1621 TRACE("(%p %p)\n", hwnd, tbi);
1622
1623 if(tbi->cbSize != sizeof(TITLEBARINFO)) {
1624 TRACE("Invalid TITLEBARINFO size: %d\n", tbi->cbSize);
1625 SetLastError(ERROR_INVALID_PARAMETER);
1626 return FALSE;
1627 }
1628 dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
1629 dwExStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
1630 NC_GetInsideRect(hwnd, &tbi->rcTitleBar);
1631
1632 GetWindowRect(hwnd, &wndRect);
1633
1634 tbi->rcTitleBar.top += wndRect.top;
1635 tbi->rcTitleBar.left += wndRect.left;
1636 tbi->rcTitleBar.right += wndRect.left;
1637
1638 tbi->rcTitleBar.bottom = tbi->rcTitleBar.top;
1639 if(dwExStyle & WS_EX_TOOLWINDOW)
1640 tbi->rcTitleBar.bottom += GetSystemMetrics(SM_CYSMCAPTION);
1641 else {
1642 tbi->rcTitleBar.bottom += GetSystemMetrics(SM_CYCAPTION);
1643 tbi->rcTitleBar.left += GetSystemMetrics(SM_CXSIZE);
1644 }
1645
1646 ZeroMemory(&tbi->rgstate, sizeof(tbi->rgstate));
1647 /* Does the title bar always have STATE_SYSTEM_FOCUSABLE?
1648 * Under XP it seems to
1649 */
1650 tbi->rgstate[0] = STATE_SYSTEM_FOCUSABLE;
1651 if(dwStyle & WS_CAPTION) {
1652 tbi->rgstate[1] = STATE_SYSTEM_INVISIBLE;
1653 if(dwStyle & WS_SYSMENU) {
1654 if(!(dwStyle & (WS_MINIMIZEBOX|WS_MAXIMIZEBOX))) {
1655 tbi->rgstate[2] = STATE_SYSTEM_INVISIBLE;
1656 tbi->rgstate[3] = STATE_SYSTEM_INVISIBLE;
1657 }
1658 else {
1659 if(!(dwStyle & WS_MINIMIZEBOX))
1660 tbi->rgstate[2] = STATE_SYSTEM_UNAVAILABLE;
1661 if(!(dwStyle & WS_MAXIMIZEBOX))
1662 tbi->rgstate[3] = STATE_SYSTEM_UNAVAILABLE;
1663 }
1664 if(!(dwExStyle & WS_EX_CONTEXTHELP))
1665 tbi->rgstate[4] = STATE_SYSTEM_INVISIBLE;
1666 if(GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE)
1667 tbi->rgstate[5] = STATE_SYSTEM_UNAVAILABLE;
1668 }
1669 else {
1670 tbi->rgstate[2] = STATE_SYSTEM_INVISIBLE;
1671 tbi->rgstate[3] = STATE_SYSTEM_INVISIBLE;
1672 tbi->rgstate[4] = STATE_SYSTEM_INVISIBLE;
1673 tbi->rgstate[5] = STATE_SYSTEM_INVISIBLE;
1674 }
1675 }
1676 else
1677 tbi->rgstate[0] |= STATE_SYSTEM_INVISIBLE;
1678 return TRUE;
1679 }
useful hacks and other patches not (yet) suitable for mainline