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