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