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