?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 980329
[wine.git] / windows / nonclient.c
blob6d75fc1dadd61f8eab1b3fb2200581338f9c053a
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 "graphics.h"
22 #include "queue.h"
23 #include "selectors.h"
24 #include "tweak.h"
25 #include "debug.h"
26 #include "options.h"
27
28
29 int NC_CaptionLeftNudge;
30 int NC_CaptionTopNudge;
31 int NC_SysControlNudge;
32 int NC_MaxControlNudge;
33 int NC_MinControlNudge;
34 UINT32 NC_CaptionTextFlags;
35 HBRUSH32 NC_WinHighlight95;
36 HBRUSH32 NC_WinShadow95;
37
38 static HBITMAP16 hbitmapClose = 0;
39 static HBITMAP16 hbitmapMinimize = 0;
40 static HBITMAP16 hbitmapMinimizeD = 0;
41 static HBITMAP16 hbitmapMaximize = 0;
42 static HBITMAP16 hbitmapMaximizeD = 0;
43 static HBITMAP16 hbitmapRestore = 0;
44 static HBITMAP16 hbitmapRestoreD = 0;
45
46 #define SC_ABOUTWINE (SC_SCREENSAVE+1)
47
48 /* Some useful macros */
49 #define HAS_DLGFRAME(style,exStyle) \
50 (((exStyle) & WS_EX_DLGMODALFRAME) || \
51 (((style) & WS_DLGFRAME) && !((style) & WS_BORDER)))
52
53 #define HAS_THICKFRAME(style) \
54 (((style) & WS_THICKFRAME) && \
55 !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
56
57 #define HAS_MENU(w) (!((w)->dwStyle & WS_CHILD) && ((w)->wIDmenu != 0))
58
59 #define ON_LEFT_BORDER(hit) \
60 (((hit) == HTLEFT) || ((hit) == HTTOPLEFT) || ((hit) == HTBOTTOMLEFT))
61 #define ON_RIGHT_BORDER(hit) \
62 (((hit) == HTRIGHT) || ((hit) == HTTOPRIGHT) || ((hit) == HTBOTTOMRIGHT))
63 #define ON_TOP_BORDER(hit) \
64 (((hit) == HTTOP) || ((hit) == HTTOPLEFT) || ((hit) == HTTOPRIGHT))
65 #define ON_BOTTOM_BORDER(hit) \
66 (((hit) == HTBOTTOM) || ((hit) == HTBOTTOMLEFT) || ((hit) == HTBOTTOMRIGHT))
67
68 /***********************************************************************
69 * NC_AdjustRect
70 *
71 * Compute the size of the window rectangle from the size of the
72 * client rectangle.
73 */
74 static void NC_AdjustRect( LPRECT16 rect, DWORD style, BOOL32 menu,
75 DWORD exStyle )
76 {
77 if(TWEAK_Win95Look)
78 fprintf( stddeb, "NC_AdjustRect was called in Win95 mode. Aiee! "
79 "Please report this.\n" );
80
81 if(style & WS_ICONIC) return;
82 /* Decide if the window will be managed (see CreateWindowEx) */
83 if (!(Options.managed && !(style & WS_CHILD) &&
84 ((style & (WS_DLGFRAME | WS_THICKFRAME)) ||
85 (exStyle & WS_EX_DLGMODALFRAME))))
86 {
87 if (HAS_DLGFRAME( style, exStyle ))
88 InflateRect16(rect, SYSMETRICS_CXDLGFRAME, SYSMETRICS_CYDLGFRAME );
89 else
90 {
91 if (HAS_THICKFRAME(style))
92 InflateRect16( rect, SYSMETRICS_CXFRAME, SYSMETRICS_CYFRAME );
93 if (style & WS_BORDER)
94 InflateRect16( rect, SYSMETRICS_CXBORDER, SYSMETRICS_CYBORDER);
95 }
96
97 if ((style & WS_CAPTION) == WS_CAPTION)
98 rect->top -= SYSMETRICS_CYCAPTION - SYSMETRICS_CYBORDER;
99 }
100 if (menu) rect->top -= SYSMETRICS_CYMENU + SYSMETRICS_CYBORDER;
101
102 if (style & WS_VSCROLL) rect->right += SYSMETRICS_CXVSCROLL - 1;
103 if (style & WS_HSCROLL) rect->bottom += SYSMETRICS_CYHSCROLL - 1;
104 }
105
106
107 /******************************************************************************
108 *
109 * NC_AdjustRect95(
110 * LPRECT16 rect,
111 * DWORD style,
112 * BOOL32 menu,
113 * DWORD exStyle )
114 *
115 * Computes the size of the window based on the parameters of the client
116 * area.
117 *
118 * Bugs
119 * Most of this code is copied from NC_AdjustRect. It shouldn't be.
120 * There are some unique things about Win 95 that are being horribly
121 * neglected here. I don't know what they are, either. :-\
122 *
123 * Revision history
124 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
125 * Original cut & paste from NC_AdjustRect
126 *
127 *****************************************************************************/
128
129 static void NC_AdjustRect95( LPRECT16 rect, DWORD style, BOOL32 menu,
130 DWORD exStyle )
131 {
132 if(style & WS_ICONIC) return;
133
134 /* Decide if the window will be managed (see CreateWindowEx) */
135 if (!(Options.managed && !(style & WS_CHILD) &&
136 ((style & (WS_DLGFRAME | WS_THICKFRAME)) ||
137 (exStyle & WS_EX_DLGMODALFRAME))))
138 {
139 if (HAS_DLGFRAME( style, exStyle ))
140 InflateRect16(rect, SYSMETRICS_CXDLGFRAME, SYSMETRICS_CYDLGFRAME );
141 else
142 {
143 if (HAS_THICKFRAME(style))
144 InflateRect16( rect, SYSMETRICS_CXFRAME, SYSMETRICS_CYFRAME );
145 if (style & WS_BORDER)
146 InflateRect16( rect, SYSMETRICS_CXBORDER, SYSMETRICS_CYBORDER);
147 }
148
149 if ((style & WS_CAPTION) == WS_CAPTION)
150 rect->top -= SYSMETRICS_CYCAPTION - SYSMETRICS_CYBORDER;
151 }
152 if (menu) rect->top -= SYSMETRICS_CYMENU + SYSMETRICS_CYBORDER + 2;
153 else rect->top += SYSMETRICS_CYBORDER;
154
155 if (style & WS_VSCROLL) rect->right += SYSMETRICS_CXVSCROLL;
156 if (style & WS_HSCROLL) rect->bottom += SYSMETRICS_CYHSCROLL;
157 }
158
159
160 /***********************************************************************
161 * DrawCaptionTempA (USER32.)
162 */
163 DWORD
164 DrawCaptionTemp32A(HWND32 hwnd,HDC32 hdc,LPRECT32 rect,HFONT32 hfont,DWORD x1,LPCSTR str,DWORD x2) {
165 fprintf(stderr,"DrawCaptionTempA(%08x,%08x,%p,%08x,%08lx,\"%s\",%08lx),tub!\n",
166 hwnd,hdc,rect,hfont,x1,str,x2
167 );
168 return 0;
169 }
170
171
172 /***********************************************************************
173 * AdjustWindowRect16 (USER.102)
174 */
175 BOOL16 WINAPI AdjustWindowRect16( LPRECT16 rect, DWORD style, BOOL16 menu )
176 {
177 return AdjustWindowRectEx16( rect, style, menu, 0 );
178 }
179
180
181 /***********************************************************************
182 * AdjustWindowRect32 (USER32.)
183 */
184 BOOL32 WINAPI AdjustWindowRect32( LPRECT32 rect, DWORD style, BOOL32 menu )
185 {
186 return AdjustWindowRectEx32( rect, style, menu, 0 );
187 }
188
189
190 /***********************************************************************
191 * AdjustWindowRectEx16 (USER.454)
192 */
193 BOOL16 WINAPI AdjustWindowRectEx16( LPRECT16 rect, DWORD style,
194 BOOL16 menu, DWORD exStyle )
195 {
196 /* Correct the window style */
197
198 if (!(style & (WS_POPUP | WS_CHILD))) /* Overlapped window */
199 style |= WS_CAPTION;
200 style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD);
201 exStyle &= WS_EX_DLGMODALFRAME;
202 if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
203
204 TRACE(nonclient, "(%d,%d)-(%d,%d) %08lx %d %08lx\n",
205 rect->left, rect->top, rect->right, rect->bottom,
206 style, menu, exStyle );
207
208 if(TWEAK_Win95Look)
209 NC_AdjustRect95( rect, style, menu, exStyle );
210 else
211 NC_AdjustRect( rect, style, menu, exStyle );
212
213 return TRUE;
214 }
215
216
217 /***********************************************************************
218 * AdjustWindowRectEx32 (USER32.)
219 */
220 BOOL32 WINAPI AdjustWindowRectEx32( LPRECT32 rect, DWORD style,
221 BOOL32 menu, DWORD exStyle )
222 {
223 RECT16 rect16;
224 BOOL32 ret;
225
226 CONV_RECT32TO16( rect, &rect16 );
227 ret = AdjustWindowRectEx16( &rect16, style, (BOOL16)menu, exStyle );
228 CONV_RECT16TO32( &rect16, rect );
229 return ret;
230 }
231
232
233 /***********************************************************************
234 * NC_HandleNCCalcSize
235 *
236 * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
237 */
238 LONG NC_HandleNCCalcSize( WND *pWnd, RECT32 *winRect )
239 {
240 RECT16 tmpRect = { 0, 0, 0, 0 };
241 LONG result = 0;
242
243 if (pWnd->class->style & CS_VREDRAW) result |= WVR_VREDRAW;
244 if (pWnd->class->style & CS_HREDRAW) result |= WVR_HREDRAW;
245
246 if( !( pWnd->dwStyle & WS_MINIMIZE ) ) {
247 if(TWEAK_Win95Look)
248 NC_AdjustRect95( &tmpRect, pWnd->dwStyle, FALSE, pWnd->dwExStyle );
249 else
250 NC_AdjustRect( &tmpRect, pWnd->dwStyle, FALSE, pWnd->dwExStyle );
251
252 winRect->left -= tmpRect.left;
253 winRect->top -= tmpRect.top;
254 winRect->right -= tmpRect.right;
255 winRect->bottom -= tmpRect.bottom;
256
257 if (HAS_MENU(pWnd)) {
258 TRACE(nonclient, "Calling "
259 "GetMenuBarHeight with HWND 0x%x, width %d, "
260 "at (%d, %d).\n", pWnd->hwndSelf,
261 winRect->right - winRect->left,
262 -tmpRect.left, -tmpRect.top );
263
264 winRect->top +=
265 MENU_GetMenuBarHeight( pWnd->hwndSelf,
266 winRect->right - winRect->left,
267 -tmpRect.left, -tmpRect.top ) + 1;
268 }
269 }
270 return result;
271 }
272
273
274 /***********************************************************************
275 * NC_GetInsideRect
276 *
277 * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
278 * but without the borders (if any).
279 * The rectangle is in window coordinates (for drawing with GetWindowDC()).
280 *
281 * FIXME: A Win95 version of this function is needed.
282 */
283 static void NC_GetInsideRect( HWND32 hwnd, RECT32 *rect )
284 {
285 WND * wndPtr = WIN_FindWndPtr( hwnd );
286
287 rect->top = rect->left = 0;
288 rect->right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
289 rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
290
291 if ((wndPtr->dwStyle & WS_ICONIC) || (wndPtr->flags & WIN_MANAGED)) return;
292
293 /* Remove frame from rectangle */
294 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
295 {
296 InflateRect32( rect, -SYSMETRICS_CXDLGFRAME, -SYSMETRICS_CYDLGFRAME);
297 if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
298 InflateRect32( rect, -1, 0 );
299 }
300 else
301 {
302 if (HAS_THICKFRAME( wndPtr->dwStyle ))
303 InflateRect32( rect, -SYSMETRICS_CXFRAME, -SYSMETRICS_CYFRAME );
304 if (wndPtr->dwStyle & WS_BORDER)
305 InflateRect32( rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER );
306 }
307
308 return;
309 }
310
311
312 /***********************************************************************
313 * NC_HandleNCHitTest
314 *
315 * Handle a WM_NCHITTEST message. Called from DefWindowProc().
316 *
317 * FIXME: A Win95 version of this function is needed.
318 */
319 LONG NC_HandleNCHitTest( HWND32 hwnd, POINT16 pt )
320 {
321 RECT16 rect;
322 WND *wndPtr = WIN_FindWndPtr( hwnd );
323 if (!wndPtr) return HTERROR;
324
325 TRACE(nonclient, "hwnd=%04x pt=%d,%d\n",
326 hwnd, pt.x, pt.y );
327
328 GetWindowRect16( hwnd, &rect );
329 if (!PtInRect16( &rect, pt )) return HTNOWHERE;
330
331 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
332
333 if (!(wndPtr->flags & WIN_MANAGED))
334 {
335 /* Check borders */
336 if (HAS_THICKFRAME( wndPtr->dwStyle ))
337 {
338 InflateRect16( &rect, -SYSMETRICS_CXFRAME, -SYSMETRICS_CYFRAME );
339 if (wndPtr->dwStyle & WS_BORDER)
340 InflateRect16(&rect,-SYSMETRICS_CXBORDER,-SYSMETRICS_CYBORDER);
341 if (!PtInRect16( &rect, pt ))
342 {
343 /* Check top sizing border */
344 if (pt.y < rect.top)
345 {
346 if (pt.x < rect.left+SYSMETRICS_CXSIZE) return HTTOPLEFT;
347 if (pt.x >= rect.right-SYSMETRICS_CXSIZE) return HTTOPRIGHT;
348 return HTTOP;
349 }
350 /* Check bottom sizing border */
351 if (pt.y >= rect.bottom)
352 {
353 if (pt.x < rect.left+SYSMETRICS_CXSIZE) return HTBOTTOMLEFT;
354 if (pt.x >= rect.right-SYSMETRICS_CXSIZE) return HTBOTTOMRIGHT;
355 return HTBOTTOM;
356 }
357 /* Check left sizing border */
358 if (pt.x < rect.left)
359 {
360 if (pt.y < rect.top+SYSMETRICS_CYSIZE) return HTTOPLEFT;
361 if (pt.y >= rect.bottom-SYSMETRICS_CYSIZE) return HTBOTTOMLEFT;
362 return HTLEFT;
363 }
364 /* Check right sizing border */
365 if (pt.x >= rect.right)
366 {
367 if (pt.y < rect.top+SYSMETRICS_CYSIZE) return HTTOPRIGHT;
368 if (pt.y >= rect.bottom-SYSMETRICS_CYSIZE) return HTBOTTOMRIGHT;
369 return HTRIGHT;
370 }
371 }
372 }
373 else /* No thick frame */
374 {
375 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
376 InflateRect16(&rect, -SYSMETRICS_CXDLGFRAME, -SYSMETRICS_CYDLGFRAME);
377 else if (wndPtr->dwStyle & WS_BORDER)
378 InflateRect16(&rect, -SYSMETRICS_CXBORDER, -SYSMETRICS_CYBORDER);
379 if (!PtInRect16( &rect, pt )) return HTBORDER;
380 }
381
382 /* Check caption */
383
384 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
385 {
386 rect.top += SYSMETRICS_CYCAPTION - 1;
387 if (!PtInRect16( &rect, pt ))
388 {
389 /* Check system menu */
390 if (wndPtr->dwStyle & WS_SYSMENU)
391 rect.left += SYSMETRICS_CXSIZE;
392 if (pt.x <= rect.left) return HTSYSMENU;
393 /* Check maximize box */
394 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
395 rect.right -= SYSMETRICS_CXSIZE + 1;
396 if (pt.x >= rect.right) return HTMAXBUTTON;
397 /* Check minimize box */
398 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
399 rect.right -= SYSMETRICS_CXSIZE + 1;
400 if (pt.x >= rect.right) return HTMINBUTTON;
401 return HTCAPTION;
402 }
403 }
404 }
405
406 /* Check client area */
407
408 ScreenToClient16( hwnd, &pt );
409 GetClientRect16( hwnd, &rect );
410 if (PtInRect16( &rect, pt )) return HTCLIENT;
411
412 /* Check vertical scroll bar */
413
414 if (wndPtr->dwStyle & WS_VSCROLL)
415 {
416 rect.right += SYSMETRICS_CXVSCROLL;
417 if (PtInRect16( &rect, pt )) return HTVSCROLL;
418 }
419
420 /* Check horizontal scroll bar */
421
422 if (wndPtr->dwStyle & WS_HSCROLL)
423 {
424 rect.bottom += SYSMETRICS_CYHSCROLL;
425 if (PtInRect16( &rect, pt ))
426 {
427 /* Check size box */
428 if ((wndPtr->dwStyle & WS_VSCROLL) &&
429 (pt.x >= rect.right - SYSMETRICS_CXVSCROLL))
430 return HTSIZE;
431 return HTHSCROLL;
432 }
433 }
434
435 /* Check menu bar */
436
437 if (HAS_MENU(wndPtr))
438 {
439 if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
440 return HTMENU;
441 }
442
443 /* Should never get here */
444 return HTERROR;
445 }
446
447
448 /***********************************************************************
449 * NC_DrawSysButton
450 */
451 void NC_DrawSysButton( HWND32 hwnd, HDC32 hdc, BOOL32 down )
452 {
453 RECT32 rect;
454 HDC32 hdcMem;
455 HBITMAP32 hbitmap;
456 WND *wndPtr = WIN_FindWndPtr( hwnd );
457
458 if( !(wndPtr->flags & WIN_MANAGED) )
459 {
460 NC_GetInsideRect( hwnd, &rect );
461 hdcMem = CreateCompatibleDC32( hdc );
462 hbitmap = SelectObject32( hdcMem, hbitmapClose );
463 BitBlt32(hdc, rect.left, rect.top, SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
464 hdcMem, (wndPtr->dwStyle & WS_CHILD) ? SYSMETRICS_CXSIZE : 0, 0,
465 down ? NOTSRCCOPY : SRCCOPY );
466 SelectObject32( hdcMem, hbitmap );
467 DeleteDC32( hdcMem );
468 }
469 }
470
471
472 /***********************************************************************
473 * NC_DrawMaxButton
474 */
475 static void NC_DrawMaxButton( HWND32 hwnd, HDC16 hdc, BOOL32 down )
476 {
477 RECT32 rect;
478 WND *wndPtr = WIN_FindWndPtr( hwnd );
479
480 if( !(wndPtr->flags & WIN_MANAGED) )
481 {
482 NC_GetInsideRect( hwnd, &rect );
483 GRAPH_DrawBitmap( hdc, (IsZoomed32(hwnd)
484 ? (down ? hbitmapRestoreD : hbitmapRestore)
485 : (down ? hbitmapMaximizeD : hbitmapMaximize)),
486 rect.right - SYSMETRICS_CXSIZE - 1, rect.top,
487 0, 0, SYSMETRICS_CXSIZE+1, SYSMETRICS_CYSIZE, FALSE );
488 }
489 }
490
491
492 /***********************************************************************
493 * NC_DrawMinButton
494 */
495 static void NC_DrawMinButton( HWND32 hwnd, HDC16 hdc, BOOL32 down )
496 {
497 RECT32 rect;
498 WND *wndPtr = WIN_FindWndPtr( hwnd );
499
500 if( !(wndPtr->flags & WIN_MANAGED) )
501 {
502 NC_GetInsideRect( hwnd, &rect );
503 if (wndPtr->dwStyle & WS_MAXIMIZEBOX) rect.right -= SYSMETRICS_CXSIZE+1;
504 GRAPH_DrawBitmap( hdc, (down ? hbitmapMinimizeD : hbitmapMinimize),
505 rect.right - SYSMETRICS_CXSIZE - 1, rect.top,
506 0, 0, SYSMETRICS_CXSIZE+1, SYSMETRICS_CYSIZE, FALSE );
507 }
508 }
509
510
511 /******************************************************************************
512 *
513 * void NC_DrawSysButton95(
514 * HWND32 hwnd,
515 * HDC32 hdc,
516 * BOOL32 down )
517 *
518 * Draws a fake Win95 system button. Horribly broken. We should be drawing
519 * an icon, not the X. (This will require some thought)
520 *
521 * Bugs
522 * Plain and simply doesn't work. Fails miserably for child windows.
523 *
524 * Revision history
525 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
526 * Original implementation from NC_DrawSysButton source.
527 *
528 *****************************************************************************/
529
530 void NC_DrawSysButton95(
531 HWND32 hwnd,
532 HDC32 hdc,
533 BOOL32 down )
534 {
535 RECT32 rect;
536 HDC32 hdcMem;
537 HBITMAP32 hbitmap;
538 WND *wndPtr = WIN_FindWndPtr( hwnd );
539 SIZE32 bmsz;
540
541 if( !(wndPtr->flags & WIN_MANAGED) )
542 {
543 NC_GetInsideRect( hwnd, &rect );
544 hdcMem = CreateCompatibleDC32( hdc );
545 hbitmap = SelectObject32( hdcMem, hbitmapClose );
546 if(GetBitmapDimensionEx32( hbitmapClose, &bmsz )) {
547 BitBlt32(hdc, rect.left + (sysMetrics[SM_CXSIZE] - bmsz.cx) / 2 +
548 NC_SysControlNudge,
549 rect.top + (sysMetrics[SM_CYSIZE] - bmsz.cy - 1) / 2,
550 bmsz.cx, bmsz.cy,
551 hdcMem, 0, 0, down ? NOTSRCCOPY : SRCCOPY );
552 }
553 SelectObject32( hdcMem, hbitmap );
554 DeleteDC32( hdcMem );
555
556 }
557 return;
558 }
559
560
561 /******************************************************************************
562 *
563 * NC_DrawMaxButton95(
564 * HWND32 hwnd,
565 * HDC16 hdc,
566 * BOOL32 down )
567 *
568 * Draws the maximize button for Win95 style windows.
569 *
570 * Bugs
571 * Many. Spacing might still be incorrect. Need to fit a close
572 * button between the max button and the edge. Draws the wrong thing
573 * (a Win31 up-down) when maximized. Should scale the image with the
574 * title bar. And more...
575 *
576 * Revision history
577 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
578 * Original implementation.
579 *
580 *****************************************************************************/
581
582 static void NC_DrawMaxButton95(
583 HWND32 hwnd,
584 HDC16 hdc,
585 BOOL32 down )
586 {
587 RECT32 rect;
588 WND *wndPtr = WIN_FindWndPtr( hwnd );
589 SIZE32 bmsz;
590 HBITMAP32 bm;
591
592 if( !(wndPtr->flags & WIN_MANAGED) &&
593 GetBitmapDimensionEx32((bm = IsZoomed32(hwnd) ?
594 (down ? hbitmapRestoreD : hbitmapRestore ) :
595 (down ? hbitmapMaximizeD : hbitmapMaximize)),
596 &bmsz)) {
597
598 NC_GetInsideRect( hwnd, &rect );
599
600 GRAPH_DrawBitmap( hdc, bm,
601 rect.right + NC_MaxControlNudge -
602 (sysMetrics[SM_CXSIZE] + bmsz.cx) / 2,
603 rect.top + (sysMetrics[SM_CYSIZE] - bmsz.cy - 1) / 2,
604 0, 0, bmsz.cx, bmsz.cy, FALSE );
605 }
606
607 return;
608 }
609
610
611 /******************************************************************************
612 *
613 * NC_DrawMinButton95(
614 * HWND32 hwnd,
615 * HDC16 hdc,
616 * BOOL32 down )
617 *
618 * Draws the minimize button for Win95 style windows.
619 *
620 * Bugs
621 * Many. Spacing is still incorrect. Should scale the image with the
622 * title bar. And more...
623 *
624 * Revision history
625 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
626 * Original implementation.
627 *
628 *****************************************************************************/
629
630 static void NC_DrawMinButton95(
631 HWND32 hwnd,
632 HDC16 hdc,
633 BOOL32 down )
634 {
635 RECT32 rect;
636 WND *wndPtr = WIN_FindWndPtr( hwnd );
637 SIZE32 bmsz;
638 HBITMAP32 bm;
639
640 if( !(wndPtr->flags & WIN_MANAGED) &&
641 GetBitmapDimensionEx32((bm = down ? hbitmapMinimizeD :
642 hbitmapMinimize), &bmsz)) {
643
644 NC_GetInsideRect( hwnd, &rect );
645
646 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
647 rect.right += -1 + NC_MaxControlNudge -
648 (sysMetrics[SM_CXSIZE] + bmsz.cx) / 2;
649
650 GRAPH_DrawBitmap( hdc, bm, rect.right + NC_MinControlNudge -
651 (sysMetrics[SM_CXSIZE] + bmsz.cx) / 2,
652 rect.top + (sysMetrics[SM_CYSIZE] - bmsz.cy - 1) / 2,
653 0, 0, bmsz.cx, bmsz.cy, FALSE );
654 }
655
656 return;
657 }
658
659
660 /***********************************************************************
661 * NC_DrawFrame
662 *
663 * Draw a window frame inside the given rectangle, and update the rectangle.
664 * The correct pen for the frame must be selected in the DC.
665 */
666 static void NC_DrawFrame( HDC32 hdc, RECT32 *rect, BOOL32 dlgFrame,
667 BOOL32 active )
668 {
669 INT32 width, height;
670
671 if(TWEAK_Win95Look)
672 fprintf( stddeb, "NC_DrawFrame was called in Win95 mode. Aiee! "
673 "Please report this.\n" );
674
675 if (dlgFrame)
676 {
677 width = SYSMETRICS_CXDLGFRAME - 1;
678 height = SYSMETRICS_CYDLGFRAME - 1;
679 SelectObject32( hdc, GetSysColorBrush32(active ? COLOR_ACTIVECAPTION :
680 COLOR_INACTIVECAPTION) );
681 }
682 else
683 {
684 width = SYSMETRICS_CXFRAME - 1;
685 height = SYSMETRICS_CYFRAME - 1;
686 SelectObject32( hdc, GetSysColorBrush32(active ? COLOR_ACTIVEBORDER :
687 COLOR_INACTIVEBORDER) );
688 }
689
690 /* Draw frame */
691 PatBlt32( hdc, rect->left, rect->top,
692 rect->right - rect->left, height, PATCOPY );
693 PatBlt32( hdc, rect->left, rect->top,
694 width, rect->bottom - rect->top, PATCOPY );
695 PatBlt32( hdc, rect->left, rect->bottom,
696 rect->right - rect->left, -height, PATCOPY );
697 PatBlt32( hdc, rect->right, rect->top,
698 -width, rect->bottom - rect->top, PATCOPY );
699
700 if (dlgFrame)
701 {
702 InflateRect32( rect, -width, -height );
703 }
704 else
705 {
706 POINT32 lpt[16];
707
708 /* Draw inner rectangle */
709
710 GRAPH_DrawRectangle( hdc, rect->left + width,
711 rect->top + height,
712 rect->right - rect->left - 2*width ,
713 rect->bottom - rect->top - 2*height,
714 (HPEN32)0 );
715
716 /* Draw the decorations */
717
718 lpt[4].x = lpt[0].x = rect->left;
719 lpt[5].x = lpt[1].x = rect->left + width;
720 lpt[6].x = lpt[2].x = rect->right - 1;
721 lpt[7].x = lpt[3].x = rect->right - width - 1;
722
723 lpt[0].y = lpt[1].y = lpt[2].y = lpt[3].y =
724 rect->top + SYSMETRICS_CYFRAME + SYSMETRICS_CYSIZE;
725 lpt[4].y = lpt[5].y = lpt[6].y = lpt[7].y =
726 rect->bottom - SYSMETRICS_CYFRAME - SYSMETRICS_CYSIZE;
727
728 lpt[8].x = lpt[9].x = lpt[10].x = lpt[11].x =
729 rect->left + SYSMETRICS_CXFRAME + SYSMETRICS_CXSIZE;
730 lpt[12].x = lpt[13].x = lpt[14].x = lpt[15].x =
731 rect->right - SYSMETRICS_CXFRAME - SYSMETRICS_CYSIZE;
732
733 lpt[12].y = lpt[8].y = rect->top;
734 lpt[13].y = lpt[9].y = rect->top + height;
735 lpt[14].y = lpt[10].y = rect->bottom - 1;
736 lpt[15].y = lpt[11].y = rect->bottom - height - 1;
737
738 GRAPH_DrawLines( hdc, lpt, 8, (HPEN32)0 ); /* 8 is the maximum */
739 InflateRect32( rect, -width - 1, -height - 1 );
740 }
741 }
742
743
744 /******************************************************************************
745 *
746 * void NC_DrawFrame95(
747 * HDC32 hdc,
748 * RECT32 *rect,
749 * BOOL32 dlgFrame,
750 * BOOL32 active )
751 *
752 * Draw a window frame inside the given rectangle, and update the rectangle.
753 * The correct pen for the frame must be selected in the DC.
754 *
755 * Bugs
756 * Many. First, just what IS a frame in Win95? Note that the 3D look
757 * on the outer edge is handled by NC_DoNCPaint95. As is the inner
758 * edge. The inner rectangle just inside the frame is handled by the
759 * Caption code.
760 *
761 * In short, for most people, this function should be a nop (unless
762 * you LIKE thick borders in Win95/NT4.0 -- I've been working with
763 * them lately, but just to get this code right). Even so, it doesn't
764 * appear to be so. It's being worked on...
765 *
766 * Revision history
767 * 06-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
768 * Original implementation (based on NC_DrawFrame)
769 *
770 *****************************************************************************/
771
772 static void NC_DrawFrame95(
773 HDC32 hdc,
774 RECT32 *rect,
775 BOOL32 dlgFrame,
776 BOOL32 active )
777 {
778 INT32 width, height;
779
780 if (dlgFrame)
781 {
782 width = SYSMETRICS_CXDLGFRAME - 1;
783 height = SYSMETRICS_CYDLGFRAME - 1;
784 SelectObject32( hdc, GetSysColorBrush32(active ? COLOR_ACTIVECAPTION :
785 COLOR_INACTIVECAPTION) );
786 }
787 else
788 {
789 width = sysMetrics[SM_CXFRAME] - sysMetrics[SM_CXEDGE] - 1;
790 height = sysMetrics[SM_CYFRAME] - sysMetrics[SM_CYEDGE] - 1;
791 SelectObject32( hdc, GetSysColorBrush32(active ? COLOR_ACTIVEBORDER :
792 COLOR_INACTIVEBORDER) );
793 }
794
795 /* Draw frame */
796 PatBlt32( hdc, rect->left, rect->top,
797 rect->right - rect->left, height, PATCOPY );
798 PatBlt32( hdc, rect->left, rect->top,
799 width, rect->bottom - rect->top, PATCOPY );
800 PatBlt32( hdc, rect->left, rect->bottom,
801 rect->right - rect->left, -height, PATCOPY );
802 PatBlt32( hdc, rect->right, rect->top,
803 -width, rect->bottom - rect->top, PATCOPY );
804
805 InflateRect32( rect, -width, -height );
806
807 if(!dlgFrame) {
808 /* Draw inner rectangle */
809 GRAPH_DrawRectangle( hdc, rect->left, rect->top,
810 rect->right - rect->left,
811 rect->bottom - rect->top,
812 TWEAK_PenC095 );
813
814 InflateRect32( rect, -1, -1 );
815 }
816 }
817
818
819
820 /***********************************************************************
821 * NC_DrawMovingFrame
822 *
823 * Draw the frame used when moving or resizing window.
824 *
825 * FIXME: This causes problems in Win95 mode. (why?)
826 */
827 static void NC_DrawMovingFrame( HDC32 hdc, RECT32 *rect, BOOL32 thickframe )
828 {
829 if (thickframe)
830 {
831 RECT16 r16;
832 CONV_RECT32TO16( rect, &r16 );
833 FastWindowFrame( hdc, &r16, SYSMETRICS_CXFRAME,
834 SYSMETRICS_CYFRAME, PATINVERT );
835 }
836 else DrawFocusRect32( hdc, rect );
837 }
838
839
840 /***********************************************************************
841 * NC_DrawCaption
842 *
843 * Draw the window caption.
844 * The correct pen for the window frame must be selected in the DC.
845 */
846 static void NC_DrawCaption( HDC32 hdc, RECT32 *rect, HWND32 hwnd,
847 DWORD style, BOOL32 active )
848 {
849 RECT32 r = *rect;
850 WND * wndPtr = WIN_FindWndPtr( hwnd );
851 char buffer[256];
852
853 if (wndPtr->flags & WIN_MANAGED) return;
854
855 if (!hbitmapClose)
856 {
857 if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_CLOSE) )))
858 return;
859 hbitmapMinimize = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_REDUCE) );
860 hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_REDUCED) );
861 hbitmapMaximize = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_ZOOM) );
862 hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_ZOOMD) );
863 hbitmapRestore = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_RESTORE) );
864 hbitmapRestoreD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_RESTORED) );
865 }
866
867 if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
868 {
869 HBRUSH32 hbrushOld = SelectObject32(hdc, GetSysColorBrush32(COLOR_WINDOW) );
870 PatBlt32( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
871 PatBlt32( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
872 PatBlt32( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
873 r.left++;
874 r.right--;
875 SelectObject32( hdc, hbrushOld );
876 }
877
878 MoveTo( hdc, r.left, r.bottom );
879 LineTo32( hdc, r.right, r.bottom );
880
881 if (style & WS_SYSMENU)
882 {
883 NC_DrawSysButton( hwnd, hdc, FALSE );
884 r.left += SYSMETRICS_CXSIZE + 1;
885 MoveTo( hdc, r.left - 1, r.top );
886 LineTo32( hdc, r.left - 1, r.bottom );
887 }
888 if (style & WS_MAXIMIZEBOX)
889 {
890 NC_DrawMaxButton( hwnd, hdc, FALSE );
891 r.right -= SYSMETRICS_CXSIZE + 1;
892 }
893 if (style & WS_MINIMIZEBOX)
894 {
895 NC_DrawMinButton( hwnd, hdc, FALSE );
896 r.right -= SYSMETRICS_CXSIZE + 1;
897 }
898
899 FillRect32( hdc, &r, GetSysColorBrush32(active ? COLOR_ACTIVECAPTION :
900 COLOR_INACTIVECAPTION) );
901
902 if (GetWindowText32A( hwnd, buffer, sizeof(buffer) ))
903 {
904 if (active) SetTextColor32( hdc, GetSysColor32( COLOR_CAPTIONTEXT ) );
905 else SetTextColor32( hdc, GetSysColor32( COLOR_INACTIVECAPTIONTEXT ) );
906 SetBkMode32( hdc, TRANSPARENT );
907 DrawText32A( hdc, buffer, -1, &r,
908 DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX );
909 }
910 }
911
912
913 /******************************************************************************
914 *
915 * NC_DrawCaption95(
916 * HDC32 hdc,
917 * RECT32 *rect,
918 * HWND32 hwnd,
919 * DWORD style,
920 * BOOL32 active )
921 *
922 * Draw the window caption for Win95 style windows.
923 * The correct pen for the window frame must be selected in the DC.
924 *
925 * Bugs
926 * Hey, a function that finally works! Well, almost. In Win95, the
927 * title has its own font -- not the system font. It's being worked
928 * on.
929 *
930 * Revision history
931 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
932 * Original implementation.
933 *
934 *****************************************************************************/
935
936 static void NC_DrawCaption95(
937 HDC32 hdc,
938 RECT32 *rect,
939 HWND32 hwnd,
940 DWORD style,
941 BOOL32 active )
942 {
943 RECT32 r = *rect;
944 WND *wndPtr = WIN_FindWndPtr( hwnd );
945 char buffer[256];
946
947 if (wndPtr->flags & WIN_MANAGED) return;
948
949 FillRect32( hdc, &r, GetSysColorBrush32(active ? COLOR_ACTIVECAPTION :
950 COLOR_INACTIVECAPTION) );
951
952 if (!hbitmapClose) {
953 if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_CLOSE) )))
954 return;
955 hbitmapMinimize = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_REDUCE) );
956 hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_REDUCED) );
957 hbitmapMaximize = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_ZOOM) );
958 hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_ZOOMD) );
959 hbitmapRestore = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_RESTORE) );
960 hbitmapRestoreD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_RESTORED) );
961 }
962
963 if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME) {
964 HBRUSH32 hbrushOld = SelectObject32(hdc, GetSysColorBrush32(COLOR_WINDOW) );
965 PatBlt32( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
966 PatBlt32( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
967 PatBlt32( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
968 r.left++;
969 r.right--;
970 SelectObject32( hdc, hbrushOld );
971 }
972
973 if (style & WS_SYSMENU) {
974 NC_DrawSysButton95( hwnd, hdc, FALSE );
975 r.left += SYSMETRICS_CXSIZE + 1;
976 }
977 if (style & WS_MAXIMIZEBOX) {
978 NC_DrawMaxButton95( hwnd, hdc, FALSE );
979 r.right -= SYSMETRICS_CXSIZE + 1;
980 }
981 if (style & WS_MINIMIZEBOX) {
982 NC_DrawMinButton95( hwnd, hdc, FALSE );
983 r.right -= SYSMETRICS_CXSIZE + 1;
984 }
985
986 if (GetWindowText32A( hwnd, buffer, sizeof(buffer) )) {
987 if (active) SetTextColor32( hdc, GetSysColor32( COLOR_CAPTIONTEXT ) );
988 else SetTextColor32( hdc, GetSysColor32( COLOR_INACTIVECAPTIONTEXT ) );
989 SetBkMode32( hdc, TRANSPARENT );
990 r.top += NC_CaptionTopNudge - 2;
991 r.left += NC_CaptionLeftNudge;
992 DrawText32A( hdc, buffer, -1, &r, NC_CaptionTextFlags );
993 }
994 }
995
996
997
998 /***********************************************************************
999 * NC_DoNCPaint
1000 *
1001 * Paint the non-client area. clip is currently unused.
1002 */
1003 void NC_DoNCPaint( WND* wndPtr, HRGN32 clip, BOOL32 suppress_menupaint )
1004 {
1005 HDC32 hdc;
1006 RECT32 rect;
1007 BOOL32 active;
1008 HWND32 hwnd = wndPtr->hwndSelf;
1009
1010 if ( wndPtr->dwStyle & WS_MINIMIZE ||
1011 !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1012
1013 active = wndPtr->flags & WIN_NCACTIVATED;
1014
1015 TRACE(nonclient, "%04x %d\n", hwnd, active );
1016
1017 if (!(hdc = GetDCEx32( hwnd, 0, DCX_USESTYLE | DCX_WINDOW ))) return;
1018
1019 if (ExcludeVisRect( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1020 wndPtr->rectClient.top-wndPtr->rectWindow.top,
1021 wndPtr->rectClient.right-wndPtr->rectWindow.left,
1022 wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1023 == NULLREGION)
1024 {
1025 ReleaseDC32( hwnd, hdc );
1026 return;
1027 }
1028
1029 rect.top = rect.left = 0;
1030 rect.right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1031 rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1032
1033 SelectObject32( hdc, GetSysColorPen32(COLOR_WINDOWFRAME) );
1034
1035 if (!(wndPtr->flags & WIN_MANAGED))
1036 {
1037 if ((wndPtr->dwStyle & WS_BORDER) || (wndPtr->dwStyle & WS_DLGFRAME) ||
1038 (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME))
1039 {
1040 GRAPH_DrawRectangle( hdc, 0, 0,
1041 rect.right, rect.bottom, (HPEN32)0 );
1042 InflateRect32( &rect, -1, -1 );
1043 }
1044
1045 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1046 NC_DrawFrame( hdc, &rect, TRUE, active );
1047 else if (wndPtr->dwStyle & WS_THICKFRAME)
1048 NC_DrawFrame(hdc, &rect, FALSE, active );
1049
1050 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1051 {
1052 RECT32 r = rect;
1053 r.bottom = rect.top + SYSMETRICS_CYSIZE;
1054 rect.top += SYSMETRICS_CYSIZE + SYSMETRICS_CYBORDER;
1055 NC_DrawCaption( hdc, &r, hwnd, wndPtr->dwStyle, active );
1056 }
1057 }
1058
1059 if (HAS_MENU(wndPtr))
1060 {
1061 RECT32 r = rect;
1062 r.bottom = rect.top + SYSMETRICS_CYMENU; /* default height */
1063 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
1064 }
1065
1066 /* Draw the scroll-bars */
1067
1068 if (wndPtr->dwStyle & WS_VSCROLL)
1069 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE );
1070 if (wndPtr->dwStyle & WS_HSCROLL)
1071 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE );
1072
1073 /* Draw the "size-box" */
1074
1075 if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1076 {
1077 RECT32 r = rect;
1078 r.left = r.right - SYSMETRICS_CXVSCROLL + 1;
1079 r.top = r.bottom - SYSMETRICS_CYHSCROLL + 1;
1080 FillRect32( hdc, &r, GetSysColorBrush32(COLOR_SCROLLBAR) );
1081 }
1082
1083 ReleaseDC32( hwnd, hdc );
1084 }
1085
1086
1087 /******************************************************************************
1088 *
1089 * void NC_DoNCPaint95(
1090 * WND *wndPtr,
1091 * HRGN32 clip,
1092 * BOOL32 suppress_menupaint )
1093 *
1094 * Paint the non-client area for Win95 windows. The clip region is
1095 * currently ignored.
1096 *
1097 * Bugs
1098 * grep -E -A10 -B5 \(95\)\|\(Bugs\)\|\(FIXME\) windows/nonclient.c \
1099 * misc/tweak.c controls/menu.c # :-)
1100 *
1101 * Revision history
1102 * 03-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1103 * Original implementation
1104 *
1105 *****************************************************************************/
1106
1107 void NC_DoNCPaint95(
1108 WND *wndPtr,
1109 HRGN32 clip,
1110 BOOL32 suppress_menupaint )
1111 {
1112 HDC32 hdc;
1113 RECT32 rect;
1114 BOOL32 active;
1115 HWND32 hwnd = wndPtr->hwndSelf;
1116
1117 if ( wndPtr->dwStyle & WS_MINIMIZE ||
1118 !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1119
1120 active = wndPtr->flags & WIN_NCACTIVATED;
1121
1122 TRACE(nonclient, "%04x %d\n", hwnd, active );
1123
1124 if (!(hdc = GetDCEx32( hwnd, 0, DCX_USESTYLE | DCX_WINDOW ))) return;
1125
1126 if (ExcludeVisRect( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1127 wndPtr->rectClient.top-wndPtr->rectWindow.top,
1128 wndPtr->rectClient.right-wndPtr->rectWindow.left,
1129 wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1130 == NULLREGION)
1131 {
1132 ReleaseDC32( hwnd, hdc );
1133 return;
1134 }
1135
1136 rect.top = rect.left = 0;
1137 rect.right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1138 rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1139
1140 SelectObject32( hdc, GetSysColorPen32(COLOR_WINDOWFRAME) );
1141
1142 if(!(wndPtr->flags & WIN_MANAGED)) {
1143 if((wndPtr->dwStyle & WS_BORDER) || (wndPtr->dwStyle & WS_DLGFRAME) ||
1144 (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)) {
1145 TWEAK_DrawReliefRect95(hdc, &rect);
1146 InflateRect32(&rect, -2, -2);
1147 }
1148
1149 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1150 NC_DrawFrame95( hdc, &rect, TRUE, active );
1151 else if (wndPtr->dwStyle & WS_THICKFRAME)
1152 NC_DrawFrame95(hdc, &rect, FALSE, active );
1153
1154 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1155 {
1156 RECT32 r = rect;
1157 POINT32 sep[2] = { { rect.left,
1158 rect.top + sysMetrics[SM_CYCAPTION] - 2 },
1159 { rect.right,
1160 rect.top + sysMetrics[SM_CYCAPTION] - 2 } };
1161
1162 r.bottom = rect.top + sysMetrics[SM_CYCAPTION] - 2;
1163 rect.top += sysMetrics[SM_CYCAPTION] - 2 + sysMetrics[SM_CYBORDER];
1164 NC_DrawCaption95( hdc, &r, hwnd, wndPtr->dwStyle, active );
1165 GRAPH_DrawLines( hdc, sep, 1, TWEAK_PenC095 );
1166 }
1167 }
1168
1169 if (HAS_MENU(wndPtr))
1170 {
1171 RECT32 r = rect;
1172 r.bottom = rect.top + sysMetrics[SM_CYMENU] - sysMetrics[SM_CYBORDER];
1173 r.top -= sysMetrics[SM_CYBORDER];
1174
1175 TRACE(nonclient, "Calling DrawMenuBar with "
1176 "rect (%d, %d)-(%d, %d)\n", r.left, r.top,
1177 r.right, r.bottom);
1178
1179 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
1180 }
1181
1182 TRACE(nonclient, "After MenuBar, rect is (%d, %d)-(%d, %d).\n",
1183 rect.left, rect.top, rect.right, rect.bottom );
1184
1185 /* Draw the inner frames */
1186 GRAPH_DrawRectangle( hdc, rect.left, rect.top, rect.right - rect.left,
1187 rect.bottom - rect.top, TWEAK_PenC095 );
1188 InflateRect32(&rect, -1, -1);
1189 GRAPH_DrawGenericReliefRect( hdc, &rect, 1, 1, NC_WinShadow95,
1190 NC_WinHighlight95 );
1191
1192 InflateRect32(&rect, -1, -1);
1193
1194 /* Draw the scroll-bars */
1195
1196 if (wndPtr->dwStyle & WS_VSCROLL)
1197 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE );
1198 if (wndPtr->dwStyle & WS_HSCROLL)
1199 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE );
1200
1201 /* Draw the "size-box" */
1202 if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1203 {
1204 RECT32 r = rect;
1205 r.left = r.right - SYSMETRICS_CXVSCROLL + 1;
1206 r.top = r.bottom - SYSMETRICS_CYHSCROLL + 1;
1207 FillRect32( hdc, &r, GetSysColorBrush32(COLOR_SCROLLBAR) );
1208 }
1209
1210 ReleaseDC32( hwnd, hdc );
1211 }
1212
1213
1214
1215
1216 /***********************************************************************
1217 * NC_HandleNCPaint
1218 *
1219 * Handle a WM_NCPAINT message. Called from DefWindowProc().
1220 */
1221 LONG NC_HandleNCPaint( HWND32 hwnd , HRGN32 clip)
1222 {
1223 WND* wndPtr = WIN_FindWndPtr( hwnd );
1224
1225 if( wndPtr && wndPtr->dwStyle & WS_VISIBLE )
1226 {
1227 if( wndPtr->dwStyle & WS_MINIMIZE )
1228 WINPOS_RedrawIconTitle( hwnd );
1229 else if(TWEAK_Win95Look)
1230 NC_DoNCPaint95( wndPtr, clip, FALSE );
1231 else
1232 NC_DoNCPaint( wndPtr, clip, FALSE );
1233 }
1234 return 0;
1235 }
1236
1237
1238 /***********************************************************************
1239 * NC_HandleNCActivate
1240 *
1241 * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1242 */
1243 LONG NC_HandleNCActivate( WND *wndPtr, WPARAM16 wParam )
1244 {
1245 WORD wStateChange;
1246
1247 if( wParam ) wStateChange = !(wndPtr->flags & WIN_NCACTIVATED);
1248 else wStateChange = wndPtr->flags & WIN_NCACTIVATED;
1249
1250 if( wStateChange )
1251 {
1252 if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1253 else wndPtr->flags &= ~WIN_NCACTIVATED;
1254
1255 if( wndPtr->dwStyle & WS_MINIMIZE )
1256 WINPOS_RedrawIconTitle( wndPtr->hwndSelf );
1257 else if( TWEAK_Win95Look )
1258 NC_DoNCPaint95( wndPtr, (HRGN32)1, FALSE );
1259 else
1260 NC_DoNCPaint( wndPtr, (HRGN32)1, FALSE );
1261 }
1262 return TRUE;
1263 }
1264
1265
1266 /***********************************************************************
1267 * NC_HandleSetCursor
1268 *
1269 * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1270 */
1271 LONG NC_HandleSetCursor( HWND32 hwnd, WPARAM16 wParam, LPARAM lParam )
1272 {
1273 if (hwnd != (HWND32)wParam) return 0; /* Don't set the cursor for child windows */
1274
1275 switch(LOWORD(lParam))
1276 {
1277 case HTERROR:
1278 {
1279 WORD msg = HIWORD( lParam );
1280 if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1281 (msg == WM_RBUTTONDOWN))
1282 MessageBeep32(0);
1283 }
1284 break;
1285
1286 case HTCLIENT:
1287 {
1288 WND *wndPtr;
1289 if (!(wndPtr = WIN_FindWndPtr( hwnd ))) break;
1290 if (wndPtr->class->hCursor)
1291 {
1292 SetCursor16( wndPtr->class->hCursor );
1293 return TRUE;
1294 }
1295 else return FALSE;
1296 }
1297
1298 case HTLEFT:
1299 case HTRIGHT:
1300 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZEWE ) );
1301
1302 case HTTOP:
1303 case HTBOTTOM:
1304 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENS ) );
1305
1306 case HTTOPLEFT:
1307 case HTBOTTOMRIGHT:
1308 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENWSE ) );
1309
1310 case HTTOPRIGHT:
1311 case HTBOTTOMLEFT:
1312 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENESW ) );
1313 }
1314
1315 /* Default cursor: arrow */
1316 return (LONG)SetCursor16( LoadCursor16( 0, IDC_ARROW ) );
1317 }
1318
1319 /***********************************************************************
1320 * NC_GetSysPopupPos
1321 */
1322 BOOL32 NC_GetSysPopupPos( WND* wndPtr, RECT32* rect )
1323 {
1324 if( wndPtr->hSysMenu )
1325 {
1326 if( wndPtr->dwStyle & WS_MINIMIZE )
1327 GetWindowRect32( wndPtr->hwndSelf, rect );
1328 else
1329 {
1330 NC_GetInsideRect( wndPtr->hwndSelf, rect );
1331 OffsetRect32( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
1332 if (wndPtr->dwStyle & WS_CHILD)
1333 ClientToScreen32( wndPtr->parent->hwndSelf, (POINT32 *)rect );
1334 rect->right = rect->left + SYSMETRICS_CXSIZE;
1335 rect->bottom = rect->top + SYSMETRICS_CYSIZE;
1336 }
1337 return TRUE;
1338 }
1339 return FALSE;
1340 }
1341
1342 /***********************************************************************
1343 * NC_StartSizeMove
1344 *
1345 * Initialisation of a move or resize, when initiatied from a menu choice.
1346 * Return hit test code for caption or sizing border.
1347 */
1348 static LONG NC_StartSizeMove( WND* wndPtr, WPARAM16 wParam,
1349 POINT16 *capturePoint )
1350 {
1351 LONG hittest = 0;
1352 POINT16 pt;
1353 MSG16 msg;
1354
1355 if ((wParam & 0xfff0) == SC_MOVE)
1356 {
1357 /* Move pointer at the center of the caption */
1358 RECT32 rect;
1359 NC_GetInsideRect( wndPtr->hwndSelf, &rect );
1360 if (wndPtr->dwStyle & WS_SYSMENU)
1361 rect.left += SYSMETRICS_CXSIZE + 1;
1362 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
1363 rect.right -= SYSMETRICS_CXSIZE + 1;
1364 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
1365 rect.right -= SYSMETRICS_CXSIZE + 1;
1366 pt.x = wndPtr->rectWindow.left + (rect.right - rect.left) / 2;
1367 pt.y = wndPtr->rectWindow.top + rect.top + SYSMETRICS_CYSIZE/2;
1368 hittest = HTCAPTION;
1369 *capturePoint = pt;
1370
1371 if (wndPtr->dwStyle & WS_CHILD)
1372 ClientToScreen16( wndPtr->parent->hwndSelf, &pt );
1373 }
1374 else /* SC_SIZE */
1375 {
1376 while(!hittest)
1377 {
1378 MSG_InternalGetMessage( &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE );
1379 switch(msg.message)
1380 {
1381 case WM_MOUSEMOVE:
1382 hittest = NC_HandleNCHitTest( wndPtr->hwndSelf, msg.pt );
1383 pt = msg.pt;
1384 if ((hittest < HTLEFT) || (hittest > HTBOTTOMRIGHT))
1385 hittest = 0;
1386 break;
1387
1388 case WM_LBUTTONUP:
1389 return 0;
1390
1391 case WM_KEYDOWN:
1392 switch(msg.wParam)
1393 {
1394 case VK_UP:
1395 hittest = HTTOP;
1396 pt.x =(wndPtr->rectWindow.left+wndPtr->rectWindow.right)/2;
1397 pt.y = wndPtr->rectWindow.top + SYSMETRICS_CYFRAME / 2;
1398 break;
1399 case VK_DOWN:
1400 hittest = HTBOTTOM;
1401 pt.x =(wndPtr->rectWindow.left+wndPtr->rectWindow.right)/2;
1402 pt.y = wndPtr->rectWindow.bottom - SYSMETRICS_CYFRAME / 2;
1403 break;
1404 case VK_LEFT:
1405 hittest = HTLEFT;
1406 pt.x = wndPtr->rectWindow.left + SYSMETRICS_CXFRAME / 2;
1407 pt.y =(wndPtr->rectWindow.top+wndPtr->rectWindow.bottom)/2;
1408 break;
1409 case VK_RIGHT:
1410 hittest = HTRIGHT;
1411 pt.x = wndPtr->rectWindow.right - SYSMETRICS_CXFRAME / 2;
1412 pt.y =(wndPtr->rectWindow.top+wndPtr->rectWindow.bottom)/2;
1413 break;
1414 case VK_RETURN:
1415 case VK_ESCAPE: return 0;
1416 }
1417 }
1418 }
1419 *capturePoint = pt;
1420 }
1421 SetCursorPos32( pt.x, pt.y );
1422 NC_HandleSetCursor( wndPtr->hwndSelf,
1423 wndPtr->hwndSelf, MAKELONG( hittest, WM_MOUSEMOVE ));
1424 return hittest;
1425 }
1426
1427
1428 /***********************************************************************
1429 * NC_DoSizeMove
1430 *
1431 * Perform SC_MOVE and SC_SIZE commands.
1432 */
1433 static void NC_DoSizeMove( HWND32 hwnd, WORD wParam, POINT16 pt )
1434 {
1435 MSG16 msg;
1436 RECT32 sizingRect, mouseRect;
1437 HDC32 hdc;
1438 LONG hittest = (LONG)(wParam & 0x0f);
1439 HCURSOR16 hDragCursor = 0, hOldCursor = 0;
1440 POINT32 minTrack, maxTrack;
1441 POINT16 capturePoint = pt;
1442 WND * wndPtr = WIN_FindWndPtr( hwnd );
1443 BOOL32 thickframe = HAS_THICKFRAME( wndPtr->dwStyle );
1444 BOOL32 iconic = wndPtr->dwStyle & WS_MINIMIZE;
1445 BOOL32 moved = FALSE;
1446
1447 if (IsZoomed32(hwnd) || !IsWindowVisible32(hwnd) ||
1448 (wndPtr->flags & WIN_MANAGED)) return;
1449
1450 if ((wParam & 0xfff0) == SC_MOVE)
1451 {
1452 if (!(wndPtr->dwStyle & WS_CAPTION)) return;
1453 if (!hittest)
1454 hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
1455 if (!hittest) return;
1456 }
1457 else /* SC_SIZE */
1458 {
1459 if (!thickframe) return;
1460 if ( hittest && hittest != HTSYSMENU ) hittest += 2;
1461 else
1462 {
1463 SetCapture32(hwnd);
1464 hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
1465 if (!hittest)
1466 {
1467 ReleaseCapture();
1468 return;
1469 }
1470 }
1471 }
1472
1473 /* Get min/max info */
1474
1475 WINPOS_GetMinMaxInfo( wndPtr, NULL, NULL, &minTrack, &maxTrack );
1476 sizingRect = wndPtr->rectWindow;
1477 if (wndPtr->dwStyle & WS_CHILD)
1478 GetClientRect32( wndPtr->parent->hwndSelf, &mouseRect );
1479 else
1480 SetRect32(&mouseRect, 0, 0, SYSMETRICS_CXSCREEN, SYSMETRICS_CYSCREEN);
1481 if (ON_LEFT_BORDER(hittest))
1482 {
1483 mouseRect.left = MAX( mouseRect.left, sizingRect.right-maxTrack.x );
1484 mouseRect.right = MIN( mouseRect.right, sizingRect.right-minTrack.x );
1485 }
1486 else if (ON_RIGHT_BORDER(hittest))
1487 {
1488 mouseRect.left = MAX( mouseRect.left, sizingRect.left+minTrack.x );
1489 mouseRect.right = MIN( mouseRect.right, sizingRect.left+maxTrack.x );
1490 }
1491 if (ON_TOP_BORDER(hittest))
1492 {
1493 mouseRect.top = MAX( mouseRect.top, sizingRect.bottom-maxTrack.y );
1494 mouseRect.bottom = MIN( mouseRect.bottom,sizingRect.bottom-minTrack.y);
1495 }
1496 else if (ON_BOTTOM_BORDER(hittest))
1497 {
1498 mouseRect.top = MAX( mouseRect.top, sizingRect.top+minTrack.y );
1499 mouseRect.bottom = MIN( mouseRect.bottom, sizingRect.top+maxTrack.y );
1500 }
1501 SendMessage16( hwnd, WM_ENTERSIZEMOVE, 0, 0 );
1502
1503 if (GetCapture32() != hwnd) SetCapture32( hwnd );
1504
1505 if (wndPtr->dwStyle & WS_CHILD)
1506 {
1507 /* Retrieve a default cache DC (without using the window style) */
1508 hdc = GetDCEx32( wndPtr->parent->hwndSelf, 0, DCX_CACHE );
1509 }
1510 else
1511 { /* Grab the server only when moving top-level windows without desktop */
1512 hdc = GetDC32( 0 );
1513 if (rootWindow == DefaultRootWindow(display)) TSXGrabServer( display );
1514 }
1515
1516 if( iconic ) /* create a cursor for dragging */
1517 {
1518 HICON16 hIcon = (wndPtr->class->hIcon) ? wndPtr->class->hIcon
1519 : (HICON16)SendMessage16( hwnd, WM_QUERYDRAGICON, 0, 0L);
1520 if( hIcon ) hDragCursor = CURSORICON_IconToCursor( hIcon, TRUE );
1521 if( !hDragCursor ) iconic = FALSE;
1522 }
1523
1524 if( !iconic ) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
1525
1526 while(1)
1527 {
1528 int dx = 0, dy = 0;
1529
1530 MSG_InternalGetMessage( &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE );
1531
1532 /* Exit on button-up, Return, or Esc */
1533 if ((msg.message == WM_LBUTTONUP) ||
1534 ((msg.message == WM_KEYDOWN) &&
1535 ((msg.wParam == VK_RETURN) || (msg.wParam == VK_ESCAPE)))) break;
1536
1537 if ((msg.message != WM_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
1538 continue; /* We are not interested in other messages */
1539
1540 pt = msg.pt;
1541 if (wndPtr->dwStyle & WS_CHILD)
1542 ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
1543
1544 if (msg.message == WM_KEYDOWN) switch(msg.wParam)
1545 {
1546 case VK_UP: pt.y -= 8; break;
1547 case VK_DOWN: pt.y += 8; break;
1548 case VK_LEFT: pt.x -= 8; break;
1549 case VK_RIGHT: pt.x += 8; break;
1550 }
1551
1552 pt.x = MAX( pt.x, mouseRect.left );
1553 pt.x = MIN( pt.x, mouseRect.right );
1554 pt.y = MAX( pt.y, mouseRect.top );
1555 pt.y = MIN( pt.y, mouseRect.bottom );
1556
1557 dx = pt.x - capturePoint.x;
1558 dy = pt.y - capturePoint.y;
1559
1560 if (dx || dy)
1561 {
1562 if( !moved )
1563 {
1564 moved = TRUE;
1565 if( iconic ) /* ok, no system popup tracking */
1566 {
1567 hOldCursor = SetCursor32(hDragCursor);
1568 ShowCursor32( TRUE );
1569 WINPOS_ShowIconTitle( wndPtr, FALSE );
1570 }
1571 }
1572
1573 if (msg.message == WM_KEYDOWN) SetCursorPos32( pt.x, pt.y );
1574 else
1575 {
1576 RECT32 newRect = sizingRect;
1577
1578 if (hittest == HTCAPTION) OffsetRect32( &newRect, dx, dy );
1579 if (ON_LEFT_BORDER(hittest)) newRect.left += dx;
1580 else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
1581 if (ON_TOP_BORDER(hittest)) newRect.top += dy;
1582 else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
1583 if( !iconic )
1584 {
1585 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
1586 NC_DrawMovingFrame( hdc, &newRect, thickframe );
1587 }
1588 capturePoint = pt;
1589 sizingRect = newRect;
1590 }
1591 }
1592 }
1593
1594 ReleaseCapture();
1595 if( iconic )
1596 {
1597 if( moved ) /* restore cursors, show icon title later on */
1598 {
1599 ShowCursor32( FALSE );
1600 SetCursor32( hOldCursor );
1601 }
1602 DestroyCursor32( hDragCursor );
1603 }
1604 else
1605 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
1606
1607 if (wndPtr->dwStyle & WS_CHILD)
1608 ReleaseDC32( wndPtr->parent->hwndSelf, hdc );
1609 else
1610 {
1611 ReleaseDC32( 0, hdc );
1612 if (rootWindow == DefaultRootWindow(display)) TSXUngrabServer( display );
1613 }
1614
1615 if (HOOK_IsHooked( WH_CBT ))
1616 {
1617 RECT16* pr = SEGPTR_NEW(RECT16);
1618 if( pr )
1619 {
1620 CONV_RECT32TO16( &sizingRect, pr );
1621 if( HOOK_CallHooks16( WH_CBT, HCBT_MOVESIZE, hwnd,
1622 (LPARAM)SEGPTR_GET(pr)) )
1623 sizingRect = wndPtr->rectWindow;
1624 else
1625 CONV_RECT16TO32( pr, &sizingRect );
1626 SEGPTR_FREE(pr);
1627 }
1628 }
1629 SendMessage16( hwnd, WM_EXITSIZEMOVE, 0, 0 );
1630 SendMessage16( hwnd, WM_SETVISIBLE, !IsIconic16(hwnd), 0L);
1631
1632 if( moved && !((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) )
1633 {
1634 /* NOTE: SWP_NOACTIVATE prevents document window activation in Word 6 */
1635 SetWindowPos32( hwnd, 0, sizingRect.left, sizingRect.top,
1636 sizingRect.right - sizingRect.left,
1637 sizingRect.bottom - sizingRect.top,
1638 ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
1639 }
1640
1641 if( IsWindow32(hwnd) )
1642 if( wndPtr->dwStyle & WS_MINIMIZE )
1643 {
1644 /* Single click brings up the system menu when iconized */
1645
1646 if( !moved )
1647 {
1648 if( wndPtr->dwStyle & WS_SYSMENU )
1649 SendMessage16( hwnd, WM_SYSCOMMAND,
1650 SC_MOUSEMENU + HTSYSMENU, *((LPARAM*)&pt));
1651 }
1652 else WINPOS_ShowIconTitle( wndPtr, TRUE );
1653 }
1654 }
1655
1656
1657 /***********************************************************************
1658 * NC_TrackMinMaxBox
1659 *
1660 * Track a mouse button press on the minimize or maximize box.
1661 */
1662 static void NC_TrackMinMaxBox( HWND32 hwnd, WORD wParam )
1663 {
1664 MSG16 msg;
1665 HDC32 hdc = GetWindowDC32( hwnd );
1666 BOOL32 pressed = TRUE;
1667 void (*paintButton)(HWND32, HDC16, BOOL32);
1668
1669 SetCapture32( hwnd );
1670 if (wParam == HTMINBUTTON)
1671 paintButton = (TWEAK_Win95Look) ? &NC_DrawMinButton95 : &NC_DrawMinButton;
1672 else
1673 paintButton = (TWEAK_Win95Look) ? &NC_DrawMaxButton95 : &NC_DrawMaxButton;
1674
1675 (*paintButton)( hwnd, hdc, TRUE );
1676
1677 do
1678 {
1679 BOOL32 oldstate = pressed;
1680 MSG_InternalGetMessage( &msg, 0, 0, 0, PM_REMOVE, FALSE );
1681
1682 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1683 if (pressed != oldstate)
1684 (*paintButton)( hwnd, hdc, pressed );
1685 } while (msg.message != WM_LBUTTONUP);
1686
1687 (*paintButton)( hwnd, hdc, FALSE );
1688
1689 ReleaseCapture();
1690 ReleaseDC32( hwnd, hdc );
1691 if (!pressed) return;
1692
1693 if (wParam == HTMINBUTTON)
1694 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&msg.pt );
1695 else
1696 SendMessage16( hwnd, WM_SYSCOMMAND,
1697 IsZoomed32(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&msg.pt );
1698 }
1699
1700
1701 /***********************************************************************
1702 * NC_TrackScrollBar
1703 *
1704 * Track a mouse button press on the horizontal or vertical scroll-bar.
1705 */
1706 static void NC_TrackScrollBar( HWND32 hwnd, WPARAM32 wParam, POINT32 pt )
1707 {
1708 MSG16 *msg;
1709 INT32 scrollbar;
1710 WND *wndPtr = WIN_FindWndPtr( hwnd );
1711
1712 if ((wParam & 0xfff0) == SC_HSCROLL)
1713 {
1714 if ((wParam & 0x0f) != HTHSCROLL) return;
1715 scrollbar = SB_HORZ;
1716 }
1717 else /* SC_VSCROLL */
1718 {
1719 if ((wParam & 0x0f) != HTVSCROLL) return;
1720 scrollbar = SB_VERT;
1721 }
1722
1723 if (!(msg = SEGPTR_NEW(MSG16))) return;
1724 pt.x -= wndPtr->rectWindow.left;
1725 pt.y -= wndPtr->rectWindow.top;
1726 SetCapture32( hwnd );
1727 SCROLL_HandleScrollEvent( hwnd, scrollbar, WM_LBUTTONDOWN, pt );
1728
1729 do
1730 {
1731 GetMessage16( SEGPTR_GET(msg), 0, 0, 0 );
1732 switch(msg->message)
1733 {
1734 case WM_LBUTTONUP:
1735 case WM_MOUSEMOVE:
1736 case WM_SYSTIMER:
1737 pt.x = LOWORD(msg->lParam) + wndPtr->rectClient.left -
1738 wndPtr->rectWindow.left;
1739 pt.y = HIWORD(msg->lParam) + wndPtr->rectClient.top -
1740 wndPtr->rectWindow.top;
1741 SCROLL_HandleScrollEvent( hwnd, scrollbar, msg->message, pt );
1742 break;
1743 default:
1744 TranslateMessage16( msg );
1745 DispatchMessage16( msg );
1746 break;
1747 }
1748 if (!IsWindow32( hwnd ))
1749 {
1750 ReleaseCapture();
1751 break;
1752 }
1753 } while (msg->message != WM_LBUTTONUP);
1754 SEGPTR_FREE(msg);
1755 }
1756
1757 /***********************************************************************
1758 * NC_HandleNCLButtonDown
1759 *
1760 * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
1761 */
1762 LONG NC_HandleNCLButtonDown( WND* pWnd, WPARAM16 wParam, LPARAM lParam )
1763 {
1764 HWND32 hwnd = pWnd->hwndSelf;
1765
1766 switch(wParam) /* Hit test */
1767 {
1768 case HTCAPTION:
1769 hwnd = WIN_GetTopParent(hwnd);
1770
1771 if( WINPOS_SetActiveWindow(hwnd, TRUE, TRUE) || (GetActiveWindow32() == hwnd) )
1772 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
1773 break;
1774
1775 case HTSYSMENU:
1776 if( pWnd->dwStyle & WS_SYSMENU )
1777 {
1778 if( !(pWnd->dwStyle & WS_MINIMIZE) )
1779 {
1780 HDC32 hDC = GetWindowDC32(hwnd);
1781 if( TWEAK_Win95Look)
1782 NC_DrawSysButton95( hwnd, hDC, TRUE );
1783 else
1784 NC_DrawSysButton( hwnd, hDC, TRUE );
1785 ReleaseDC32( hwnd, hDC );
1786 }
1787 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
1788 }
1789 break;
1790
1791 case HTMENU:
1792 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
1793 break;
1794
1795 case HTHSCROLL:
1796 SendMessage16( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
1797 break;
1798
1799 case HTVSCROLL:
1800 SendMessage16( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
1801 break;
1802
1803 case HTMINBUTTON:
1804 case HTMAXBUTTON:
1805 NC_TrackMinMaxBox( hwnd, wParam );
1806 break;
1807
1808 case HTLEFT:
1809 case HTRIGHT:
1810 case HTTOP:
1811 case HTTOPLEFT:
1812 case HTTOPRIGHT:
1813 case HTBOTTOM:
1814 case HTBOTTOMLEFT:
1815 case HTBOTTOMRIGHT:
1816 /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */
1817 SendMessage16( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - 2, lParam);
1818 break;
1819
1820 case HTBORDER:
1821 break;
1822 }
1823 return 0;
1824 }
1825
1826
1827 /***********************************************************************
1828 * NC_HandleNCLButtonDblClk
1829 *
1830 * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
1831 */
1832 LONG NC_HandleNCLButtonDblClk( WND *pWnd, WPARAM16 wParam, LPARAM lParam )
1833 {
1834 /*
1835 * if this is an icon, send a restore since we are handling
1836 * a double click
1837 */
1838 if (pWnd->dwStyle & WS_MINIMIZE)
1839 {
1840 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_RESTORE, lParam );
1841 return 0;
1842 }
1843
1844 switch(wParam) /* Hit test */
1845 {
1846 case HTCAPTION:
1847 /* stop processing if WS_MAXIMIZEBOX is missing */
1848 if (pWnd->dwStyle & WS_MAXIMIZEBOX)
1849 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND,
1850 (pWnd->dwStyle & WS_MAXIMIZE) ? SC_RESTORE : SC_MAXIMIZE,
1851 lParam );
1852 break;
1853
1854 case HTSYSMENU:
1855 if (!(pWnd->class->style & CS_NOCLOSE))
1856 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_CLOSE, lParam );
1857 break;
1858
1859 case HTHSCROLL:
1860 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL,
1861 lParam );
1862 break;
1863
1864 case HTVSCROLL:
1865 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL,
1866 lParam );
1867 break;
1868 }
1869 return 0;
1870 }
1871
1872
1873 /***********************************************************************
1874 * NC_HandleSysCommand
1875 *
1876 * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
1877 */
1878 LONG NC_HandleSysCommand( HWND32 hwnd, WPARAM16 wParam, POINT16 pt )
1879 {
1880 WND *wndPtr = WIN_FindWndPtr( hwnd );
1881 POINT32 pt32;
1882 UINT16 uCommand = wParam & 0xFFF0;
1883
1884 TRACE(nonclient, "Handling WM_SYSCOMMAND %x %d,%d\n",
1885 wParam, pt.x, pt.y );
1886
1887 if (wndPtr->dwStyle & WS_CHILD && uCommand != SC_KEYMENU )
1888 ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
1889
1890 switch (uCommand)
1891 {
1892 case SC_SIZE:
1893 case SC_MOVE:
1894 NC_DoSizeMove( hwnd, wParam, pt );
1895 break;
1896
1897 case SC_MINIMIZE:
1898 ShowWindow32( hwnd, SW_MINIMIZE );
1899 break;
1900
1901 case SC_MAXIMIZE:
1902 ShowWindow32( hwnd, SW_MAXIMIZE );
1903 break;
1904
1905 case SC_RESTORE:
1906 ShowWindow32( hwnd, SW_RESTORE );
1907 break;
1908
1909 case SC_CLOSE:
1910 return SendMessage16( hwnd, WM_CLOSE, 0, 0 );
1911
1912 case SC_VSCROLL:
1913 case SC_HSCROLL:
1914 CONV_POINT16TO32( &pt, &pt32 );
1915 NC_TrackScrollBar( hwnd, wParam, pt32 );
1916 break;
1917
1918 case SC_MOUSEMENU:
1919 CONV_POINT16TO32( &pt, &pt32 );
1920 MENU_TrackMouseMenuBar( wndPtr, wParam & 0x000F, pt32 );
1921 break;
1922
1923 case SC_KEYMENU:
1924 MENU_TrackKbdMenuBar( wndPtr , wParam , pt.x );
1925 break;
1926
1927 case SC_TASKLIST:
1928 WinExec32( "taskman.exe", SW_SHOWNORMAL );
1929 break;
1930
1931 case SC_SCREENSAVE:
1932 if (wParam == SC_ABOUTWINE)
1933 ShellAbout32A(hwnd,"Wine", WINE_RELEASE_INFO, 0);
1934 break;
1935
1936 case SC_HOTKEY:
1937 case SC_ARRANGE:
1938 case SC_NEXTWINDOW:
1939 case SC_PREVWINDOW:
1940 /* FIXME: unimplemented */
1941 break;
1942 }
1943 return 0;
1944 }
Windows API implementation