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