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