?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added, update information about AppDefault.
[wine/wine64.git] / windows / nonclient.c
blob1da7c36717979f56453e3f80591bdc7b06fe4e42
1 /*
2 * Non-client area window functions
3 *
4 * Copyright 1994 Alexandre Julliard
5 *
6 */
7
8 #include "windef.h"
9 #include "wingdi.h"
10 #include "wine/winuser16.h"
11 #include "version.h"
12 #include "win.h"
13 #include "user.h"
14 #include "dce.h"
15 #include "controls.h"
16 #include "cursoricon.h"
17 #include "winpos.h"
18 #include "hook.h"
19 #include "nonclient.h"
20 #include "debugtools.h"
21 #include "shellapi.h"
22 #include "bitmap.h"
23
24 DEFAULT_DEBUG_CHANNEL(nonclient);
25 DECLARE_DEBUG_CHANNEL(shell);
26
27 BOOL NC_DrawGrayButton(HDC hdc, int x, int y);
28
29 static HBITMAP hbitmapClose;
30
31 static const BYTE lpGrayMask[] = { 0xAA, 0xA0,
32 0x55, 0x50,
33 0xAA, 0xA0,
34 0x55, 0x50,
35 0xAA, 0xA0,
36 0x55, 0x50,
37 0xAA, 0xA0,
38 0x55, 0x50,
39 0xAA, 0xA0,
40 0x55, 0x50};
41
42 #define SC_ABOUTWINE (SC_SCREENSAVE+1)
43 #define SC_PUTMARK (SC_SCREENSAVE+2)
44
45 /* Some useful macros */
46 #define HAS_DLGFRAME(style,exStyle) \
47 (((exStyle) & WS_EX_DLGMODALFRAME) || \
48 (((style) & WS_DLGFRAME) && !((style) & WS_THICKFRAME)))
49
50 #define HAS_THICKFRAME(style,exStyle) \
51 (((style) & WS_THICKFRAME) && \
52 !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
53
54 #define HAS_THINFRAME(style) \
55 (((style) & WS_BORDER) || !((style) & (WS_CHILD | WS_POPUP)))
56
57 #define HAS_BIGFRAME(style,exStyle) \
58 (((style) & (WS_THICKFRAME | WS_DLGFRAME)) || \
59 ((exStyle) & WS_EX_DLGMODALFRAME))
60
61 #define HAS_STATICOUTERFRAME(style,exStyle) \
62 (((exStyle) & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) == \
63 WS_EX_STATICEDGE)
64
65 #define HAS_ANYFRAME(style,exStyle) \
66 (((style) & (WS_THICKFRAME | WS_DLGFRAME | WS_BORDER)) || \
67 ((exStyle) & WS_EX_DLGMODALFRAME) || \
68 !((style) & (WS_CHILD | WS_POPUP)))
69
70 #define HAS_MENU(w) (!((w)->dwStyle & WS_CHILD) && ((w)->wIDmenu != 0))
71
72
73 /***********************************************************************
74 * NC_AdjustRect
75 *
76 * Compute the size of the window rectangle from the size of the
77 * client rectangle.
78 */
79 static void NC_AdjustRect( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
80 {
81 if (TWEAK_WineLook > WIN31_LOOK)
82 ERR("Called in Win95 mode. Aiee! Please report this.\n" );
83
84 if(style & WS_ICONIC) return;
85
86 if (HAS_THICKFRAME( style, exStyle ))
87 InflateRect( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
88 else if (HAS_DLGFRAME( style, exStyle ))
89 InflateRect( rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
90 else if (HAS_THINFRAME( style ))
91 InflateRect( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
92
93 if ((style & WS_CAPTION) == WS_CAPTION)
94 rect->top -= GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
95
96 if (menu) rect->top -= GetSystemMetrics(SM_CYMENU) + GetSystemMetrics(SM_CYBORDER);
97
98 if (style & WS_VSCROLL) {
99 rect->right += GetSystemMetrics(SM_CXVSCROLL) - 1;
100 if(!HAS_ANYFRAME( style, exStyle ))
101 rect->right++;
102 }
103
104 if (style & WS_HSCROLL) {
105 rect->bottom += GetSystemMetrics(SM_CYHSCROLL) - 1;
106 if(!HAS_ANYFRAME( style, exStyle ))
107 rect->bottom++;
108 }
109 }
110
111
112 /******************************************************************************
113 * NC_AdjustRectOuter95
114 *
115 * Computes the size of the "outside" parts of the window based on the
116 * parameters of the client area.
117 *
118 + PARAMS
119 * LPRECT16 rect
120 * DWORD style
121 * BOOL menu
122 * DWORD exStyle
123 *
124 * NOTES
125 * "Outer" parts of a window means the whole window frame, caption and
126 * menu bar. It does not include "inner" parts of the frame like client
127 * edge, static edge or scroll bars.
128 *
129 * Revision history
130 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
131 * Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
132 *
133 * 20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
134 * Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
135 * NC_AdjustRectInner95 and added handling of Win95 styles.
136 *
137 * 28-Jul-1999 Ove Kåven (ovek@arcticnet.no)
138 * Streamlined window style checks.
139 *
140 *****************************************************************************/
141
142 static void
143 NC_AdjustRectOuter95 (LPRECT rect, DWORD style, BOOL menu, DWORD exStyle)
144 {
145 int adjust;
146 if(style & WS_ICONIC) return;
147
148 if ((exStyle & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) ==
149 WS_EX_STATICEDGE)
150 {
151 adjust = 1; /* for the outer frame always present */
152 }
153 else
154 {
155 adjust = 0;
156 if ((exStyle & WS_EX_DLGMODALFRAME) ||
157 (style & (WS_THICKFRAME|WS_DLGFRAME))) adjust = 2; /* outer */
158 }
159 if (style & WS_THICKFRAME)
160 adjust += ( GetSystemMetrics (SM_CXFRAME)
161 - GetSystemMetrics (SM_CXDLGFRAME)); /* The resize border */
162 if ((style & (WS_BORDER|WS_DLGFRAME)) ||
163 (exStyle & WS_EX_DLGMODALFRAME))
164 adjust++; /* The other border */
165
166 InflateRect (rect, adjust, adjust);
167
168 if ((style & WS_CAPTION) == WS_CAPTION)
169 {
170 if (exStyle & WS_EX_TOOLWINDOW)
171 rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
172 else
173 rect->top -= GetSystemMetrics(SM_CYCAPTION);
174 }
175 if (menu) rect->top -= GetSystemMetrics(SM_CYMENU);
176 }
177
178
179 /******************************************************************************
180 * NC_AdjustRectInner95
181 *
182 * Computes the size of the "inside" part of the window based on the
183 * parameters of the client area.
184 *
185 + PARAMS
186 * LPRECT16 rect
187 * DWORD style
188 * DWORD exStyle
189 *
190 * NOTES
191 * "Inner" part of a window means the window frame inside of the flat
192 * window frame. It includes the client edge, the static edge and the
193 * scroll bars.
194 *
195 * Revision history
196 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
197 * Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
198 *
199 * 20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
200 * Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
201 * NC_AdjustRectInner95 and added handling of Win95 styles.
202 *
203 *****************************************************************************/
204
205 static void
206 NC_AdjustRectInner95 (LPRECT rect, DWORD style, DWORD exStyle)
207 {
208 if(style & WS_ICONIC) return;
209
210 if (exStyle & WS_EX_CLIENTEDGE)
211 InflateRect(rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
212
213 if (style & WS_VSCROLL) rect->right += GetSystemMetrics(SM_CXVSCROLL);
214 if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
215 }
216
217
218
219 static HICON NC_IconForWindow( HWND hwnd )
220 {
221 HICON hIcon = (HICON) GetClassLongA( hwnd, GCL_HICONSM );
222 if (!hIcon) hIcon = (HICON) GetClassLongA( hwnd, GCL_HICON );
223
224 /* If there is no hIcon specified and this is a modal dialog,
225 * get the default one.
226 */
227 if (!hIcon && (GetWindowLongA( hwnd, GWL_STYLE ) & DS_MODALFRAME))
228 hIcon = LoadImageA(0, IDI_WINLOGOA, IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
229 return hIcon;
230 }
231
232 /***********************************************************************
233 * DrawCaption (USER32.@) Draws a caption bar
234 *
235 * PARAMS
236 * hwnd [I]
237 * hdc [I]
238 * lpRect [I]
239 * uFlags [I]
240 *
241 * RETURNS
242 * Success:
243 * Failure:
244 */
245
246 BOOL WINAPI
247 DrawCaption (HWND hwnd, HDC hdc, const RECT *lpRect, UINT uFlags)
248 {
249 return DrawCaptionTempA (hwnd, hdc, lpRect, 0, 0, NULL, uFlags & 0x1F);
250 }
251
252
253 /***********************************************************************
254 * DrawCaptionTempA (USER32.@)
255 */
256 BOOL WINAPI DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
257 HICON hIcon, LPCSTR str, UINT uFlags)
258 {
259 LPWSTR strW;
260 INT len;
261 BOOL ret = FALSE;
262
263 if (!(uFlags & DC_TEXT) || !str)
264 return DrawCaptionTempW( hwnd, hdc, rect, hFont, hIcon, NULL, uFlags );
265
266 len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
267 if ((strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
268 {
269 MultiByteToWideChar( CP_ACP, 0, str, -1, strW, len );
270 ret = DrawCaptionTempW (hwnd, hdc, rect, hFont, hIcon, strW, uFlags);
271 HeapFree( GetProcessHeap (), 0, strW );
272 }
273 return ret;
274 }
275
276
277 /***********************************************************************
278 * DrawCaptionTempW (USER32.@)
279 */
280 BOOL WINAPI DrawCaptionTempW (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
281 HICON hIcon, LPCWSTR str, UINT uFlags)
282 {
283 RECT rc = *rect;
284
285 TRACE("(%08x,%08x,%p,%08x,%08x,%s,%08x)\n",
286 hwnd, hdc, rect, hFont, hIcon, debugstr_w(str), uFlags);
287
288 /* drawing background */
289 if (uFlags & DC_INBUTTON) {
290 FillRect (hdc, &rc, GetSysColorBrush (COLOR_3DFACE));
291
292 if (uFlags & DC_ACTIVE) {
293 HBRUSH hbr = SelectObject (hdc, CACHE_GetPattern55AABrush ());
294 PatBlt (hdc, rc.left, rc.top,
295 rc.right-rc.left, rc.bottom-rc.top, 0xFA0089);
296 SelectObject (hdc, hbr);
297 }
298 }
299 else {
300 FillRect (hdc, &rc, GetSysColorBrush ((uFlags & DC_ACTIVE) ?
301 COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
302 }
303
304
305 /* drawing icon */
306 if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP)) {
307 POINT pt;
308
309 pt.x = rc.left + 2;
310 pt.y = (rc.bottom + rc.top - GetSystemMetrics(SM_CYSMICON)) / 2;
311
312 if (!hIcon) hIcon = NC_IconForWindow(hwnd);
313 DrawIconEx (hdc, pt.x, pt.y, hIcon, GetSystemMetrics(SM_CXSMICON),
314 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
315 rc.left += (rc.bottom - rc.top);
316 }
317
318 /* drawing text */
319 if (uFlags & DC_TEXT) {
320 HFONT hOldFont;
321
322 if (uFlags & DC_INBUTTON)
323 SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
324 else if (uFlags & DC_ACTIVE)
325 SetTextColor (hdc, GetSysColor (COLOR_CAPTIONTEXT));
326 else
327 SetTextColor (hdc, GetSysColor (COLOR_INACTIVECAPTIONTEXT));
328
329 SetBkMode (hdc, TRANSPARENT);
330
331 if (hFont)
332 hOldFont = SelectObject (hdc, hFont);
333 else {
334 NONCLIENTMETRICSA nclm;
335 HFONT hNewFont;
336 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
337 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
338 hNewFont = CreateFontIndirectA ((uFlags & DC_SMALLCAP) ?
339 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
340 hOldFont = SelectObject (hdc, hNewFont);
341 }
342
343 if (str)
344 DrawTextW (hdc, str, -1, &rc,
345 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
346 else {
347 WCHAR szText[128];
348 INT nLen;
349 nLen = GetWindowTextW (hwnd, szText, 128);
350 DrawTextW (hdc, szText, nLen, &rc,
351 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
352 }
353
354 if (hFont)
355 SelectObject (hdc, hOldFont);
356 else
357 DeleteObject (SelectObject (hdc, hOldFont));
358 }
359
360 /* drawing focus ??? */
361 if (uFlags & 0x2000)
362 FIXME("undocumented flag (0x2000)!\n");
363
364 return 0;
365 }
366
367
368 /***********************************************************************
369 * AdjustWindowRect (USER.102)
370 */
371 BOOL16 WINAPI AdjustWindowRect16( LPRECT16 rect, DWORD style, BOOL16 menu )
372 {
373 return AdjustWindowRectEx16( rect, style, menu, 0 );
374 }
375
376
377 /***********************************************************************
378 * AdjustWindowRect (USER32.@)
379 */
380 BOOL WINAPI AdjustWindowRect( LPRECT rect, DWORD style, BOOL menu )
381 {
382 return AdjustWindowRectEx( rect, style, menu, 0 );
383 }
384
385
386 /***********************************************************************
387 * AdjustWindowRectEx (USER.454)
388 */
389 BOOL16 WINAPI AdjustWindowRectEx16( LPRECT16 rect, DWORD style,
390 BOOL16 menu, DWORD exStyle )
391 {
392 RECT rect32;
393 BOOL ret;
394
395 CONV_RECT16TO32( rect, &rect32 );
396 ret = AdjustWindowRectEx( &rect32, style, menu, exStyle );
397 CONV_RECT32TO16( &rect32, rect );
398 return ret;
399 }
400
401
402 /***********************************************************************
403 * AdjustWindowRectEx (USER32.@)
404 */
405 BOOL WINAPI AdjustWindowRectEx( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
406 {
407 /* Correct the window style */
408
409 if (!(style & (WS_POPUP | WS_CHILD))) style |= WS_CAPTION; /* Overlapped window */
410 style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD);
411 exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
412 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
413 if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
414
415 TRACE("(%d,%d)-(%d,%d) %08lx %d %08lx\n",
416 rect->left, rect->top, rect->right, rect->bottom,
417 style, menu, exStyle );
418
419 if (TWEAK_WineLook == WIN31_LOOK)
420 NC_AdjustRect( rect, style, menu, exStyle );
421 else
422 {
423 NC_AdjustRectOuter95( rect, style, menu, exStyle );
424 NC_AdjustRectInner95( rect, style, exStyle );
425 }
426 return TRUE;
427 }
428
429
430 /***********************************************************************
431 * NC_HandleNCCalcSize
432 *
433 * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
434 */
435 LONG NC_HandleNCCalcSize( HWND hwnd, RECT *winRect )
436 {
437 RECT tmpRect = { 0, 0, 0, 0 };
438 LONG result = 0;
439 LONG cls_style = GetClassLongA(hwnd, GCL_STYLE);
440 LONG style = GetWindowLongA( hwnd, GWL_STYLE );
441 LONG exStyle = GetWindowLongA( hwnd, GWL_EXSTYLE );
442
443 if (cls_style & CS_VREDRAW) result |= WVR_VREDRAW;
444 if (cls_style & CS_HREDRAW) result |= WVR_HREDRAW;
445
446 if (!IsIconic(hwnd))
447 {
448 if (TWEAK_WineLook == WIN31_LOOK)
449 NC_AdjustRect( &tmpRect, style, FALSE, exStyle );
450 else
451 NC_AdjustRectOuter95( &tmpRect, style, FALSE, exStyle );
452
453 winRect->left -= tmpRect.left;
454 winRect->top -= tmpRect.top;
455 winRect->right -= tmpRect.right;
456 winRect->bottom -= tmpRect.bottom;
457
458 if (!(style & WS_CHILD) && GetMenu(hwnd))
459 {
460 TRACE("Calling GetMenuBarHeight with HWND 0x%x, width %d, "
461 "at (%d, %d).\n", hwnd,
462 winRect->right - winRect->left,
463 -tmpRect.left, -tmpRect.top );
464
465 winRect->top +=
466 MENU_GetMenuBarHeight( hwnd,
467 winRect->right - winRect->left,
468 -tmpRect.left, -tmpRect.top ) + 1;
469 }
470
471 if (TWEAK_WineLook > WIN31_LOOK) {
472 SetRect(&tmpRect, 0, 0, 0, 0);
473 NC_AdjustRectInner95 (&tmpRect, style, exStyle);
474 winRect->left -= tmpRect.left;
475 winRect->top -= tmpRect.top;
476 winRect->right -= tmpRect.right;
477 winRect->bottom -= tmpRect.bottom;
478 }
479
480 if (winRect->top > winRect->bottom)
481 winRect->bottom = winRect->top;
482
483 if (winRect->left > winRect->right)
484 winRect->right = winRect->left;
485 }
486 return result;
487 }
488
489
490 /***********************************************************************
491 * NC_GetInsideRect
492 *
493 * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
494 * but without the borders (if any).
495 * The rectangle is in window coordinates (for drawing with GetWindowDC()).
496 */
497 void NC_GetInsideRect( HWND hwnd, RECT *rect )
498 {
499 WND * wndPtr = WIN_FindWndPtr( hwnd );
500
501 rect->top = rect->left = 0;
502 rect->right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
503 rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
504
505 if (wndPtr->dwStyle & WS_ICONIC) goto END;
506
507 /* Remove frame from rectangle */
508 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
509 {
510 InflateRect( rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
511 }
512 else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
513 {
514 InflateRect( rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
515 /* FIXME: this isn't in NC_AdjustRect? why not? */
516 if ((TWEAK_WineLook == WIN31_LOOK) && (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME))
517 InflateRect( rect, -1, 0 );
518 }
519 else if (HAS_THINFRAME( wndPtr->dwStyle ))
520 {
521 InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
522 }
523
524 /* We have additional border information if the window
525 * is a child (but not an MDI child) */
526 if (TWEAK_WineLook != WIN31_LOOK)
527 {
528 if ( (wndPtr->dwStyle & WS_CHILD) &&
529 ( (wndPtr->dwExStyle & WS_EX_MDICHILD) == 0 ) )
530 {
531 if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
532 InflateRect (rect, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYEDGE));
533 if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
534 InflateRect (rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
535 }
536 }
537
538 END:
539 WIN_ReleaseWndPtr(wndPtr);
540 return;
541 }
542
543
544 /***********************************************************************
545 * NC_DoNCHitTest
546 *
547 * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
548 */
549
550 static LONG NC_DoNCHitTest (WND *wndPtr, POINT pt )
551 {
552 RECT rect;
553
554 TRACE("hwnd=%04x pt=%ld,%ld\n", wndPtr->hwndSelf, pt.x, pt.y );
555
556 GetWindowRect(wndPtr->hwndSelf, &rect );
557 if (!PtInRect( &rect, pt )) return HTNOWHERE;
558
559 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
560
561 /* Check borders */
562 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
563 {
564 InflateRect( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
565 if (!PtInRect( &rect, pt ))
566 {
567 /* Check top sizing border */
568 if (pt.y < rect.top)
569 {
570 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
571 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
572 return HTTOP;
573 }
574 /* Check bottom sizing border */
575 if (pt.y >= rect.bottom)
576 {
577 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
578 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
579 return HTBOTTOM;
580 }
581 /* Check left sizing border */
582 if (pt.x < rect.left)
583 {
584 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
585 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
586 return HTLEFT;
587 }
588 /* Check right sizing border */
589 if (pt.x >= rect.right)
590 {
591 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
592 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
593 return HTRIGHT;
594 }
595 }
596 }
597 else /* No thick frame */
598 {
599 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
600 InflateRect(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
601 else if (HAS_THINFRAME( wndPtr->dwStyle ))
602 InflateRect(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
603 if (!PtInRect( &rect, pt )) return HTBORDER;
604 }
605
606 /* Check caption */
607
608 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
609 {
610 rect.top += GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
611 if (!PtInRect( &rect, pt ))
612 {
613 /* Check system menu */
614 if ((wndPtr->dwStyle & WS_SYSMENU) && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
615 rect.left += GetSystemMetrics(SM_CXSIZE);
616 if (pt.x <= rect.left) return HTSYSMENU;
617
618 /* Check maximize box */
619 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
620 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
621
622 if (pt.x >= rect.right) return HTMAXBUTTON;
623 /* Check minimize box */
624 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
625 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
626 if (pt.x >= rect.right) return HTMINBUTTON;
627 return HTCAPTION;
628 }
629 }
630
631 /* Check client area */
632
633 ScreenToClient( wndPtr->hwndSelf, &pt );
634 GetClientRect( wndPtr->hwndSelf, &rect );
635 if (PtInRect( &rect, pt )) return HTCLIENT;
636
637 /* Check vertical scroll bar */
638
639 if (wndPtr->dwStyle & WS_VSCROLL)
640 {
641 rect.right += GetSystemMetrics(SM_CXVSCROLL);
642 if (PtInRect( &rect, pt )) return HTVSCROLL;
643 }
644
645 /* Check horizontal scroll bar */
646
647 if (wndPtr->dwStyle & WS_HSCROLL)
648 {
649 rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
650 if (PtInRect( &rect, pt ))
651 {
652 /* Check size box */
653 if ((wndPtr->dwStyle & WS_VSCROLL) &&
654 (pt.x >= rect.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 ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.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_DoNCHitTest95
676 *
677 * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
678 *
679 * FIXME: Just a modified copy of the Win 3.1 version.
680 */
681
682 static LONG NC_DoNCHitTest95 (WND *wndPtr, POINT pt )
683 {
684 RECT rect;
685
686 TRACE("hwnd=%04x pt=%ld,%ld\n", wndPtr->hwndSelf, pt.x, pt.y );
687
688 GetWindowRect(wndPtr->hwndSelf, &rect );
689 if (!PtInRect( &rect, pt )) return HTNOWHERE;
690
691 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
692
693 /* Check borders */
694 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
695 {
696 InflateRect( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
697 if (!PtInRect( &rect, pt ))
698 {
699 /* Check top sizing border */
700 if (pt.y < rect.top)
701 {
702 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
703 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
704 return HTTOP;
705 }
706 /* Check bottom sizing border */
707 if (pt.y >= rect.bottom)
708 {
709 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
710 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
711 return HTBOTTOM;
712 }
713 /* Check left sizing border */
714 if (pt.x < rect.left)
715 {
716 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
717 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
718 return HTLEFT;
719 }
720 /* Check right sizing border */
721 if (pt.x >= rect.right)
722 {
723 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
724 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
725 return HTRIGHT;
726 }
727 }
728 }
729 else /* No thick frame */
730 {
731 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
732 InflateRect(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
733 else if (HAS_THINFRAME( wndPtr->dwStyle ))
734 InflateRect(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
735 if (!PtInRect( &rect, pt )) return HTBORDER;
736 }
737
738 /* Check caption */
739
740 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
741 {
742 if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
743 rect.top += GetSystemMetrics(SM_CYSMCAPTION) - 1;
744 else
745 rect.top += GetSystemMetrics(SM_CYCAPTION) - 1;
746 if (!PtInRect( &rect, pt ))
747 {
748 /* Check system menu */
749 if ((wndPtr->dwStyle & WS_SYSMENU) && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
750 {
751 if (NC_IconForWindow(wndPtr->hwndSelf))
752 rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
753 }
754 if (pt.x < rect.left) return HTSYSMENU;
755
756 /* Check close button */
757 if (wndPtr->dwStyle & WS_SYSMENU)
758 rect.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
759 if (pt.x > rect.right) return HTCLOSE;
760
761 /* Check maximize box */
762 /* In win95 there is automatically a Maximize button when there is a minimize one*/
763 if ((wndPtr->dwStyle & WS_MAXIMIZEBOX)|| (wndPtr->dwStyle & WS_MINIMIZEBOX))
764 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
765 if (pt.x > rect.right) return HTMAXBUTTON;
766
767 /* Check minimize box */
768 /* In win95 there is automatically a Maximize button when there is a Maximize one*/
769 if ((wndPtr->dwStyle & WS_MINIMIZEBOX)||(wndPtr->dwStyle & WS_MAXIMIZEBOX))
770 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
771
772 if (pt.x > rect.right) return HTMINBUTTON;
773 return HTCAPTION;
774 }
775 }
776
777 /* Check client area */
778
779 ScreenToClient( wndPtr->hwndSelf, &pt );
780 GetClientRect( wndPtr->hwndSelf, &rect );
781 if (PtInRect( &rect, pt )) return HTCLIENT;
782
783 /* Check vertical scroll bar */
784
785 if (wndPtr->dwStyle & WS_VSCROLL)
786 {
787 rect.right += GetSystemMetrics(SM_CXVSCROLL);
788 if (PtInRect( &rect, pt )) return HTVSCROLL;
789 }
790
791 /* Check horizontal scroll bar */
792
793 if (wndPtr->dwStyle & WS_HSCROLL)
794 {
795 rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
796 if (PtInRect( &rect, pt ))
797 {
798 /* Check size box */
799 if ((wndPtr->dwStyle & WS_VSCROLL) &&
800 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
801 return HTSIZE;
802 return HTHSCROLL;
803 }
804 }
805
806 /* Check menu bar */
807
808 if (HAS_MENU(wndPtr))
809 {
810 if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
811 return HTMENU;
812 }
813
814 /* Has to return HTNOWHERE if nothing was found
815 Could happen when a window has a customized non client area */
816 return HTNOWHERE;
817 }
818
819
820 /***********************************************************************
821 * NC_HandleNCHitTest
822 *
823 * Handle a WM_NCHITTEST message. Called from DefWindowProc().
824 */
825 LONG NC_HandleNCHitTest (HWND hwnd , POINT pt)
826 {
827 LONG retvalue;
828 WND *wndPtr = WIN_FindWndPtr (hwnd);
829
830 if (!wndPtr)
831 return HTERROR;
832
833 if (TWEAK_WineLook == WIN31_LOOK)
834 retvalue = NC_DoNCHitTest (wndPtr, pt);
835 else
836 retvalue = NC_DoNCHitTest95 (wndPtr, pt);
837 WIN_ReleaseWndPtr(wndPtr);
838 return retvalue;
839 }
840
841
842 /***********************************************************************
843 * NC_DrawSysButton
844 */
845 void NC_DrawSysButton( HWND hwnd, HDC hdc, BOOL down )
846 {
847 RECT rect;
848 HDC hdcMem;
849 HBITMAP hbitmap;
850
851 NC_GetInsideRect( hwnd, &rect );
852 hdcMem = CreateCompatibleDC( hdc );
853 hbitmap = SelectObject( hdcMem, hbitmapClose );
854 BitBlt(hdc, rect.left, rect.top, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
855 hdcMem, (GetWindowLongA(hwnd,GWL_STYLE) & WS_CHILD) ? GetSystemMetrics(SM_CXSIZE) : 0, 0,
856 down ? NOTSRCCOPY : SRCCOPY );
857 SelectObject( hdcMem, hbitmap );
858 DeleteDC( hdcMem );
859 }
860
861
862 /***********************************************************************
863 * NC_DrawMaxButton
864 */
865 static void NC_DrawMaxButton( HWND hwnd, HDC16 hdc, BOOL down )
866 {
867 RECT rect;
868 UINT flags = IsZoomed(hwnd) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMAX;
869
870 NC_GetInsideRect( hwnd, &rect );
871 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE) + 1;
872 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
873 rect.top += 1;
874 rect.right -= 1;
875 if (down) flags |= DFCS_PUSHED;
876 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
877 }
878
879
880 /***********************************************************************
881 * NC_DrawMinButton
882 */
883 static void NC_DrawMinButton( HWND hwnd, HDC16 hdc, BOOL down )
884 {
885 RECT rect;
886 UINT flags = DFCS_CAPTIONMIN;
887 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
888
889 NC_GetInsideRect( hwnd, &rect );
890 if (style & (WS_MAXIMIZEBOX|WS_MINIMIZEBOX))
891 rect.right -= GetSystemMetrics(SM_CXSIZE) - 2;
892 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE) + 1;
893 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
894 rect.top += 1;
895 rect.right -= 1;
896 if (down) flags |= DFCS_PUSHED;
897 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
898 }
899
900
901 /******************************************************************************
902 *
903 * void NC_DrawSysButton95(
904 * HWND hwnd,
905 * HDC hdc,
906 * BOOL down )
907 *
908 * Draws the Win95 system icon.
909 *
910 * Revision history
911 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
912 * Original implementation from NC_DrawSysButton source.
913 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
914 * Fixed most bugs.
915 *
916 *****************************************************************************/
917
918 BOOL
919 NC_DrawSysButton95 (HWND hwnd, HDC hdc, BOOL down)
920 {
921 HICON hIcon = NC_IconForWindow( hwnd );
922
923 if (hIcon)
924 {
925 RECT rect;
926 NC_GetInsideRect( hwnd, &rect );
927 DrawIconEx (hdc, rect.left + 2, rect.top + 2, hIcon,
928 GetSystemMetrics(SM_CXSMICON),
929 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
930 }
931 return (hIcon != 0);
932 }
933
934
935 /******************************************************************************
936 *
937 * void NC_DrawCloseButton95(
938 * HWND hwnd,
939 * HDC hdc,
940 * BOOL down,
941 * BOOL bGrayed )
942 *
943 * Draws the Win95 close button.
944 *
945 * If bGrayed is true, then draw a disabled Close button
946 *
947 * Revision history
948 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
949 * Original implementation from NC_DrawSysButton95 source.
950 *
951 *****************************************************************************/
952
953 static void NC_DrawCloseButton95 (HWND hwnd, HDC hdc, BOOL down, BOOL bGrayed)
954 {
955 RECT rect;
956
957 NC_GetInsideRect( hwnd, &rect );
958
959 /* A tool window has a smaller Close button */
960 if (GetWindowLongA( hwnd, GWL_EXSTYLE ) & WS_EX_TOOLWINDOW)
961 {
962 INT iBmpHeight = 11; /* Windows does not use SM_CXSMSIZE and SM_CYSMSIZE */
963 INT iBmpWidth = 11; /* it uses 11x11 for the close button in tool window */
964 INT iCaptionHeight = GetSystemMetrics(SM_CYSMCAPTION);
965
966 rect.top = rect.top + (iCaptionHeight - 1 - iBmpHeight) / 2;
967 rect.left = rect.right - (iCaptionHeight + 1 + iBmpWidth) / 2;
968 rect.bottom = rect.top + iBmpHeight;
969 rect.right = rect.left + iBmpWidth;
970 }
971 else
972 {
973 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE) - 1;
974 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
975 rect.top += 2;
976 rect.right -= 2;
977 }
978 DrawFrameControl( hdc, &rect, DFC_CAPTION,
979 (DFCS_CAPTIONCLOSE |
980 (down ? DFCS_PUSHED : 0) |
981 (bGrayed ? DFCS_INACTIVE : 0)) );
982 }
983
984 /******************************************************************************
985 * NC_DrawMaxButton95
986 *
987 * Draws the maximize button for Win95 style windows.
988 * If bGrayed is true, then draw a disabled Maximize button
989 */
990 static void NC_DrawMaxButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
991 {
992 RECT rect;
993 UINT flags = IsZoomed(hwnd) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMAX;
994
995 NC_GetInsideRect( hwnd, &rect );
996 if (GetWindowLongA( hwnd, GWL_STYLE) & WS_SYSMENU)
997 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
998 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
999 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
1000 rect.top += 2;
1001 rect.right -= 2;
1002 if (down) flags |= DFCS_PUSHED;
1003 if (bGrayed) flags |= DFCS_INACTIVE;
1004 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
1005 }
1006
1007 /******************************************************************************
1008 * NC_DrawMinButton95
1009 *
1010 * Draws the minimize button for Win95 style windows.
1011 * If bGrayed is true, then draw a disabled Minimize button
1012 */
1013 static void NC_DrawMinButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1014 {
1015 RECT rect;
1016 UINT flags = DFCS_CAPTIONMIN;
1017 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
1018
1019 NC_GetInsideRect( hwnd, &rect );
1020 if (style & WS_SYSMENU)
1021 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1022 if (style & (WS_MAXIMIZEBOX|WS_MINIMIZEBOX))
1023 rect.right -= GetSystemMetrics(SM_CXSIZE) - 2;
1024 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
1025 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
1026 rect.top += 2;
1027 rect.right -= 2;
1028 if (down) flags |= DFCS_PUSHED;
1029 if (bGrayed) flags |= DFCS_INACTIVE;
1030 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
1031 }
1032
1033 /***********************************************************************
1034 * NC_DrawFrame
1035 *
1036 * Draw a window frame inside the given rectangle, and update the rectangle.
1037 * The correct pen for the frame must be selected in the DC.
1038 */
1039 static void NC_DrawFrame( HDC hdc, RECT *rect, BOOL dlgFrame,
1040 BOOL active )
1041 {
1042 INT width, height;
1043
1044 if (TWEAK_WineLook != WIN31_LOOK)
1045 ERR("Called in Win95 mode. Aiee! Please report this.\n" );
1046
1047 if (dlgFrame)
1048 {
1049 width = GetSystemMetrics(SM_CXDLGFRAME) - 1;
1050 height = GetSystemMetrics(SM_CYDLGFRAME) - 1;
1051 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1052 COLOR_INACTIVECAPTION) );
1053 }
1054 else
1055 {
1056 width = GetSystemMetrics(SM_CXFRAME) - 2;
1057 height = GetSystemMetrics(SM_CYFRAME) - 2;
1058 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1059 COLOR_INACTIVEBORDER) );
1060 }
1061
1062 /* Draw frame */
1063 PatBlt( hdc, rect->left, rect->top,
1064 rect->right - rect->left, height, PATCOPY );
1065 PatBlt( hdc, rect->left, rect->top,
1066 width, rect->bottom - rect->top, PATCOPY );
1067 PatBlt( hdc, rect->left, rect->bottom - 1,
1068 rect->right - rect->left, -height, PATCOPY );
1069 PatBlt( hdc, rect->right - 1, rect->top,
1070 -width, rect->bottom - rect->top, PATCOPY );
1071
1072 if (dlgFrame)
1073 {
1074 InflateRect( rect, -width, -height );
1075 }
1076 else
1077 {
1078 INT decYOff = GetSystemMetrics(SM_CXFRAME) + GetSystemMetrics(SM_CXSIZE) - 1;
1079 INT decXOff = GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYSIZE) - 1;
1080
1081 /* Draw inner rectangle */
1082
1083 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1084 Rectangle( hdc, rect->left + width, rect->top + height,
1085 rect->right - width , rect->bottom - height );
1086
1087 /* Draw the decorations */
1088
1089 MoveToEx( hdc, rect->left, rect->top + decYOff, NULL );
1090 LineTo( hdc, rect->left + width, rect->top + decYOff );
1091 MoveToEx( hdc, rect->right - 1, rect->top + decYOff, NULL );
1092 LineTo( hdc, rect->right - width - 1, rect->top + decYOff );
1093 MoveToEx( hdc, rect->left, rect->bottom - decYOff, NULL );
1094 LineTo( hdc, rect->left + width, rect->bottom - decYOff );
1095 MoveToEx( hdc, rect->right - 1, rect->bottom - decYOff, NULL );
1096 LineTo( hdc, rect->right - width - 1, rect->bottom - decYOff );
1097
1098 MoveToEx( hdc, rect->left + decXOff, rect->top, NULL );
1099 LineTo( hdc, rect->left + decXOff, rect->top + height);
1100 MoveToEx( hdc, rect->left + decXOff, rect->bottom - 1, NULL );
1101 LineTo( hdc, rect->left + decXOff, rect->bottom - height - 1 );
1102 MoveToEx( hdc, rect->right - decXOff, rect->top, NULL );
1103 LineTo( hdc, rect->right - decXOff, rect->top + height );
1104 MoveToEx( hdc, rect->right - decXOff, rect->bottom - 1, NULL );
1105 LineTo( hdc, rect->right - decXOff, rect->bottom - height - 1 );
1106
1107 InflateRect( rect, -width - 1, -height - 1 );
1108 }
1109 }
1110
1111
1112 /******************************************************************************
1113 *
1114 * void NC_DrawFrame95(
1115 * HDC hdc,
1116 * RECT *rect,
1117 * BOOL active,
1118 * DWORD style,
1119 * DWORD exStyle )
1120 *
1121 * Draw a window frame inside the given rectangle, and update the rectangle.
1122 *
1123 * Bugs
1124 * Many. First, just what IS a frame in Win95? Note that the 3D look
1125 * on the outer edge is handled by NC_DoNCPaint95. As is the inner
1126 * edge. The inner rectangle just inside the frame is handled by the
1127 * Caption code.
1128 *
1129 * In short, for most people, this function should be a nop (unless
1130 * you LIKE thick borders in Win95/NT4.0 -- I've been working with
1131 * them lately, but just to get this code right). Even so, it doesn't
1132 * appear to be so. It's being worked on...
1133 *
1134 * Revision history
1135 * 06-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1136 * Original implementation (based on NC_DrawFrame)
1137 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1138 * Some minor fixes.
1139 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1140 * Fixed a fix or something.
1141 *
1142 *****************************************************************************/
1143
1144 static void NC_DrawFrame95(
1145 HDC hdc,
1146 RECT *rect,
1147 BOOL active,
1148 DWORD style,
1149 DWORD exStyle)
1150 {
1151 INT width, height;
1152
1153 /* Firstly the "thick" frame */
1154 if (style & WS_THICKFRAME)
1155 {
1156 width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXDLGFRAME);
1157 height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYDLGFRAME);
1158
1159 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1160 COLOR_INACTIVEBORDER) );
1161 /* Draw frame */
1162 PatBlt( hdc, rect->left, rect->top,
1163 rect->right - rect->left, height, PATCOPY );
1164 PatBlt( hdc, rect->left, rect->top,
1165 width, rect->bottom - rect->top, PATCOPY );
1166 PatBlt( hdc, rect->left, rect->bottom - 1,
1167 rect->right - rect->left, -height, PATCOPY );
1168 PatBlt( hdc, rect->right - 1, rect->top,
1169 -width, rect->bottom - rect->top, PATCOPY );
1170
1171 InflateRect( rect, -width, -height );
1172 }
1173
1174 /* Now the other bit of the frame */
1175 if ((style & (WS_BORDER|WS_DLGFRAME)) ||
1176 (exStyle & WS_EX_DLGMODALFRAME))
1177 {
1178 width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
1179 height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
1180 /* This should give a value of 1 that should also work for a border */
1181
1182 SelectObject( hdc, GetSysColorBrush(
1183 (exStyle & (WS_EX_DLGMODALFRAME|WS_EX_CLIENTEDGE)) ?
1184 COLOR_3DFACE :
1185 (exStyle & WS_EX_STATICEDGE) ?
1186 COLOR_WINDOWFRAME :
1187 (style & (WS_DLGFRAME|WS_THICKFRAME)) ?
1188 COLOR_3DFACE :
1189 /* else */
1190 COLOR_WINDOWFRAME));
1191
1192 /* Draw frame */
1193 PatBlt( hdc, rect->left, rect->top,
1194 rect->right - rect->left, height, PATCOPY );
1195 PatBlt( hdc, rect->left, rect->top,
1196 width, rect->bottom - rect->top, PATCOPY );
1197 PatBlt( hdc, rect->left, rect->bottom - 1,
1198 rect->right - rect->left, -height, PATCOPY );
1199 PatBlt( hdc, rect->right - 1, rect->top,
1200 -width, rect->bottom - rect->top, PATCOPY );
1201
1202 InflateRect( rect, -width, -height );
1203 }
1204 }
1205
1206
1207 /***********************************************************************
1208 * NC_DrawCaption
1209 *
1210 * Draw the window caption.
1211 * The correct pen for the window frame must be selected in the DC.
1212 */
1213 static void NC_DrawCaption( HDC hdc, RECT *rect, HWND hwnd,
1214 DWORD style, BOOL active )
1215 {
1216 RECT r = *rect;
1217 char buffer[256];
1218
1219 if (!hbitmapClose)
1220 {
1221 if (!(hbitmapClose = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_OLD_CLOSE) ))) return;
1222 }
1223
1224 if (GetWindowLongA( hwnd, GWL_EXSTYLE) & WS_EX_DLGMODALFRAME)
1225 {
1226 HBRUSH hbrushOld = SelectObject(hdc, GetSysColorBrush(COLOR_WINDOW) );
1227 PatBlt( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
1228 PatBlt( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
1229 PatBlt( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
1230 r.left++;
1231 r.right--;
1232 SelectObject( hdc, hbrushOld );
1233 }
1234 MoveToEx( hdc, r.left, r.bottom, NULL );
1235 LineTo( hdc, r.right, r.bottom );
1236
1237 if (style & WS_SYSMENU)
1238 {
1239 NC_DrawSysButton( hwnd, hdc, FALSE );
1240 r.left += GetSystemMetrics(SM_CXSIZE) + 1;
1241 MoveToEx( hdc, r.left - 1, r.top, NULL );
1242 LineTo( hdc, r.left - 1, r.bottom );
1243 }
1244 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION) );
1245 if (style & WS_MAXIMIZEBOX)
1246 {
1247 NC_DrawMaxButton( hwnd, hdc, FALSE );
1248 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1249 }
1250 if (style & WS_MINIMIZEBOX)
1251 {
1252 NC_DrawMinButton( hwnd, hdc, FALSE );
1253 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1254 }
1255
1256 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) ))
1257 {
1258 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1259 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1260 SetBkMode( hdc, TRANSPARENT );
1261 DrawTextA( hdc, buffer, -1, &r,
1262 DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX );
1263 }
1264 }
1265
1266
1267 /******************************************************************************
1268 *
1269 * NC_DrawCaption95(
1270 * HDC hdc,
1271 * RECT *rect,
1272 * HWND hwnd,
1273 * DWORD style,
1274 * BOOL active )
1275 *
1276 * Draw the window caption for Win95 style windows.
1277 * The correct pen for the window frame must be selected in the DC.
1278 *
1279 * Bugs
1280 * Hey, a function that finally works! Well, almost.
1281 * It's being worked on.
1282 *
1283 * Revision history
1284 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1285 * Original implementation.
1286 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1287 * Some minor fixes.
1288 *
1289 *****************************************************************************/
1290
1291 static void NC_DrawCaption95(
1292 HDC hdc,
1293 RECT *rect,
1294 HWND hwnd,
1295 DWORD style,
1296 DWORD exStyle,
1297 BOOL active )
1298 {
1299 RECT r = *rect;
1300 char buffer[256];
1301 HPEN hPrevPen;
1302 HMENU hSysMenu;
1303
1304 hPrevPen = SelectObject( hdc, GetSysColorPen(
1305 ((exStyle & (WS_EX_STATICEDGE|WS_EX_CLIENTEDGE|
1306 WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE) ?
1307 COLOR_WINDOWFRAME : COLOR_3DFACE) );
1308 MoveToEx( hdc, r.left, r.bottom - 1, NULL );
1309 LineTo( hdc, r.right, r.bottom - 1 );
1310 SelectObject( hdc, hPrevPen );
1311 r.bottom--;
1312
1313 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1314 COLOR_INACTIVECAPTION) );
1315
1316 if ((style & WS_SYSMENU) && !(exStyle & WS_EX_TOOLWINDOW)) {
1317 if (NC_DrawSysButton95 (hwnd, hdc, FALSE))
1318 r.left += GetSystemMetrics(SM_CYCAPTION) - 1;
1319 }
1320
1321 if (style & WS_SYSMENU)
1322 {
1323 UINT state;
1324
1325 /* Go get the sysmenu */
1326 hSysMenu = GetSystemMenu(hwnd, FALSE);
1327 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1328
1329 /* Draw a grayed close button if disabled and a normal one if SC_CLOSE is not there */
1330 NC_DrawCloseButton95 (hwnd, hdc, FALSE,
1331 ((((state & MF_DISABLED) || (state & MF_GRAYED))) && (state != 0xFFFFFFFF)));
1332 r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
1333
1334 if ((style & WS_MAXIMIZEBOX) || (style & WS_MINIMIZEBOX))
1335 {
1336 /* In win95 the two buttons are always there */
1337 /* But if the menu item is not in the menu they're disabled*/
1338
1339 NC_DrawMaxButton95( hwnd, hdc, FALSE, (!(style & WS_MAXIMIZEBOX)));
1340 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1341
1342 NC_DrawMinButton95( hwnd, hdc, FALSE, (!(style & WS_MINIMIZEBOX)));
1343 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1344 }
1345 }
1346
1347 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) )) {
1348 NONCLIENTMETRICSA nclm;
1349 HFONT hFont, hOldFont;
1350 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
1351 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
1352 if (exStyle & WS_EX_TOOLWINDOW)
1353 hFont = CreateFontIndirectA (&nclm.lfSmCaptionFont);
1354 else
1355 hFont = CreateFontIndirectA (&nclm.lfCaptionFont);
1356 hOldFont = SelectObject (hdc, hFont);
1357 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1358 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1359 SetBkMode( hdc, TRANSPARENT );
1360 r.left += 2;
1361 DrawTextA( hdc, buffer, -1, &r,
1362 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
1363 DeleteObject (SelectObject (hdc, hOldFont));
1364 }
1365 }
1366
1367
1368
1369 /***********************************************************************
1370 * NC_DoNCPaint
1371 *
1372 * Paint the non-client area. clip is currently unused.
1373 */
1374 static void NC_DoNCPaint( HWND hwnd, HRGN clip, BOOL suppress_menupaint )
1375 {
1376 HDC hdc;
1377 RECT rect;
1378 BOOL active;
1379 WND *wndPtr;
1380 DWORD dwStyle, dwExStyle;
1381 WORD flags;
1382 RECT rectClient, rectWindow;
1383 int has_menu;
1384
1385 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return;
1386 has_menu = HAS_MENU(wndPtr);
1387 dwStyle = wndPtr->dwStyle;
1388 dwExStyle = wndPtr->dwExStyle;
1389 flags = wndPtr->flags;
1390 rectClient = wndPtr->rectClient;
1391 rectWindow = wndPtr->rectWindow;
1392 WIN_ReleasePtr( wndPtr );
1393
1394 if ( dwStyle & WS_MINIMIZE ||
1395 !WIN_IsWindowDrawable( hwnd, 0 )) return; /* Nothing to do */
1396
1397 active = flags & WIN_NCACTIVATED;
1398
1399 TRACE("%04x %d\n", hwnd, active );
1400
1401 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1402 ((clip > 1) ? (DCX_INTERSECTRGN | DCX_KEEPCLIPRGN): 0) ))) return;
1403
1404 if (ExcludeVisRect16( hdc, rectClient.left-rectWindow.left,
1405 rectClient.top-rectWindow.top,
1406 rectClient.right-rectWindow.left,
1407 rectClient.bottom-rectWindow.top )
1408 == NULLREGION)
1409 {
1410 ReleaseDC( hwnd, hdc );
1411 return;
1412 }
1413
1414 rect.top = rect.left = 0;
1415 rect.right = rectWindow.right - rectWindow.left;
1416 rect.bottom = rectWindow.bottom - rectWindow.top;
1417
1418 SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
1419
1420 if (HAS_ANYFRAME( dwStyle, dwExStyle ))
1421 {
1422 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1423 Rectangle( hdc, 0, 0, rect.right, rect.bottom );
1424 InflateRect( &rect, -1, -1 );
1425 }
1426
1427 if (HAS_THICKFRAME( dwStyle, dwExStyle ))
1428 NC_DrawFrame(hdc, &rect, FALSE, active );
1429 else if (HAS_DLGFRAME( dwStyle, dwExStyle ))
1430 NC_DrawFrame( hdc, &rect, TRUE, active );
1431
1432 if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1433 {
1434 RECT r = rect;
1435 r.bottom = rect.top + GetSystemMetrics(SM_CYSIZE);
1436 rect.top += GetSystemMetrics(SM_CYSIZE) + GetSystemMetrics(SM_CYBORDER);
1437 NC_DrawCaption( hdc, &r, hwnd, dwStyle, active );
1438 }
1439
1440 if (has_menu)
1441 {
1442 RECT r = rect;
1443 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU); /* default height */
1444 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
1445 }
1446
1447 /* Draw the scroll-bars */
1448
1449 if (dwStyle & WS_VSCROLL)
1450 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1451 if (dwStyle & WS_HSCROLL)
1452 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1453
1454 /* Draw the "size-box" */
1455
1456 if ((dwStyle & WS_VSCROLL) && (dwStyle & WS_HSCROLL))
1457 {
1458 RECT r = rect;
1459 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1460 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1461 if(wndPtr->dwStyle & WS_BORDER) {
1462 r.left++;
1463 r.top++;
1464 }
1465 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1466 }
1467
1468 ReleaseDC( hwnd, hdc );
1469 }
1470
1471
1472 /******************************************************************************
1473 *
1474 * void NC_DoNCPaint95(
1475 * HWND hwnd,
1476 * HRGN clip,
1477 * BOOL suppress_menupaint )
1478 *
1479 * Paint the non-client area for Win95 windows. The clip region is
1480 * currently ignored.
1481 *
1482 * Bugs
1483 * grep -E -A10 -B5 \(95\)\|\(Bugs\)\|\(FIXME\) windows/nonclient.c \
1484 * misc/tweak.c controls/menu.c # :-)
1485 *
1486 * Revision history
1487 * 03-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1488 * Original implementation
1489 * 10-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1490 * Fixed some bugs.
1491 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1492 * Streamlined window style checks.
1493 *
1494 *****************************************************************************/
1495
1496 static void NC_DoNCPaint95(
1497 HWND hwnd,
1498 HRGN clip,
1499 BOOL suppress_menupaint )
1500 {
1501 HDC hdc;
1502 RECT rfuzz, rect, rectClip;
1503 BOOL active;
1504 WND *wndPtr;
1505 DWORD dwStyle, dwExStyle;
1506 WORD flags;
1507 RECT rectClient, rectWindow;
1508 int has_menu;
1509
1510 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return;
1511 has_menu = HAS_MENU(wndPtr);
1512 dwStyle = wndPtr->dwStyle;
1513 dwExStyle = wndPtr->dwExStyle;
1514 flags = wndPtr->flags;
1515 rectClient = wndPtr->rectClient;
1516 rectWindow = wndPtr->rectWindow;
1517 WIN_ReleasePtr( wndPtr );
1518
1519 if ( dwStyle & WS_MINIMIZE ||
1520 !WIN_IsWindowDrawable( hwnd, 0 )) return; /* Nothing to do */
1521
1522 active = flags & WIN_NCACTIVATED;
1523
1524 TRACE("%04x %d\n", hwnd, active );
1525
1526 /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
1527 the call to GetDCEx implying that it is allowed not to use it either.
1528 However, the suggested GetDCEx( , DCX_WINDOW | DCX_INTERSECTRGN)
1529 will cause clipRgn to be deleted after ReleaseDC().
1530 Now, how is the "system" supposed to tell what happened?
1531 */
1532
1533 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1534 ((clip > 1) ?(DCX_INTERSECTRGN | DCX_KEEPCLIPRGN) : 0) ))) return;
1535
1536
1537 if (ExcludeVisRect16( hdc, rectClient.left-rectWindow.left,
1538 rectClient.top-rectWindow.top,
1539 rectClient.right-rectWindow.left,
1540 rectClient.bottom-rectWindow.top )
1541 == NULLREGION)
1542 {
1543 ReleaseDC( hwnd, hdc );
1544 return;
1545 }
1546
1547 rect.top = rect.left = 0;
1548 rect.right = rectWindow.right - rectWindow.left;
1549 rect.bottom = rectWindow.bottom - rectWindow.top;
1550
1551 if( clip > 1 )
1552 GetRgnBox( clip, &rectClip );
1553 else
1554 {
1555 clip = 0;
1556 rectClip = rect;
1557 }
1558
1559 SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
1560
1561 if (HAS_STATICOUTERFRAME(dwStyle, dwExStyle)) {
1562 DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1563 }
1564 else if (HAS_BIGFRAME( dwStyle, dwExStyle)) {
1565 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1566 }
1567
1568 NC_DrawFrame95(hdc, &rect, active, dwStyle, dwExStyle );
1569
1570 if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1571 {
1572 RECT r = rect;
1573 if (dwExStyle & WS_EX_TOOLWINDOW) {
1574 r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
1575 rect.top += GetSystemMetrics(SM_CYSMCAPTION);
1576 }
1577 else {
1578 r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
1579 rect.top += GetSystemMetrics(SM_CYCAPTION);
1580 }
1581 if( !clip || IntersectRect( &rfuzz, &r, &rectClip ) )
1582 NC_DrawCaption95 (hdc, &r, hwnd, dwStyle,
1583 dwExStyle, active);
1584 }
1585
1586 if (has_menu)
1587 {
1588 RECT r = rect;
1589 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
1590
1591 TRACE("Calling DrawMenuBar with rect (%d, %d)-(%d, %d)\n",
1592 r.left, r.top, r.right, r.bottom);
1593
1594 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
1595 }
1596
1597 TRACE("After MenuBar, rect is (%d, %d)-(%d, %d).\n",
1598 rect.left, rect.top, rect.right, rect.bottom );
1599
1600 if (dwExStyle & WS_EX_CLIENTEDGE)
1601 DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1602
1603 /* Draw the scroll-bars */
1604
1605 if (dwStyle & WS_VSCROLL)
1606 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1607 if (dwStyle & WS_HSCROLL)
1608 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1609
1610 /* Draw the "size-box" */
1611 if ((dwStyle & WS_VSCROLL) && (dwStyle & WS_HSCROLL))
1612 {
1613 RECT r = rect;
1614 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1615 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1616 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1617 }
1618
1619 ReleaseDC( hwnd, hdc );
1620 }
1621
1622
1623
1624
1625 /***********************************************************************
1626 * NC_HandleNCPaint
1627 *
1628 * Handle a WM_NCPAINT message. Called from DefWindowProc().
1629 */
1630 LONG NC_HandleNCPaint( HWND hwnd , HRGN clip)
1631 {
1632 DWORD dwStyle = GetWindowLongW( hwnd, GWL_STYLE );
1633
1634 if( dwStyle & WS_VISIBLE )
1635 {
1636 if( dwStyle & WS_MINIMIZE )
1637 WINPOS_RedrawIconTitle( hwnd );
1638 else if (TWEAK_WineLook == WIN31_LOOK)
1639 NC_DoNCPaint( hwnd, clip, FALSE );
1640 else
1641 NC_DoNCPaint95( hwnd, clip, FALSE );
1642 }
1643 return 0;
1644 }
1645
1646
1647 /***********************************************************************
1648 * NC_HandleNCActivate
1649 *
1650 * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1651 */
1652 LONG NC_HandleNCActivate( HWND hwnd, WPARAM wParam )
1653 {
1654 WND* wndPtr = WIN_FindWndPtr( hwnd );
1655
1656 /* Lotus Notes draws menu descriptions in the caption of its main
1657 * window. When it wants to restore original "system" view, it just
1658 * sends WM_NCACTIVATE message to itself. Any optimizations here in
1659 * attempt to minimize redrawings lead to a not restored caption.
1660 */
1661 if (wndPtr)
1662 {
1663 if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1664 else wndPtr->flags &= ~WIN_NCACTIVATED;
1665 WIN_ReleaseWndPtr(wndPtr);
1666
1667 if (IsIconic(hwnd)) WINPOS_RedrawIconTitle( hwnd );
1668 else if (TWEAK_WineLook == WIN31_LOOK)
1669 NC_DoNCPaint( hwnd, (HRGN)1, FALSE );
1670 else
1671 NC_DoNCPaint95( hwnd, (HRGN)1, FALSE );
1672 }
1673 return TRUE;
1674 }
1675
1676
1677 /***********************************************************************
1678 * NC_HandleSetCursor
1679 *
1680 * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1681 */
1682 LONG NC_HandleSetCursor( HWND hwnd, WPARAM wParam, LPARAM lParam )
1683 {
1684 if (hwnd != WIN_GetFullHandle( (HWND)wParam ))
1685 return 0; /* Don't set the cursor for child windows */
1686
1687 switch(LOWORD(lParam))
1688 {
1689 case HTERROR:
1690 {
1691 WORD msg = HIWORD( lParam );
1692 if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1693 (msg == WM_RBUTTONDOWN))
1694 MessageBeep(0);
1695 }
1696 break;
1697
1698 case HTCLIENT:
1699 {
1700 HCURSOR hCursor = GetClassLongA(hwnd, GCL_HCURSOR);
1701 if(hCursor) {
1702 SetCursor(hCursor);
1703 return TRUE;
1704 }
1705 return FALSE;
1706 }
1707
1708 case HTLEFT:
1709 case HTRIGHT:
1710 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZEWEA ) );
1711
1712 case HTTOP:
1713 case HTBOTTOM:
1714 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZENSA ) );
1715
1716 case HTTOPLEFT:
1717 case HTBOTTOMRIGHT:
1718 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZENWSEA ) );
1719
1720 case HTTOPRIGHT:
1721 case HTBOTTOMLEFT:
1722 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZENESWA ) );
1723 }
1724
1725 /* Default cursor: arrow */
1726 return (LONG)SetCursor( LoadCursorA( 0, IDC_ARROWA ) );
1727 }
1728
1729 /***********************************************************************
1730 * NC_GetSysPopupPos
1731 */
1732 void NC_GetSysPopupPos( HWND hwnd, RECT* rect )
1733 {
1734 if (IsIconic(hwnd)) GetWindowRect( hwnd, rect );
1735 else
1736 {
1737 WND *wndPtr = WIN_FindWndPtr( hwnd );
1738 if (!wndPtr) return;
1739
1740 NC_GetInsideRect( hwnd, rect );
1741 OffsetRect( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
1742 if (wndPtr->dwStyle & WS_CHILD)
1743 ClientToScreen( GetParent(hwnd), (POINT *)rect );
1744 if (TWEAK_WineLook == WIN31_LOOK) {
1745 rect->right = rect->left + GetSystemMetrics(SM_CXSIZE);
1746 rect->bottom = rect->top + GetSystemMetrics(SM_CYSIZE);
1747 }
1748 else {
1749 rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
1750 rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
1751 }
1752 WIN_ReleaseWndPtr( wndPtr );
1753 }
1754 }
1755
1756 /***********************************************************************
1757 * NC_TrackMinMaxBox95
1758 *
1759 * Track a mouse button press on the minimize or maximize box.
1760 *
1761 * The big difference between 3.1 and 95 is the disabled button state.
1762 * In win95 the system button can be disabled, so it can ignore the mouse
1763 * event.
1764 *
1765 */
1766 static void NC_TrackMinMaxBox95( HWND hwnd, WORD wParam )
1767 {
1768 MSG msg;
1769 HDC hdc = GetWindowDC( hwnd );
1770 BOOL pressed = TRUE;
1771 UINT state;
1772 DWORD wndStyle = GetWindowLongA( hwnd, GWL_STYLE);
1773 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1774
1775 void (*paintButton)(HWND, HDC16, BOOL, BOOL);
1776
1777 if (wParam == HTMINBUTTON)
1778 {
1779 /* If the style is not present, do nothing */
1780 if (!(wndStyle & WS_MINIMIZEBOX))
1781 return;
1782
1783 /* Check if the sysmenu item for minimize is there */
1784 state = GetMenuState(hSysMenu, SC_MINIMIZE, MF_BYCOMMAND);
1785
1786 paintButton = &NC_DrawMinButton95;
1787 }
1788 else
1789 {
1790 /* If the style is not present, do nothing */
1791 if (!(wndStyle & WS_MAXIMIZEBOX))
1792 return;
1793
1794 /* Check if the sysmenu item for maximize is there */
1795 state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
1796
1797 paintButton = &NC_DrawMaxButton95;
1798 }
1799
1800 SetCapture( hwnd );
1801
1802 (*paintButton)( hwnd, hdc, TRUE, FALSE);
1803
1804 while(1)
1805 {
1806 BOOL oldstate = pressed;
1807
1808 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1809 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1810
1811 if(msg.message == WM_LBUTTONUP)
1812 break;
1813
1814 if(msg.message != WM_MOUSEMOVE)
1815 continue;
1816
1817 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1818 if (pressed != oldstate)
1819 (*paintButton)( hwnd, hdc, pressed, FALSE);
1820 }
1821
1822 if(pressed)
1823 (*paintButton)(hwnd, hdc, FALSE, FALSE);
1824
1825 ReleaseCapture();
1826 ReleaseDC( hwnd, hdc );
1827
1828 /* If the item minimize or maximize of the sysmenu are not there */
1829 /* or if the style is not present, do nothing */
1830 if ((!pressed) || (state == 0xFFFFFFFF))
1831 return;
1832
1833 if (wParam == HTMINBUTTON)
1834 SendMessageA( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1835 else
1836 SendMessageA( hwnd, WM_SYSCOMMAND,
1837 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1838 }
1839
1840 /***********************************************************************
1841 * NC_TrackMinMaxBox
1842 *
1843 * Track a mouse button press on the minimize or maximize box.
1844 */
1845 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
1846 {
1847 MSG msg;
1848 HDC hdc = GetWindowDC( hwnd );
1849 BOOL pressed = TRUE;
1850 void (*paintButton)(HWND, HDC16, BOOL);
1851
1852 SetCapture( hwnd );
1853
1854 if (wParam == HTMINBUTTON)
1855 paintButton = &NC_DrawMinButton;
1856 else
1857 paintButton = &NC_DrawMaxButton;
1858
1859 (*paintButton)( hwnd, hdc, TRUE);
1860
1861 while(1)
1862 {
1863 BOOL oldstate = pressed;
1864
1865 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1866 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1867
1868 if(msg.message == WM_LBUTTONUP)
1869 break;
1870
1871 if(msg.message != WM_MOUSEMOVE)
1872 continue;
1873
1874 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1875 if (pressed != oldstate)
1876 (*paintButton)( hwnd, hdc, pressed);
1877 }
1878
1879 if(pressed)
1880 (*paintButton)( hwnd, hdc, FALSE);
1881
1882 ReleaseCapture();
1883 ReleaseDC( hwnd, hdc );
1884
1885 if (!pressed) return;
1886
1887 if (wParam == HTMINBUTTON)
1888 SendMessageA( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1889 else
1890 SendMessageA( hwnd, WM_SYSCOMMAND,
1891 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1892 }
1893
1894
1895 /***********************************************************************
1896 * NC_TrackCloseButton95
1897 *
1898 * Track a mouse button press on the Win95 close button.
1899 */
1900 static void
1901 NC_TrackCloseButton95 (HWND hwnd, WORD wParam)
1902 {
1903 MSG msg;
1904 HDC hdc;
1905 BOOL pressed = TRUE;
1906 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1907 UINT state;
1908
1909 if(hSysMenu == 0)
1910 return;
1911
1912 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1913
1914 /* If the item close of the sysmenu is disabled or not there do nothing */
1915 if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
1916 return;
1917
1918 hdc = GetWindowDC( hwnd );
1919
1920 SetCapture( hwnd );
1921
1922 NC_DrawCloseButton95 (hwnd, hdc, TRUE, FALSE);
1923
1924 while(1)
1925 {
1926 BOOL oldstate = pressed;
1927
1928 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1929 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1930
1931 if(msg.message == WM_LBUTTONUP)
1932 break;
1933
1934 if(msg.message != WM_MOUSEMOVE)
1935 continue;
1936
1937 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1938 if (pressed != oldstate)
1939 NC_DrawCloseButton95 (hwnd, hdc, pressed, FALSE);
1940 }
1941
1942 if(pressed)
1943 NC_DrawCloseButton95 (hwnd, hdc, FALSE, FALSE);
1944
1945 ReleaseCapture();
1946 ReleaseDC( hwnd, hdc );
1947 if (!pressed) return;
1948
1949 SendMessageA( hwnd, WM_SYSCOMMAND, SC_CLOSE, MAKELONG(msg.pt.x,msg.pt.y) );
1950 }
1951
1952
1953 /***********************************************************************
1954 * NC_TrackScrollBar
1955 *
1956 * Track a mouse button press on the horizontal or vertical scroll-bar.
1957 */
1958 static void NC_TrackScrollBar( HWND hwnd, WPARAM wParam, POINT pt )
1959 {
1960 INT scrollbar;
1961
1962 if ((wParam & 0xfff0) == SC_HSCROLL)
1963 {
1964 if ((wParam & 0x0f) != HTHSCROLL) return;
1965 scrollbar = SB_HORZ;
1966 }
1967 else /* SC_VSCROLL */
1968 {
1969 if ((wParam & 0x0f) != HTVSCROLL) return;
1970 scrollbar = SB_VERT;
1971 }
1972 SCROLL_TrackScrollBar( hwnd, scrollbar, pt );
1973 }
1974
1975
1976 /***********************************************************************
1977 * NC_HandleNCLButtonDown
1978 *
1979 * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
1980 */
1981 LONG NC_HandleNCLButtonDown( HWND hwnd, WPARAM wParam, LPARAM lParam )
1982 {
1983 LONG style = GetWindowLongA( hwnd, GWL_STYLE );
1984
1985 switch(wParam) /* Hit test */
1986 {
1987 case HTCAPTION:
1988 {
1989 HWND top = GetAncestor( hwnd, GA_ROOT );
1990
1991 if( WINPOS_SetActiveWindow(top, TRUE, TRUE) || (GetActiveWindow() == top) )
1992 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
1993 break;
1994 }
1995
1996 case HTSYSMENU:
1997 if( style & WS_SYSMENU )
1998 {
1999 if( !(style & WS_MINIMIZE) )
2000 {
2001 HDC hDC = GetWindowDC(hwnd);
2002 if (TWEAK_WineLook == WIN31_LOOK)
2003 NC_DrawSysButton( hwnd, hDC, TRUE );
2004 else
2005 NC_DrawSysButton95( hwnd, hDC, TRUE );
2006 ReleaseDC( hwnd, hDC );
2007 }
2008 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
2009 }
2010 break;
2011
2012 case HTMENU:
2013 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
2014 break;
2015
2016 case HTHSCROLL:
2017 SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2018 break;
2019
2020 case HTVSCROLL:
2021 SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2022 break;
2023
2024 case HTMINBUTTON:
2025 case HTMAXBUTTON:
2026 if (TWEAK_WineLook == WIN31_LOOK)
2027 NC_TrackMinMaxBox( hwnd, wParam );
2028 else
2029 NC_TrackMinMaxBox95( hwnd, wParam );
2030 break;
2031
2032 case HTCLOSE:
2033 if (TWEAK_WineLook >= WIN95_LOOK)
2034 NC_TrackCloseButton95 (hwnd, wParam);
2035 break;
2036
2037 case HTLEFT:
2038 case HTRIGHT:
2039 case HTTOP:
2040 case HTTOPLEFT:
2041 case HTTOPRIGHT:
2042 case HTBOTTOM:
2043 case HTBOTTOMLEFT:
2044 case HTBOTTOMRIGHT:
2045 /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */
2046 SendMessageW( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - 2, lParam);
2047 break;
2048
2049 case HTBORDER:
2050 break;
2051 }
2052 return 0;
2053 }
2054
2055
2056 /***********************************************************************
2057 * NC_HandleNCLButtonDblClk
2058 *
2059 * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
2060 */
2061 LONG NC_HandleNCLButtonDblClk( HWND hwnd, WPARAM wParam, LPARAM lParam )
2062 {
2063 /*
2064 * if this is an icon, send a restore since we are handling
2065 * a double click
2066 */
2067 if (IsIconic(hwnd))
2068 {
2069 SendMessageW( hwnd, WM_SYSCOMMAND, SC_RESTORE, lParam );
2070 return 0;
2071 }
2072
2073 switch(wParam) /* Hit test */
2074 {
2075 case HTCAPTION:
2076 /* stop processing if WS_MAXIMIZEBOX is missing */
2077 if (GetWindowLongA( hwnd, GWL_STYLE ) & WS_MAXIMIZEBOX)
2078 SendMessageW( hwnd, WM_SYSCOMMAND,
2079 IsZoomed(hwnd) ? SC_RESTORE : SC_MAXIMIZE, lParam );
2080 break;
2081
2082 case HTSYSMENU:
2083 if (!(GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE))
2084 SendMessageW( hwnd, WM_SYSCOMMAND, SC_CLOSE, lParam );
2085 break;
2086
2087 case HTHSCROLL:
2088 SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2089 break;
2090
2091 case HTVSCROLL:
2092 SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2093 break;
2094 }
2095 return 0;
2096 }
2097
2098
2099 /***********************************************************************
2100 * NC_HandleSysCommand
2101 *
2102 * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
2103 */
2104 LONG NC_HandleSysCommand( HWND hwnd, WPARAM wParam, LPARAM lParam )
2105 {
2106 TRACE("Handling WM_SYSCOMMAND %x %lx\n", wParam, lParam );
2107
2108 switch (wParam & 0xfff0)
2109 {
2110 case SC_SIZE:
2111 case SC_MOVE:
2112 if (USER_Driver.pSysCommandSizeMove)
2113 USER_Driver.pSysCommandSizeMove( hwnd, wParam );
2114 break;
2115
2116 case SC_MINIMIZE:
2117 if (hwnd == GetForegroundWindow())
2118 ShowOwnedPopups(hwnd,FALSE);
2119 ShowWindow( hwnd, SW_MINIMIZE );
2120 break;
2121
2122 case SC_MAXIMIZE:
2123 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2124 ShowOwnedPopups(hwnd,TRUE);
2125 ShowWindow( hwnd, SW_MAXIMIZE );
2126 break;
2127
2128 case SC_RESTORE:
2129 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2130 ShowOwnedPopups(hwnd,TRUE);
2131 ShowWindow( hwnd, SW_RESTORE );
2132 break;
2133
2134 case SC_CLOSE:
2135 return SendMessageA( hwnd, WM_CLOSE, 0, 0 );
2136
2137 case SC_VSCROLL:
2138 case SC_HSCROLL:
2139 {
2140 POINT pt;
2141 pt.x = SLOWORD(lParam);
2142 pt.y = SHIWORD(lParam);
2143 NC_TrackScrollBar( hwnd, wParam, pt );
2144 }
2145 break;
2146
2147 case SC_MOUSEMENU:
2148 {
2149 POINT pt;
2150 pt.x = SLOWORD(lParam);
2151 pt.y = SHIWORD(lParam);
2152 MENU_TrackMouseMenuBar( hwnd, wParam & 0x000F, pt );
2153 }
2154 break;
2155
2156 case SC_KEYMENU:
2157 MENU_TrackKbdMenuBar( hwnd, wParam, LOWORD(lParam) );
2158 break;
2159
2160 case SC_TASKLIST:
2161 WinExec( "taskman.exe", SW_SHOWNORMAL );
2162 break;
2163
2164 case SC_SCREENSAVE:
2165 if (wParam == SC_ABOUTWINE)
2166 {
2167 HMODULE hmodule = LoadLibraryA( "shell32.dll" );
2168 if (hmodule)
2169 {
2170 FARPROC aboutproc = GetProcAddress( hmodule, "ShellAboutA" );
2171 if (aboutproc) aboutproc( hwnd, "Wine", WINE_RELEASE_INFO, 0 );
2172 FreeLibrary( hmodule );
2173 }
2174 }
2175 else
2176 if (wParam == SC_PUTMARK)
2177 TRACE_(shell)("Mark requested by user\n");
2178 break;
2179
2180 case SC_HOTKEY:
2181 case SC_ARRANGE:
2182 case SC_NEXTWINDOW:
2183 case SC_PREVWINDOW:
2184 FIXME("unimplemented!\n");
2185 break;
2186 }
2187 return 0;
2188 }
2189
2190 /*************************************************************
2191 * NC_DrawGrayButton
2192 *
2193 * Stub for the grayed button of the caption
2194 *
2195 *************************************************************/
2196
2197 BOOL NC_DrawGrayButton(HDC hdc, int x, int y)
2198 {
2199 HBITMAP hMaskBmp;
2200 HDC hdcMask = CreateCompatibleDC (0);
2201 HBRUSH hOldBrush;
2202
2203 hMaskBmp = CreateBitmap (12, 10, 1, 1, lpGrayMask);
2204
2205 if(hMaskBmp == 0)
2206 return FALSE;
2207
2208 SelectObject (hdcMask, hMaskBmp);
2209
2210 /* Draw the grayed bitmap using the mask */
2211 hOldBrush = SelectObject (hdc, RGB(128, 128, 128));
2212 BitBlt (hdc, x, y, 12, 10,
2213 hdcMask, 0, 0, 0xB8074A);
2214
2215 /* Clean up */
2216 SelectObject (hdc, hOldBrush);
2217 DeleteObject(hMaskBmp);
2218 DeleteDC (hdcMask);
2219
2220 return TRUE;
2221 }