?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Authors: Adrian Thurston <adriant@corel.ca>, Zygo Blaxell <zblaxell@corel.ca>
[wine.git] / windows / mdi.c
blobf6ea50bbe66ebb26472da4f05a5552bfd21b7a1e
1 /* MDI.C
2 *
3 * Copyright 1994, Bob Amstadt
4 * 1995,1996 Alex Korobka
5 *
6 * This file contains routines to support MDI features.
7 *
8 * Notes: Fairly complete implementation. Any volunteers for
9 * "More windows..." stuff?
10 *
11 * Also, Excel and WinWord do _not_ use MDI so if you're trying
12 * to fix them look elsewhere.
13 */
14
15 #include <stdlib.h>
16 #include <string.h>
17 #include <math.h>
18 #include "windows.h"
19 #include "win.h"
20 #include "heap.h"
21 #include "nonclient.h"
22 #include "mdi.h"
23 #include "user.h"
24 #include "menu.h"
25 #include "resource.h"
26 #include "struct32.h"
27 #include "sysmetrics.h"
28 #include "debug.h"
29
30 #define MDIF_NEEDUPDATE 0x0001
31
32 static HBITMAP16 hBmpClose = 0;
33 static HBITMAP16 hBmpRestore = 0;
34
35 INT32 SCROLL_SetNCSbState(WND*,int,int,int,int,int,int);
36
37 /* ----------------- declarations ----------------- */
38 static void MDI_UpdateFrameText(WND *, HWND32, BOOL32, LPCSTR);
39 static BOOL32 MDI_AugmentFrameMenu(MDICLIENTINFO*, WND *, HWND32);
40 static BOOL32 MDI_RestoreFrameMenu(WND *, HWND32);
41
42 static LONG MDI_ChildActivate( WND*, HWND32 );
43
44 /* -------- Miscellaneous service functions ----------
45 *
46 * MDI_GetChildByID
47 */
48
49 static HWND32 MDI_GetChildByID(WND* wndPtr, INT32 id)
50 {
51 for (wndPtr = wndPtr->child; wndPtr; wndPtr = wndPtr->next)
52 if (wndPtr->wIDmenu == id) return wndPtr->hwndSelf;
53 return 0;
54 }
55
56 static void MDI_PostUpdate(HWND32 hwnd, MDICLIENTINFO* ci, WORD recalc)
57 {
58 if( !(ci->mdiFlags & MDIF_NEEDUPDATE) )
59 {
60 ci->mdiFlags |= MDIF_NEEDUPDATE;
61 PostMessage32A( hwnd, WM_MDICALCCHILDSCROLL, 0, 0);
62 }
63 ci->sbRecalc = recalc;
64 }
65
66 /**********************************************************************
67 * MDI_MenuModifyItem
68 */
69 static BOOL32 MDI_MenuModifyItem(WND* clientWnd, HWND32 hWndChild )
70 {
71 char buffer[128];
72 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
73 WND *wndPtr = WIN_FindWndPtr(hWndChild);
74 UINT32 n = sprintf(buffer, "%d ",
75 wndPtr->wIDmenu - clientInfo->idFirstChild + 1);
76 BOOL32 bRet = 0;
77
78 if( !clientInfo->hWindowMenu ) return 0;
79
80 if (wndPtr->text) lstrcpyn32A(buffer + n, wndPtr->text, sizeof(buffer) - n );
81
82 n = GetMenuState32(clientInfo->hWindowMenu,wndPtr->wIDmenu ,MF_BYCOMMAND);
83 bRet = ModifyMenu32A(clientInfo->hWindowMenu , wndPtr->wIDmenu,
84 MF_BYCOMMAND | MF_STRING, wndPtr->wIDmenu, buffer );
85 CheckMenuItem32(clientInfo->hWindowMenu ,wndPtr->wIDmenu , n & MF_CHECKED);
86 return bRet;
87 }
88
89 /**********************************************************************
90 * MDI_MenuDeleteItem
91 */
92 static BOOL32 MDI_MenuDeleteItem(WND* clientWnd, HWND32 hWndChild )
93 {
94 char buffer[128];
95 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
96 WND *wndPtr = WIN_FindWndPtr(hWndChild);
97 UINT32 index = 0,id,n;
98
99 if( !clientInfo->nActiveChildren ||
100 !clientInfo->hWindowMenu ) return 0;
101
102 id = wndPtr->wIDmenu;
103 DeleteMenu32(clientInfo->hWindowMenu,id,MF_BYCOMMAND);
104
105 /* walk the rest of MDI children to prevent gaps in the id
106 * sequence and in the menu child list */
107
108 for( index = id+1; index <= clientInfo->nActiveChildren +
109 clientInfo->idFirstChild; index++ )
110 {
111 wndPtr = WIN_FindWndPtr(MDI_GetChildByID(clientWnd,index));
112 if( !wndPtr )
113 {
114 TRACE(mdi,"no window for id=%i\n",index);
115 continue;
116 }
117
118 /* set correct id */
119 wndPtr->wIDmenu--;
120
121 n = sprintf(buffer, "%d ",index - clientInfo->idFirstChild);
122 if (wndPtr->text)
123 lstrcpyn32A(buffer + n, wndPtr->text, sizeof(buffer) - n );
124
125 /* change menu */
126 ModifyMenu32A(clientInfo->hWindowMenu ,index ,MF_BYCOMMAND | MF_STRING,
127 index - 1 , buffer );
128 }
129 return 1;
130 }
131
132 /**********************************************************************
133 * MDI_GetWindow
134 *
135 * returns "activateable" child different from the current or zero
136 */
137 static HWND32 MDI_GetWindow(WND *clientWnd, HWND32 hWnd, BOOL32 bNext,
138 DWORD dwStyleMask )
139 {
140 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
141 WND *wndPtr, *pWnd, *pWndLast = NULL;
142
143 dwStyleMask |= WS_DISABLED | WS_VISIBLE;
144 if( !hWnd ) hWnd = clientInfo->hwndActiveChild;
145
146 if( !(wndPtr = WIN_FindWndPtr(hWnd)) ) return 0;
147
148 for ( pWnd = wndPtr->next; ; pWnd = pWnd->next )
149 {
150 if (!pWnd ) pWnd = wndPtr->parent->child;
151
152 if ( pWnd == wndPtr ) break; /* went full circle */
153
154 if (!pWnd->owner && (pWnd->dwStyle & dwStyleMask) == WS_VISIBLE )
155 {
156 pWndLast = pWnd;
157 if ( bNext ) break;
158 }
159 }
160 return pWndLast ? pWndLast->hwndSelf : 0;
161 }
162
163 /**********************************************************************
164 * MDI_CalcDefaultChildPos
165 *
166 * It seems that the default height is about 2/3 of the client rect
167 */
168 static void MDI_CalcDefaultChildPos( WND* w, WORD n, LPPOINT32 lpPos,
169 INT32 delta)
170 {
171 INT32 nstagger;
172 RECT32 rect = w->rectClient;
173 INT32 spacing = GetSystemMetrics32(SM_CYCAPTION) +
174 GetSystemMetrics32(SM_CYFRAME) - 1;
175
176 if( rect.bottom - rect.top - delta >= spacing )
177 rect.bottom -= delta;
178
179 nstagger = (rect.bottom - rect.top)/(3 * spacing);
180 lpPos[1].x = (rect.right - rect.left - nstagger * spacing);
181 lpPos[1].y = (rect.bottom - rect.top - nstagger * spacing);
182 lpPos[0].x = lpPos[0].y = spacing * (n%(nstagger+1));
183 }
184
185 /**********************************************************************
186 * MDISetMenu
187 */
188 static LRESULT MDISetMenu( HWND32 hwnd, HMENU32 hmenuFrame,
189 HMENU32 hmenuWindow)
190 {
191 WND *w = WIN_FindWndPtr(hwnd);
192 MDICLIENTINFO *ci;
193 HWND32 hwndFrame = GetParent32(hwnd);
194 HMENU32 oldFrameMenu = GetMenu32(hwndFrame);
195
196 TRACE(mdi, "%04x %04x %04x\n",
197 hwnd, hmenuFrame, hmenuWindow);
198
199 ci = (MDICLIENTINFO *) w->wExtra;
200
201 if( ci->hwndChildMaximized && hmenuFrame && hmenuFrame!=oldFrameMenu )
202 MDI_RestoreFrameMenu(w->parent, ci->hwndChildMaximized );
203
204 if( hmenuWindow && hmenuWindow!=ci->hWindowMenu )
205 {
206 /* delete menu items from ci->hWindowMenu
207 * and add them to hmenuWindow */
208
209 INT32 i = GetMenuItemCount32(ci->hWindowMenu) - 1;
210 INT32 pos = GetMenuItemCount32(hmenuWindow) + 1;
211
212 AppendMenu32A( hmenuWindow, MF_SEPARATOR, 0, NULL);
213
214 if( ci->nActiveChildren )
215 {
216 INT32 j = i - ci->nActiveChildren + 1;
217 char buffer[100];
218 UINT32 id,state;
219
220 for( ; i >= j ; i-- )
221 {
222 id = GetMenuItemID32(ci->hWindowMenu,i );
223 state = GetMenuState32(ci->hWindowMenu,i,MF_BYPOSITION);
224
225 GetMenuString32A(ci->hWindowMenu, i, buffer, 100, MF_BYPOSITION);
226
227 DeleteMenu32(ci->hWindowMenu, i , MF_BYPOSITION);
228 InsertMenu32A(hmenuWindow, pos, MF_BYPOSITION | MF_STRING,
229 id, buffer);
230 CheckMenuItem32(hmenuWindow ,pos , MF_BYPOSITION | (state & MF_CHECKED));
231 }
232 }
233
234 /* remove separator */
235 DeleteMenu32(ci->hWindowMenu, i, MF_BYPOSITION);
236
237 ci->hWindowMenu = hmenuWindow;
238 }
239
240 if( hmenuFrame && hmenuFrame!=oldFrameMenu)
241 {
242 SetMenu32(hwndFrame, hmenuFrame);
243 if( ci->hwndChildMaximized )
244 MDI_AugmentFrameMenu(ci, w->parent, ci->hwndChildMaximized );
245 return oldFrameMenu;
246 }
247 return 0;
248 }
249
250 /**********************************************************************
251 * MDIRefreshMenu
252 */
253 static LRESULT MDIRefreshMenu( HWND32 hwnd, HMENU32 hmenuFrame,
254 HMENU32 hmenuWindow)
255 {
256 HWND32 hwndFrame = GetParent32(hwnd);
257 HMENU32 oldFrameMenu = GetMenu32(hwndFrame);
258
259 TRACE(mdi, "%04x %04x %04x\n",
260 hwnd, hmenuFrame, hmenuWindow);
261
262 FIXME(mdi,"partially function stub\n");
263
264 return oldFrameMenu;
265 }
266
267
268 /* ------------------ MDI child window functions ---------------------- */
269
270
271 /**********************************************************************
272 * MDICreateChild
273 */
274 static HWND32 MDICreateChild( WND *w, MDICLIENTINFO *ci, HWND32 parent,
275 LPMDICREATESTRUCT32A cs )
276 {
277 POINT32 pos[2];
278 DWORD style = cs->style | (WS_CHILD | WS_CLIPSIBLINGS);
279 HWND32 hwnd, hwndMax = 0;
280 WORD wIDmenu = ci->idFirstChild + ci->nActiveChildren;
281 char lpstrDef[]="junk!";
282
283 TRACE(mdi, "origin %i,%i - dim %i,%i, style %08x\n",
284 cs->x, cs->y, cs->cx, cs->cy, (unsigned)cs->style);
285 /* calculate placement */
286 MDI_CalcDefaultChildPos(w, ci->nTotalCreated++, pos, 0);
287
288 if (cs->cx == CW_USEDEFAULT32 || !cs->cx) cs->cx = pos[1].x;
289 if (cs->cy == CW_USEDEFAULT32 || !cs->cy) cs->cy = pos[1].y;
290
291 if( cs->x == CW_USEDEFAULT32 )
292 {
293 cs->x = pos[0].x;
294 cs->y = pos[0].y;
295 }
296
297 /* restore current maximized child */
298 if( style & WS_VISIBLE && ci->hwndChildMaximized )
299 {
300 if( style & WS_MAXIMIZE )
301 SendMessage32A(w->hwndSelf, WM_SETREDRAW, FALSE, 0L );
302 hwndMax = ci->hwndChildMaximized;
303 ShowWindow32( hwndMax, SW_SHOWNOACTIVATE );
304 if( style & WS_MAXIMIZE )
305 SendMessage32A(w->hwndSelf, WM_SETREDRAW, TRUE, 0L );
306 }
307
308 /* this menu is needed to set a check mark in MDI_ChildActivate */
309 AppendMenu32A(ci->hWindowMenu ,MF_STRING ,wIDmenu, lpstrDef );
310
311 ci->nActiveChildren++;
312
313 /* fix window style */
314 if( !(w->dwStyle & MDIS_ALLCHILDSTYLES) )
315 {
316 style &= (WS_CHILD | WS_CLIPSIBLINGS | WS_MINIMIZE | WS_MAXIMIZE |
317 WS_CLIPCHILDREN | WS_DISABLED | WS_VSCROLL | WS_HSCROLL );
318 style |= (WS_VISIBLE | WS_OVERLAPPEDWINDOW);
319 }
320
321 if( w->flags & WIN_ISWIN32 )
322 {
323 hwnd = CreateWindow32A( cs->szClass, cs->szTitle, style,
324 cs->x, cs->y, cs->cx, cs->cy, parent,
325 (HMENU16)wIDmenu, cs->hOwner, cs );
326 }
327 else
328 {
329 MDICREATESTRUCT16 *cs16;
330 LPSTR title, cls;
331
332 cs16 = SEGPTR_NEW(MDICREATESTRUCT16);
333 STRUCT32_MDICREATESTRUCT32Ato16( cs, cs16 );
334 title = SEGPTR_STRDUP( cs->szTitle );
335 cls = SEGPTR_STRDUP( cs->szClass );
336 cs16->szTitle = SEGPTR_GET(title);
337 cs16->szClass = SEGPTR_GET(cls);
338
339 hwnd = CreateWindow16( cs->szClass, cs->szTitle, style,
340 cs16->x, cs16->y, cs16->cx, cs16->cy, parent,
341 (HMENU32)wIDmenu, cs16->hOwner,
342 (LPVOID)SEGPTR_GET(cs16) );
343 SEGPTR_FREE( title );
344 SEGPTR_FREE( cls );
345 SEGPTR_FREE( cs16 );
346 }
347
348 /* MDI windows are WS_CHILD so they won't be activated by CreateWindow */
349
350 if (hwnd)
351 {
352 WND* wnd = WIN_FindWndPtr( hwnd );
353
354 MDI_MenuModifyItem(w ,hwnd);
355 if( wnd->dwStyle & WS_MINIMIZE && ci->hwndActiveChild )
356 ShowWindow32( hwnd, SW_SHOWMINNOACTIVE );
357 else
358 {
359 /* WS_VISIBLE is clear if a) the MDI client has
360 * MDIS_ALLCHILDSTYLES style and 2) the flag is cleared in the
361 * MDICreateStruct. If so the created window is not shown nor
362 * activated.
363 */
364 int showflag=wnd->dwStyle & WS_VISIBLE;
365 /* clear visible flag, otherwise SetWindoPos32 ignores
366 * the SWP_SHOWWINDOW command.
367 */
368 wnd->dwStyle &= ~WS_VISIBLE;
369 if(showflag){
370 SetWindowPos32( hwnd, 0, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE );
371
372 /* Set maximized state here in case hwnd didn't receive WM_SIZE
373 * during CreateWindow - bad!
374 */
375
376 if((wnd->dwStyle & WS_MAXIMIZE) && !ci->hwndChildMaximized )
377 {
378 ci->hwndChildMaximized = wnd->hwndSelf;
379 MDI_AugmentFrameMenu( ci, w->parent, hwnd );
380 MDI_UpdateFrameText( w->parent, ci->self, MDI_REPAINTFRAME, NULL );
381 }
382 }else
383 /* needed, harmless ? */
384 SetWindowPos32( hwnd, 0, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE );
385
386 }
387 TRACE(mdi, "created child - %04x\n",hwnd);
388 }
389 else
390 {
391 ci->nActiveChildren--;
392 DeleteMenu32(ci->hWindowMenu,wIDmenu,MF_BYCOMMAND);
393 if( IsWindow32(hwndMax) )
394 ShowWindow32(hwndMax, SW_SHOWMAXIMIZED);
395 }
396
397 return hwnd;
398 }
399
400 /**********************************************************************
401 * MDI_ChildGetMinMaxInfo
402 *
403 * Note: The rule here is that client rect of the maximized MDI child
404 * is equal to the client rect of the MDI client window.
405 */
406 static void MDI_ChildGetMinMaxInfo( WND* clientWnd, HWND32 hwnd,
407 MINMAXINFO16* lpMinMax )
408 {
409 WND* childWnd = WIN_FindWndPtr(hwnd);
410 RECT32 rect = clientWnd->rectClient;
411
412 MapWindowPoints32( clientWnd->parent->hwndSelf,
413 ((MDICLIENTINFO*)clientWnd->wExtra)->self, (LPPOINT32)&rect, 2);
414 AdjustWindowRectEx32( &rect, childWnd->dwStyle, 0, childWnd->dwExStyle );
415
416 lpMinMax->ptMaxSize.x = rect.right -= rect.left;
417 lpMinMax->ptMaxSize.y = rect.bottom -= rect.top;
418
419 lpMinMax->ptMaxPosition.x = rect.left;
420 lpMinMax->ptMaxPosition.y = rect.top;
421
422 TRACE(mdi,"max rect (%i,%i - %i, %i)\n",
423 rect.left,rect.top,rect.right,rect.bottom);
424 }
425
426 /**********************************************************************
427 * MDI_SwitchActiveChild
428 *
429 * Note: SetWindowPos sends WM_CHILDACTIVATE to the child window that is
430 * being activated
431 */
432 static void MDI_SwitchActiveChild( HWND32 clientHwnd, HWND32 childHwnd,
433 BOOL32 bNextWindow )
434 {
435 WND *w = WIN_FindWndPtr(clientHwnd);
436 HWND32 hwndTo = 0;
437 HWND32 hwndPrev = 0;
438 MDICLIENTINFO *ci;
439
440 hwndTo = MDI_GetWindow(w, childHwnd, bNextWindow, 0);
441
442 ci = (MDICLIENTINFO *) w->wExtra;
443
444 TRACE(mdi, "from %04x, to %04x\n",childHwnd,hwndTo);
445
446 if ( !hwndTo ) return; /* no window to switch to */
447
448 hwndPrev = ci->hwndActiveChild;
449
450 if ( hwndTo != hwndPrev )
451 {
452 BOOL32 bOptimize = 0;
453
454 if( ci->hwndChildMaximized )
455 {
456 bOptimize = 1;
457 w->dwStyle &= ~WS_VISIBLE;
458 }
459
460 SetWindowPos32( hwndTo, HWND_TOP, 0, 0, 0, 0,
461 SWP_NOMOVE | SWP_NOSIZE );
462
463 if( bNextWindow && hwndPrev )
464 SetWindowPos32( hwndPrev, HWND_BOTTOM, 0, 0, 0, 0,
465 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE );
466 if( bOptimize )
467 ShowWindow32( clientHwnd, SW_SHOW );
468 }
469 }
470
471
472 /**********************************************************************
473 * MDIDestroyChild
474 */
475 static LRESULT MDIDestroyChild( WND *w_parent, MDICLIENTINFO *ci,
476 HWND32 parent, HWND32 child,
477 BOOL32 flagDestroy )
478 {
479 WND *childPtr = WIN_FindWndPtr(child);
480
481 if( childPtr )
482 {
483 if( child == ci->hwndActiveChild )
484 {
485 MDI_SwitchActiveChild(parent, child, TRUE);
486
487 if( child == ci->hwndActiveChild )
488 {
489 ShowWindow32( child, SW_HIDE);
490 if( child == ci->hwndChildMaximized )
491 {
492 MDI_RestoreFrameMenu(w_parent->parent, child);
493 ci->hwndChildMaximized = 0;
494 MDI_UpdateFrameText(w_parent->parent,parent,TRUE,NULL);
495 }
496
497 MDI_ChildActivate(w_parent, 0);
498 }
499 MDI_MenuDeleteItem(w_parent, child);
500 }
501
502 ci->nActiveChildren--;
503
504 TRACE(mdi,"child destroyed - %04x\n",child);
505
506 if (flagDestroy)
507 {
508 MDI_PostUpdate(GetParent32(child), ci, SB_BOTH+1);
509 DestroyWindow32(child);
510 }
511 }
512
513 return 0;
514 }
515
516
517 /**********************************************************************
518 * MDI_ChildActivate
519 *
520 * Note: hWndChild is NULL when last child is being destroyed
521 */
522 static LONG MDI_ChildActivate( WND *clientPtr, HWND32 hWndChild )
523 {
524 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientPtr->wExtra;
525 HWND32 prevActiveWnd = clientInfo->hwndActiveChild;
526 WND *wndPtr = WIN_FindWndPtr( hWndChild );
527 WND *wndPrev = WIN_FindWndPtr( prevActiveWnd );
528 BOOL32 isActiveFrameWnd = 0;
529
530 if( hWndChild == prevActiveWnd ) return 0L;
531
532 if( wndPtr )
533 if( wndPtr->dwStyle & WS_DISABLED ) return 0L;
534
535 TRACE(mdi,"%04x\n", hWndChild);
536
537 if( GetActiveWindow32() == clientPtr->parent->hwndSelf )
538 isActiveFrameWnd = TRUE;
539
540 /* deactivate prev. active child */
541 if( wndPrev )
542 {
543 wndPrev->dwStyle |= WS_SYSMENU;
544 SendMessage32A( prevActiveWnd, WM_NCACTIVATE, FALSE, 0L );
545 SendMessage32A( prevActiveWnd, WM_MDIACTIVATE, (WPARAM32)prevActiveWnd,
546 (LPARAM)hWndChild);
547 /* uncheck menu item */
548 if( clientInfo->hWindowMenu )
549 CheckMenuItem32( clientInfo->hWindowMenu,
550 wndPrev->wIDmenu, 0);
551 }
552
553 /* set appearance */
554 if( clientInfo->hwndChildMaximized )
555 {
556 if( clientInfo->hwndChildMaximized != hWndChild ) {
557 if( hWndChild ) {
558 clientInfo->hwndActiveChild = hWndChild;
559 ShowWindow32( hWndChild, SW_SHOWMAXIMIZED);
560 } else
561 ShowWindow32( clientInfo->hwndActiveChild, SW_SHOWNORMAL );
562 }
563 }
564
565 clientInfo->hwndActiveChild = hWndChild;
566
567 /* check if we have any children left */
568 if( !hWndChild )
569 {
570 if( isActiveFrameWnd )
571 SetFocus32( clientInfo->self );
572 return 0;
573 }
574
575 /* check menu item */
576 if( clientInfo->hWindowMenu )
577 CheckMenuItem32( clientInfo->hWindowMenu,
578 wndPtr->wIDmenu, MF_CHECKED);
579
580 /* bring active child to the top */
581 SetWindowPos32( hWndChild, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
582
583 if( isActiveFrameWnd )
584 {
585 SendMessage32A( hWndChild, WM_NCACTIVATE, TRUE, 0L);
586 if( GetFocus32() == clientInfo->self )
587 SendMessage32A( clientInfo->self, WM_SETFOCUS,
588 (WPARAM32)clientInfo->self, 0L );
589 else
590 SetFocus32( clientInfo->self );
591 }
592 SendMessage32A( hWndChild, WM_MDIACTIVATE, (WPARAM32)prevActiveWnd,
593 (LPARAM)hWndChild );
594 return 1;
595 }
596
597 /* -------------------- MDI client window functions ------------------- */
598
599 /**********************************************************************
600 * CreateMDIMenuBitmap
601 */
602 static HBITMAP16 CreateMDIMenuBitmap(void)
603 {
604 HDC32 hDCSrc = CreateCompatibleDC32(0);
605 HDC32 hDCDest = CreateCompatibleDC32(hDCSrc);
606 HBITMAP16 hbClose = LoadBitmap16(0, MAKEINTRESOURCE16(OBM_CLOSE) );
607 HBITMAP16 hbCopy;
608 HANDLE16 hobjSrc, hobjDest;
609
610 hobjSrc = SelectObject32(hDCSrc, hbClose);
611 hbCopy = CreateCompatibleBitmap32(hDCSrc,SYSMETRICS_CXSIZE,SYSMETRICS_CYSIZE);
612 hobjDest = SelectObject32(hDCDest, hbCopy);
613
614 BitBlt32(hDCDest, 0, 0, SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
615 hDCSrc, SYSMETRICS_CXSIZE, 0, SRCCOPY);
616
617 SelectObject32(hDCSrc, hobjSrc);
618 DeleteObject32(hbClose);
619 DeleteDC32(hDCSrc);
620
621 hobjSrc = SelectObject32( hDCDest, GetStockObject32(BLACK_PEN) );
622
623 MoveToEx32( hDCDest, SYSMETRICS_CXSIZE - 1, 0, NULL );
624 LineTo32( hDCDest, SYSMETRICS_CXSIZE - 1, SYSMETRICS_CYSIZE - 1);
625
626 SelectObject32(hDCDest, hobjSrc );
627 SelectObject32(hDCDest, hobjDest);
628 DeleteDC32(hDCDest);
629
630 return hbCopy;
631 }
632
633 /**********************************************************************
634 * MDICascade
635 */
636 static LONG MDICascade(WND* clientWnd, MDICLIENTINFO *ci)
637 {
638 WND** ppWnd;
639 UINT32 total;
640
641 if (ci->hwndChildMaximized)
642 SendMessage32A( clientWnd->hwndSelf, WM_MDIRESTORE,
643 (WPARAM32)ci->hwndChildMaximized, 0);
644
645 if (ci->nActiveChildren == 0) return 0;
646
647 if ((ppWnd = WIN_BuildWinArray(clientWnd, BWA_SKIPHIDDEN | BWA_SKIPOWNED |
648 BWA_SKIPICONIC, &total)))
649 {
650 WND** heapPtr = ppWnd;
651 if( total )
652 {
653 INT32 delta = 0, n = 0;
654 POINT32 pos[2];
655 if( total < ci->nActiveChildren )
656 delta = SYSMETRICS_CYICONSPACING + SYSMETRICS_CYICON;
657
658 /* walk the list (backwards) and move windows */
659 while (*ppWnd) ppWnd++;
660 while (ppWnd != heapPtr)
661 {
662 ppWnd--;
663 TRACE(mdi, "move %04x to (%d,%d) size [%d,%d]\n",
664 (*ppWnd)->hwndSelf, pos[0].x, pos[0].y, pos[1].x, pos[1].y);
665
666 MDI_CalcDefaultChildPos(clientWnd, n++, pos, delta);
667 SetWindowPos32( (*ppWnd)->hwndSelf, 0, pos[0].x, pos[0].y,
668 pos[1].x, pos[1].y,
669 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
670 }
671 }
672 HeapFree( SystemHeap, 0, heapPtr );
673 }
674
675 if( total < ci->nActiveChildren )
676 ArrangeIconicWindows32( clientWnd->hwndSelf );
677 return 0;
678 }
679
680 /**********************************************************************
681 * MDITile
682 */
683 static void MDITile( WND* wndClient, MDICLIENTINFO *ci, WPARAM32 wParam )
684 {
685 WND** ppWnd;
686 UINT32 total = 0;
687
688 if (ci->hwndChildMaximized)
689 SendMessage32A( wndClient->hwndSelf, WM_MDIRESTORE,
690 (WPARAM32)ci->hwndChildMaximized, 0);
691
692 if (ci->nActiveChildren == 0) return;
693
694 ppWnd = WIN_BuildWinArray(wndClient, BWA_SKIPHIDDEN | BWA_SKIPOWNED | BWA_SKIPICONIC |
695 ((wParam & MDITILE_SKIPDISABLED)? BWA_SKIPDISABLED : 0), &total );
696
697 TRACE(mdi,"%u windows to tile\n", total);
698
699 if( ppWnd )
700 {
701 WND** heapPtr = ppWnd;
702
703 if( total )
704 {
705 RECT32 rect;
706 int x, y, xsize, ysize;
707 int rows, columns, r, c, i;
708
709 rect = wndClient->rectClient;
710 rows = (int) sqrt((double)total);
711 columns = total / rows;
712
713 if( wParam & MDITILE_HORIZONTAL ) /* version >= 3.1 */
714 {
715 i = rows;
716 rows = columns; /* exchange r and c */
717 columns = i;
718 }
719
720 if( total != ci->nActiveChildren)
721 {
722 y = rect.bottom - 2 * SYSMETRICS_CYICONSPACING - SYSMETRICS_CYICON;
723 rect.bottom = ( y - SYSMETRICS_CYICON < rect.top )? rect.bottom: y;
724 }
725
726 ysize = rect.bottom / rows;
727 xsize = rect.right / columns;
728
729 for (x = i = 0, c = 1; c <= columns && *ppWnd; c++)
730 {
731 if (c == columns)
732 {
733 rows = total - i;
734 ysize = rect.bottom / rows;
735 }
736
737 y = 0;
738 for (r = 1; r <= rows && *ppWnd; r++, i++)
739 {
740 SetWindowPos32((*ppWnd)->hwndSelf, 0, x, y, xsize, ysize,
741 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
742 y += ysize;
743 ppWnd++;
744 }
745 x += xsize;
746 }
747 }
748 HeapFree( SystemHeap, 0, heapPtr );
749 }
750
751 if( total < ci->nActiveChildren ) ArrangeIconicWindows32( wndClient->hwndSelf );
752 }
753
754 /* ----------------------- Frame window ---------------------------- */
755
756
757 /**********************************************************************
758 * MDI_AugmentFrameMenu
759 */
760 static BOOL32 MDI_AugmentFrameMenu( MDICLIENTINFO* ci, WND *frame,
761 HWND32 hChild )
762 {
763 WND* child = WIN_FindWndPtr(hChild);
764 HMENU32 hSysPopup = 0;
765
766 TRACE(mdi,"frame %p,child %04x\n",frame,hChild);
767
768 if( !frame->wIDmenu || !child->hSysMenu ) return 0;
769
770 /* create a copy of sysmenu popup and insert it into frame menu bar */
771
772 if (!(hSysPopup = LoadMenuIndirect32A(SYSRES_GetResPtr(SYSRES_MENU_SYSMENU))))
773 return 0;
774
775 TRACE(mdi,"\tgot popup %04x in sysmenu %04x\n",
776 hSysPopup, child->hSysMenu);
777
778 if( !InsertMenu32A(frame->wIDmenu,0,MF_BYPOSITION | MF_BITMAP | MF_POPUP,
779 hSysPopup, (LPSTR)(DWORD)hBmpClose ))
780 {
781 DestroyMenu32(hSysPopup);
782 return 0;
783 }
784
785 // Using the magic menu id's to insert system buttons in the menu bar
786 AppendMenu32A(frame->wIDmenu,MF_HELP | MF_BITMAP,
787 SC_MINIMIZE, (LPSTR)(DWORD)3 ) ;
788 AppendMenu32A(frame->wIDmenu,MF_HELP | MF_BITMAP,
789 SC_RESTORE, (LPSTR)(DWORD)2 );
790 AppendMenu32A(frame->wIDmenu,MF_HELP | MF_BITMAP,
791 SC_CLOSE, (LPSTR)(DWORD)5 );
792
793 EnableMenuItem32(hSysPopup, SC_SIZE, MF_BYCOMMAND | MF_GRAYED);
794 EnableMenuItem32(hSysPopup, SC_MOVE, MF_BYCOMMAND | MF_GRAYED);
795 EnableMenuItem32(hSysPopup, SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED);
796
797 /* redraw menu */
798 DrawMenuBar32(frame->hwndSelf);
799
800 return 1;
801 }
802
803 /**********************************************************************
804 * MDI_RestoreFrameMenu
805 */
806 static BOOL32 MDI_RestoreFrameMenu( WND *frameWnd, HWND32 hChild )
807 {
808 INT32 nItems = GetMenuItemCount32(frameWnd->wIDmenu) - 1;
809
810 TRACE(mdi,"for child %04x\n",hChild);
811
812 if( GetMenuItemID32(frameWnd->wIDmenu,nItems) != SC_CLOSE )
813 return 0;
814
815 RemoveMenu32(frameWnd->wIDmenu,0,MF_BYPOSITION);
816
817 DeleteMenu32(frameWnd->wIDmenu,GetMenuItemCount32(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
818 DeleteMenu32(frameWnd->wIDmenu,GetMenuItemCount32(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
819 DeleteMenu32(frameWnd->wIDmenu,GetMenuItemCount32(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
820
821
822
823 DrawMenuBar32(frameWnd->hwndSelf);
824
825 return 1;
826 }
827
828 /**********************************************************************
829 * MDI_UpdateFrameText
830 *
831 * used when child window is maximized/restored
832 *
833 * Note: lpTitle can be NULL
834 */
835 static void MDI_UpdateFrameText( WND *frameWnd, HWND32 hClient,
836 BOOL32 repaint, LPCSTR lpTitle )
837 {
838 char lpBuffer[MDI_MAXTITLELENGTH+1];
839 WND* clientWnd = WIN_FindWndPtr(hClient);
840 MDICLIENTINFO *ci = (MDICLIENTINFO *) clientWnd->wExtra;
841
842 TRACE(mdi, "repaint %i, frameText %s\n", repaint, (lpTitle)?lpTitle:"NULL");
843
844 if (!clientWnd)
845 return;
846
847 if (!ci)
848 return;
849
850 /* store new "default" title if lpTitle is not NULL */
851 if (lpTitle)
852 {
853 if (ci->frameTitle) HeapFree( SystemHeap, 0, ci->frameTitle );
854 ci->frameTitle = HEAP_strdupA( SystemHeap, 0, lpTitle );
855 }
856
857 if (ci->frameTitle)
858 {
859 WND* childWnd = WIN_FindWndPtr( ci->hwndChildMaximized );
860
861 if( childWnd && childWnd->text )
862 {
863 /* combine frame title and child title if possible */
864
865 LPCSTR lpBracket = " - [";
866 int i_frame_text_length = strlen(ci->frameTitle);
867 int i_child_text_length = strlen(childWnd->text);
868
869 lstrcpyn32A( lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH);
870
871 if( i_frame_text_length + 6 < MDI_MAXTITLELENGTH )
872 {
873 strcat( lpBuffer, lpBracket );
874
875 if( i_frame_text_length + i_child_text_length + 6 < MDI_MAXTITLELENGTH )
876 {
877 strcat( lpBuffer, childWnd->text );
878 strcat( lpBuffer, "]" );
879 }
880 else
881 {
882 lstrcpyn32A( lpBuffer + i_frame_text_length + 4,
883 childWnd->text, MDI_MAXTITLELENGTH - i_frame_text_length - 5 );
884 strcat( lpBuffer, "]" );
885 }
886 }
887 }
888 else
889 {
890 strncpy(lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH );
891 lpBuffer[MDI_MAXTITLELENGTH]='\0';
892 }
893 }
894 else
895 lpBuffer[0] = '\0';
896
897 DEFWND_SetText( frameWnd, lpBuffer );
898 if( repaint == MDI_REPAINTFRAME)
899 SetWindowPos32( frameWnd->hwndSelf, 0,0,0,0,0, SWP_FRAMECHANGED |
900 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER );
901 }
902
903
904 /* ----------------------------- Interface ---------------------------- */
905
906
907 /**********************************************************************
908 * MDIClientWndProc
909 *
910 * This function handles all MDI requests.
911 */
912 LRESULT WINAPI MDIClientWndProc( HWND32 hwnd, UINT32 message, WPARAM32 wParam,
913 LPARAM lParam )
914 {
915 LPCREATESTRUCT32A cs;
916 MDICLIENTINFO *ci;
917 RECT32 rect;
918 WND *w = WIN_FindWndPtr(hwnd);
919 WND *frameWnd = w->parent;
920 INT32 nItems;
921
922 ci = (MDICLIENTINFO *) w->wExtra;
923
924 switch (message)
925 {
926 case WM_CREATE:
927
928 cs = (LPCREATESTRUCT32A)lParam;
929
930 /* Translation layer doesn't know what's in the cs->lpCreateParams
931 * so we have to keep track of what environment we're in. */
932
933 if( w->flags & WIN_ISWIN32 )
934 {
935 #define ccs ((LPCLIENTCREATESTRUCT32)cs->lpCreateParams)
936 ci->hWindowMenu = ccs->hWindowMenu;
937 ci->idFirstChild = ccs->idFirstChild;
938 #undef ccs
939 }
940 else
941 {
942 LPCLIENTCREATESTRUCT16 ccs = (LPCLIENTCREATESTRUCT16)
943 PTR_SEG_TO_LIN(cs->lpCreateParams);
944 ci->hWindowMenu = ccs->hWindowMenu;
945 ci->idFirstChild = ccs->idFirstChild;
946 }
947
948 ci->hwndChildMaximized = 0;
949 ci->nActiveChildren = 0;
950 ci->nTotalCreated = 0;
951 ci->frameTitle = NULL;
952 ci->mdiFlags = 0;
953 ci->self = hwnd;
954 w->dwStyle |= WS_CLIPCHILDREN;
955
956 if (!hBmpClose)
957 {
958 hBmpClose = CreateMDIMenuBitmap();
959 hBmpRestore = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
960 }
961 MDI_UpdateFrameText(frameWnd, hwnd, MDI_NOFRAMEREPAINT,frameWnd->text);
962
963 AppendMenu32A( ci->hWindowMenu, MF_SEPARATOR, 0, NULL );
964
965 GetClientRect32(frameWnd->hwndSelf, &rect);
966 NC_HandleNCCalcSize( w, &rect );
967 w->rectClient = rect;
968
969 TRACE(mdi,"Client created - hwnd = %04x, idFirst = %u\n",
970 hwnd, ci->idFirstChild );
971
972 return 0;
973
974 case WM_DESTROY:
975 if( ci->hwndChildMaximized ) MDI_RestoreFrameMenu(w, frameWnd->hwndSelf);
976 if((nItems = GetMenuItemCount32(ci->hWindowMenu)) > 0)
977 {
978 ci->idFirstChild = nItems - 1;
979 ci->nActiveChildren++; /* to delete a separator */
980 while( ci->nActiveChildren-- )
981 DeleteMenu32(ci->hWindowMenu,MF_BYPOSITION,ci->idFirstChild--);
982 }
983 return 0;
984
985 case WM_MDIACTIVATE:
986 if( ci->hwndActiveChild != (HWND32)wParam )
987 SetWindowPos32((HWND32)wParam, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE);
988 return 0;
989
990 case WM_MDICASCADE:
991 return MDICascade(w, ci);
992
993 case WM_MDICREATE:
994 if (lParam) return MDICreateChild( w, ci, hwnd,
995 (MDICREATESTRUCT32A*)lParam );
996 return 0;
997
998 case WM_MDIDESTROY:
999 return MDIDestroyChild( w, ci, hwnd, (HWND32)wParam, TRUE );
1000
1001 case WM_MDIGETACTIVE:
1002 if (lParam) *(BOOL32 *)lParam = (ci->hwndChildMaximized > 0);
1003 return ci->hwndActiveChild;
1004
1005 case WM_MDIICONARRANGE:
1006 ci->mdiFlags |= MDIF_NEEDUPDATE;
1007 ArrangeIconicWindows32(hwnd);
1008 ci->sbRecalc = SB_BOTH+1;
1009 SendMessage32A(hwnd, WM_MDICALCCHILDSCROLL, 0, 0L);
1010 return 0;
1011
1012 case WM_MDIMAXIMIZE:
1013 ShowWindow32( (HWND32)wParam, SW_MAXIMIZE );
1014 return 0;
1015
1016 case WM_MDINEXT: /* lParam != 0 means previous window */
1017 MDI_SwitchActiveChild(hwnd, (HWND32)wParam, (lParam)? FALSE : TRUE );
1018 break;
1019
1020 case WM_MDIRESTORE:
1021 SendMessage32A( (HWND32)wParam, WM_SYSCOMMAND, SC_RESTORE, 0);
1022 return 0;
1023
1024 case WM_MDISETMENU:
1025 return MDISetMenu( hwnd, (HMENU32)wParam, (HMENU32)lParam );
1026
1027 case WM_MDIREFRESHMENU:
1028 return MDIRefreshMenu( hwnd, (HMENU32)wParam, (HMENU32)lParam );
1029
1030 case WM_MDITILE:
1031 ci->mdiFlags |= MDIF_NEEDUPDATE;
1032 ShowScrollBar32(hwnd,SB_BOTH,FALSE);
1033 MDITile(w, ci, wParam);
1034 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1035 return 0;
1036
1037 case WM_VSCROLL:
1038 case WM_HSCROLL:
1039 ci->mdiFlags |= MDIF_NEEDUPDATE;
1040 ScrollChildren32(hwnd, message, wParam, lParam);
1041 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1042 return 0;
1043
1044 case WM_SETFOCUS:
1045 if( ci->hwndActiveChild )
1046 {
1047 w = WIN_FindWndPtr( ci->hwndActiveChild );
1048 if( !(w->dwStyle & WS_MINIMIZE) )
1049 SetFocus32( ci->hwndActiveChild );
1050 }
1051 return 0;
1052
1053 case WM_NCACTIVATE:
1054 if( ci->hwndActiveChild )
1055 SendMessage32A(ci->hwndActiveChild, message, wParam, lParam);
1056 break;
1057
1058 case WM_PARENTNOTIFY:
1059 if (LOWORD(wParam) == WM_LBUTTONDOWN)
1060 {
1061 POINT16 pt = MAKEPOINT16(lParam);
1062 HWND16 child = ChildWindowFromPoint16(hwnd, pt);
1063
1064 TRACE(mdi,"notification from %04x (%i,%i)\n",child,pt.x,pt.y);
1065
1066 if( child && child != hwnd && child != ci->hwndActiveChild )
1067 SetWindowPos32(child, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
1068 }
1069 return 0;
1070
1071 case WM_SIZE:
1072 if( IsWindow32(ci->hwndChildMaximized) )
1073 {
1074 WND* child = WIN_FindWndPtr(ci->hwndChildMaximized);
1075 RECT32 rect = { 0, 0, LOWORD(lParam), HIWORD(lParam) };
1076
1077 AdjustWindowRectEx32(&rect, child->dwStyle, 0, child->dwExStyle);
1078 MoveWindow32(ci->hwndChildMaximized, rect.left, rect.top,
1079 rect.right - rect.left, rect.bottom - rect.top, 1);
1080 }
1081 else
1082 MDI_PostUpdate(hwnd, ci, SB_BOTH+1);
1083
1084 break;
1085
1086 case WM_MDICALCCHILDSCROLL:
1087 if( (ci->mdiFlags & MDIF_NEEDUPDATE) && ci->sbRecalc )
1088 {
1089 CalcChildScroll(hwnd, ci->sbRecalc-1);
1090 ci->sbRecalc = 0;
1091 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1092 }
1093 return 0;
1094 }
1095
1096 return DefWindowProc32A( hwnd, message, wParam, lParam );
1097 }
1098
1099
1100 /***********************************************************************
1101 * DefFrameProc16 (USER.445)
1102 */
1103 LRESULT WINAPI DefFrameProc16( HWND16 hwnd, HWND16 hwndMDIClient,
1104 UINT16 message, WPARAM16 wParam, LPARAM lParam )
1105 {
1106 HWND16 childHwnd;
1107 MDICLIENTINFO* ci;
1108 WND* wndPtr;
1109
1110 if (hwndMDIClient)
1111 {
1112 switch (message)
1113 {
1114 case WM_COMMAND:
1115 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1116 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1117
1118 /* check for possible syscommands for maximized MDI child */
1119
1120 if( ci && (
1121 wParam < ci->idFirstChild ||
1122 wParam >= ci->idFirstChild + ci->nActiveChildren
1123 )){
1124 if( (wParam - 0xF000) & 0xF00F ) break;
1125 switch( wParam )
1126 {
1127 case SC_SIZE:
1128 case SC_MOVE:
1129 case SC_MINIMIZE:
1130 case SC_MAXIMIZE:
1131 case SC_NEXTWINDOW:
1132 case SC_PREVWINDOW:
1133 case SC_CLOSE:
1134 case SC_RESTORE:
1135 if( ci->hwndChildMaximized )
1136 return SendMessage16( ci->hwndChildMaximized, WM_SYSCOMMAND,
1137 wParam, lParam);
1138 }
1139 }
1140 else
1141 {
1142 childHwnd = MDI_GetChildByID( WIN_FindWndPtr(hwndMDIClient),
1143 wParam );
1144 if( childHwnd )
1145 SendMessage16(hwndMDIClient, WM_MDIACTIVATE,
1146 (WPARAM16)childHwnd , 0L);
1147 }
1148 break;
1149
1150 case WM_NCACTIVATE:
1151 SendMessage16(hwndMDIClient, message, wParam, lParam);
1152 break;
1153
1154 case WM_SETTEXT:
1155 MDI_UpdateFrameText(WIN_FindWndPtr(hwnd), hwndMDIClient,
1156 MDI_REPAINTFRAME,
1157 (LPCSTR)PTR_SEG_TO_LIN(lParam));
1158 return 0;
1159
1160 case WM_SETFOCUS:
1161 SetFocus32(hwndMDIClient);
1162 break;
1163
1164 case WM_SIZE:
1165 MoveWindow16(hwndMDIClient, 0, 0,
1166 LOWORD(lParam), HIWORD(lParam), TRUE);
1167 break;
1168
1169 case WM_NEXTMENU:
1170
1171 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1172 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1173
1174 if( !(wndPtr->parent->dwStyle & WS_MINIMIZE)
1175 && ci->hwndActiveChild && !ci->hwndChildMaximized )
1176 {
1177 /* control menu is between the frame system menu and
1178 * the first entry of menu bar */
1179
1180 if( (wParam == VK_LEFT &&
1181 wndPtr->parent->wIDmenu == LOWORD(lParam)) ||
1182 (wParam == VK_RIGHT &&
1183 GetSubMenu16(wndPtr->parent->hSysMenu, 0) == LOWORD(lParam)) )
1184 {
1185 wndPtr = WIN_FindWndPtr(ci->hwndActiveChild);
1186 return MAKELONG( GetSubMenu16(wndPtr->hSysMenu, 0),
1187 ci->hwndActiveChild);
1188 }
1189 }
1190 break;
1191 }
1192 }
1193
1194 return DefWindowProc16(hwnd, message, wParam, lParam);
1195 }
1196
1197
1198 /***********************************************************************
1199 * DefFrameProc32A (USER32.122)
1200 */
1201 LRESULT WINAPI DefFrameProc32A( HWND32 hwnd, HWND32 hwndMDIClient,
1202 UINT32 message, WPARAM32 wParam, LPARAM lParam)
1203 {
1204 if (hwndMDIClient)
1205 {
1206 switch (message)
1207 {
1208 case WM_COMMAND:
1209 return DefFrameProc16( hwnd, hwndMDIClient, message,
1210 (WPARAM16)wParam,
1211 MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ) );
1212
1213 case WM_NCACTIVATE:
1214 SendMessage32A(hwndMDIClient, message, wParam, lParam);
1215 break;
1216
1217 case WM_SETTEXT: {
1218 LRESULT ret;
1219 LPSTR segstr = SEGPTR_STRDUP((LPSTR)lParam);
1220
1221 ret = DefFrameProc16(hwnd, hwndMDIClient, message,
1222 wParam, (LPARAM)SEGPTR_GET(segstr) );
1223 SEGPTR_FREE(segstr);
1224 return ret;
1225 }
1226
1227 case WM_NEXTMENU:
1228 case WM_SETFOCUS:
1229 case WM_SIZE:
1230 return DefFrameProc16( hwnd, hwndMDIClient, message,
1231 wParam, lParam );
1232 }
1233 }
1234
1235 return DefWindowProc32A(hwnd, message, wParam, lParam);
1236 }
1237
1238
1239 /***********************************************************************
1240 * DefFrameProc32W (USER32.123)
1241 */
1242 LRESULT WINAPI DefFrameProc32W( HWND32 hwnd, HWND32 hwndMDIClient,
1243 UINT32 message, WPARAM32 wParam, LPARAM lParam)
1244 {
1245 if (hwndMDIClient)
1246 {
1247 switch (message)
1248 {
1249 case WM_COMMAND:
1250 return DefFrameProc16( hwnd, hwndMDIClient, message,
1251 (WPARAM16)wParam,
1252 MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ) );
1253
1254 case WM_NCACTIVATE:
1255 SendMessage32W(hwndMDIClient, message, wParam, lParam);
1256 break;
1257
1258 case WM_SETTEXT:
1259 {
1260 LPSTR txt = HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)lParam);
1261 LRESULT ret = DefFrameProc32A( hwnd, hwndMDIClient, message,
1262 wParam, (DWORD)txt );
1263 HeapFree(GetProcessHeap(),0,txt);
1264 return ret;
1265 }
1266 case WM_NEXTMENU:
1267 case WM_SETFOCUS:
1268 case WM_SIZE:
1269 return DefFrameProc32A( hwnd, hwndMDIClient, message,
1270 wParam, lParam );
1271 }
1272 }
1273
1274 return DefWindowProc32W( hwnd, message, wParam, lParam );
1275 }
1276
1277
1278 /***********************************************************************
1279 * DefMDIChildProc16 (USER.447)
1280 */
1281 LRESULT WINAPI DefMDIChildProc16( HWND16 hwnd, UINT16 message,
1282 WPARAM16 wParam, LPARAM lParam )
1283 {
1284 MDICLIENTINFO *ci;
1285 WND *clientWnd;
1286
1287 clientWnd = WIN_FindWndPtr(GetParent16(hwnd));
1288 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1289
1290 switch (message)
1291 {
1292 case WM_SETTEXT:
1293 DefWindowProc16(hwnd, message, wParam, lParam);
1294 MDI_MenuModifyItem(clientWnd,hwnd);
1295 if( ci->hwndChildMaximized == hwnd )
1296 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1297 MDI_REPAINTFRAME, NULL );
1298 return 0;
1299
1300 case WM_CLOSE:
1301 SendMessage16(ci->self,WM_MDIDESTROY,(WPARAM16)hwnd,0L);
1302 return 0;
1303
1304 case WM_SETFOCUS:
1305 if( ci->hwndActiveChild != hwnd )
1306 MDI_ChildActivate(clientWnd, hwnd);
1307 break;
1308
1309 case WM_CHILDACTIVATE:
1310 MDI_ChildActivate(clientWnd, hwnd);
1311 return 0;
1312
1313 case WM_NCPAINT:
1314 TRACE(mdi,"WM_NCPAINT for %04x, active %04x\n",
1315 hwnd, ci->hwndActiveChild );
1316 break;
1317
1318 case WM_SYSCOMMAND:
1319 switch( wParam )
1320 {
1321 case SC_MOVE:
1322 if( ci->hwndChildMaximized == hwnd) return 0;
1323 break;
1324 case SC_RESTORE:
1325 case SC_MINIMIZE:
1326 WIN_FindWndPtr(hwnd)->dwStyle |= WS_SYSMENU;
1327 break;
1328 case SC_MAXIMIZE:
1329 if( ci->hwndChildMaximized == hwnd)
1330 return SendMessage16( clientWnd->parent->hwndSelf,
1331 message, wParam, lParam);
1332 WIN_FindWndPtr(hwnd)->dwStyle &= ~WS_SYSMENU;
1333 break;
1334 case SC_NEXTWINDOW:
1335 SendMessage16( ci->self, WM_MDINEXT, 0, 0);
1336 return 0;
1337 case SC_PREVWINDOW:
1338 SendMessage16( ci->self, WM_MDINEXT, 0, 1);
1339 return 0;
1340 }
1341 break;
1342
1343 case WM_GETMINMAXINFO:
1344 MDI_ChildGetMinMaxInfo(clientWnd, hwnd, (MINMAXINFO16*) PTR_SEG_TO_LIN(lParam));
1345 return 0;
1346
1347 case WM_SETVISIBLE:
1348 if( ci->hwndChildMaximized) ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1349 else
1350 MDI_PostUpdate(clientWnd->hwndSelf, ci, SB_BOTH+1);
1351 break;
1352
1353 case WM_SIZE:
1354 /* do not change */
1355
1356 if( ci->hwndActiveChild == hwnd && wParam != SIZE_MAXIMIZED )
1357 {
1358 ci->hwndChildMaximized = 0;
1359
1360 MDI_RestoreFrameMenu( clientWnd->parent, hwnd);
1361 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1362 MDI_REPAINTFRAME, NULL );
1363 }
1364
1365 if( wParam == SIZE_MAXIMIZED )
1366 {
1367 HWND16 hMaxChild = ci->hwndChildMaximized;
1368
1369 if( hMaxChild == hwnd ) break;
1370
1371 if( hMaxChild)
1372 {
1373 SendMessage16( hMaxChild, WM_SETREDRAW, FALSE, 0L );
1374
1375 MDI_RestoreFrameMenu( clientWnd->parent, hMaxChild);
1376 ShowWindow16( hMaxChild, SW_SHOWNOACTIVATE);
1377
1378 SendMessage16( hMaxChild, WM_SETREDRAW, TRUE, 0L );
1379 }
1380
1381 TRACE(mdi,"maximizing child %04x\n", hwnd );
1382
1383 ci->hwndChildMaximized = hwnd; /* !!! */
1384
1385 MDI_AugmentFrameMenu( ci, clientWnd->parent, hwnd);
1386 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1387 MDI_REPAINTFRAME, NULL );
1388 }
1389
1390 if( wParam == SIZE_MINIMIZED )
1391 {
1392 HWND16 switchTo = MDI_GetWindow(clientWnd, hwnd, TRUE, WS_MINIMIZE);
1393
1394 if( switchTo )
1395 SendMessage16( switchTo, WM_CHILDACTIVATE, 0, 0L);
1396 }
1397
1398 MDI_PostUpdate(clientWnd->hwndSelf, ci, SB_BOTH+1);
1399 break;
1400
1401 case WM_MENUCHAR:
1402
1403 /* MDI children don't have menu bars */
1404 PostMessage16( clientWnd->parent->hwndSelf, WM_SYSCOMMAND,
1405 (WPARAM16)SC_KEYMENU, (LPARAM)wParam);
1406 return 0x00010000L;
1407
1408 case WM_NEXTMENU:
1409
1410 if( wParam == VK_LEFT ) /* switch to frame system menu */
1411 return MAKELONG( GetSubMenu16(clientWnd->parent->hSysMenu, 0),
1412 clientWnd->parent->hwndSelf );
1413 if( wParam == VK_RIGHT ) /* to frame menu bar */
1414 return MAKELONG( clientWnd->parent->wIDmenu,
1415 clientWnd->parent->hwndSelf );
1416
1417 break;
1418
1419 case WM_SYSCHAR:
1420 if (wParam == '-')
1421 {
1422 SendMessage16(hwnd,WM_SYSCOMMAND,
1423 (WPARAM16)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
1424 return 0;
1425 }
1426 }
1427
1428 return DefWindowProc16(hwnd, message, wParam, lParam);
1429 }
1430
1431
1432 /***********************************************************************
1433 * DefMDIChildProc32A (USER32.124)
1434 */
1435 LRESULT WINAPI DefMDIChildProc32A( HWND32 hwnd, UINT32 message,
1436 WPARAM32 wParam, LPARAM lParam )
1437 {
1438 MDICLIENTINFO *ci;
1439 WND *clientWnd;
1440
1441 clientWnd = WIN_FindWndPtr(WIN_FindWndPtr(hwnd)->parent->hwndSelf);
1442 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1443
1444 switch (message)
1445 {
1446 case WM_SETTEXT:
1447 DefWindowProc32A(hwnd, message, wParam, lParam);
1448 MDI_MenuModifyItem(clientWnd,hwnd);
1449 if( ci->hwndChildMaximized == hwnd )
1450 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1451 MDI_REPAINTFRAME, NULL );
1452 return 0;
1453
1454 case WM_GETMINMAXINFO:
1455 {
1456 MINMAXINFO16 mmi;
1457 STRUCT32_MINMAXINFO32to16( (MINMAXINFO32 *)lParam, &mmi );
1458 MDI_ChildGetMinMaxInfo( clientWnd, hwnd, &mmi );
1459 STRUCT32_MINMAXINFO16to32( &mmi, (MINMAXINFO32 *)lParam );
1460 }
1461 return 0;
1462
1463 case WM_MENUCHAR:
1464
1465 /* MDI children don't have menu bars */
1466 PostMessage16( clientWnd->parent->hwndSelf, WM_SYSCOMMAND,
1467 (WPARAM16)SC_KEYMENU, (LPARAM)LOWORD(wParam) );
1468 return 0x00010000L;
1469
1470 case WM_CLOSE:
1471 case WM_SETFOCUS:
1472 case WM_CHILDACTIVATE:
1473 case WM_NCPAINT:
1474 case WM_SYSCOMMAND:
1475 case WM_SETVISIBLE:
1476 case WM_SIZE:
1477 case WM_NEXTMENU:
1478 return DefMDIChildProc16( hwnd, message, (WPARAM16)wParam, lParam );
1479
1480 case WM_SYSCHAR:
1481 if (wParam == '-')
1482 {
1483 SendMessage32A(hwnd,WM_SYSCOMMAND,
1484 (WPARAM32)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
1485 return 0;
1486 }
1487 }
1488 return DefWindowProc32A(hwnd, message, wParam, lParam);
1489 }
1490
1491
1492 /***********************************************************************
1493 * DefMDIChildProc32W (USER32.125)
1494 */
1495 LRESULT WINAPI DefMDIChildProc32W( HWND32 hwnd, UINT32 message,
1496 WPARAM32 wParam, LPARAM lParam )
1497 {
1498 MDICLIENTINFO *ci;
1499 WND *clientWnd;
1500
1501 clientWnd = WIN_FindWndPtr(GetParent16(hwnd));
1502 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1503
1504 switch (message)
1505 {
1506 case WM_SETTEXT:
1507 DefWindowProc32W(hwnd, message, wParam, lParam);
1508 MDI_MenuModifyItem(clientWnd,hwnd);
1509 if( ci->hwndChildMaximized == hwnd )
1510 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1511 MDI_REPAINTFRAME, NULL );
1512 return 0;
1513
1514 case WM_GETMINMAXINFO:
1515 case WM_MENUCHAR:
1516 case WM_CLOSE:
1517 case WM_SETFOCUS:
1518 case WM_CHILDACTIVATE:
1519 case WM_NCPAINT:
1520 case WM_SYSCOMMAND:
1521 case WM_SETVISIBLE:
1522 case WM_SIZE:
1523 case WM_NEXTMENU:
1524 return DefMDIChildProc32A( hwnd, message, (WPARAM16)wParam, lParam );
1525
1526 case WM_SYSCHAR:
1527 if (wParam == '-')
1528 {
1529 SendMessage32W(hwnd,WM_SYSCOMMAND,
1530 (WPARAM32)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
1531 return 0;
1532 }
1533 }
1534 return DefWindowProc32W(hwnd, message, wParam, lParam);
1535 }
1536
1537
1538 /**********************************************************************
1539 * CreateMDIWindowA [USER32.79] Creates a MDI child in new thread
1540 * FIXME: its in the same thread now
1541 *
1542 * RETURNS
1543 * Success: Handle to created window
1544 * Failure: NULL
1545 */
1546 HWND32 WINAPI CreateMDIWindow32A(
1547 LPCSTR lpClassName, /* [in] Pointer to registered child class name */
1548 LPCSTR lpWindowName, /* [in] Pointer to window name */
1549 DWORD dwStyle, /* [in] Window style */
1550 INT32 X, /* [in] Horizontal position of window */
1551 INT32 Y, /* [in] Vertical position of window */
1552 INT32 nWidth, /* [in] Width of window */
1553 INT32 nHeight, /* [in] Height of window */
1554 HWND32 hWndParent, /* [in] Handle to parent window */
1555 HINSTANCE32 hInstance, /* [in] Handle to application instance */
1556 LPARAM lParam) /* [in] Application-defined value */
1557 {
1558 WARN(mdi,"is only single threaded!\n");
1559 return MDI_CreateMDIWindow32A(lpClassName, lpWindowName, dwStyle, X, Y,
1560 nWidth, nHeight, hWndParent, hInstance, lParam);
1561 }
1562
1563 /**********************************************************************
1564 * MDI_CreateMDIWindowA
1565 * single threaded version of CreateMDIWindowA
1566 * called by CreateWindowEx32A
1567 */
1568 HWND32 MDI_CreateMDIWindow32A(
1569 LPCSTR lpClassName,
1570 LPCSTR lpWindowName,
1571 DWORD dwStyle,
1572 INT32 X,
1573 INT32 Y,
1574 INT32 nWidth,
1575 INT32 nHeight,
1576 HWND32 hWndParent,
1577 HINSTANCE32 hInstance,
1578 LPARAM lParam)
1579 {
1580 MDICLIENTINFO* pCi;
1581 MDICREATESTRUCT32A cs;
1582 WND *pWnd=WIN_FindWndPtr(hWndParent);
1583
1584 TRACE(mdi, "(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld)\n",
1585 debugstr_a(lpClassName),debugstr_a(lpWindowName),dwStyle,X,Y,
1586 nWidth,nHeight,hWndParent,hInstance,lParam);
1587
1588 if(!pWnd){
1589 ERR(mdi," bad hwnd for MDI-client: %d\n",hWndParent);
1590 return 0;
1591 }
1592 cs.szClass=lpClassName;
1593 cs.szTitle=lpWindowName;
1594 cs.hOwner=hInstance;
1595 cs.x=X;
1596 cs.y=Y;
1597 cs.cx=nWidth;
1598 cs.cy=nHeight;
1599 cs.style=dwStyle;
1600 cs.lParam=lParam;
1601
1602 pCi=(MDICLIENTINFO *)pWnd->wExtra;
1603
1604 return MDICreateChild(pWnd,pCi,hWndParent,&cs);
1605 }
1606
1607 /***************************************
1608 * CreateMDIWindow32W [USER32.80] Creates a MDI child in new thread
1609 *
1610 * RETURNS
1611 * Success: Handle to created window
1612 * Failure: NULL
1613 */
1614 HWND32 WINAPI CreateMDIWindow32W(
1615 LPCWSTR lpClassName, /* [in] Pointer to registered child class name */
1616 LPCWSTR lpWindowName, /* [in] Pointer to window name */
1617 DWORD dwStyle, /* [in] Window style */
1618 INT32 X, /* [in] Horizontal position of window */
1619 INT32 Y, /* [in] Vertical position of window */
1620 INT32 nWidth, /* [in] Width of window */
1621 INT32 nHeight, /* [in] Height of window */
1622 HWND32 hWndParent, /* [in] Handle to parent window */
1623 HINSTANCE32 hInstance, /* [in] Handle to application instance */
1624 LPARAM lParam) /* [in] Application-defined value */
1625 {
1626 FIXME(mdi, "(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld): stub\n",
1627 debugstr_w(lpClassName),debugstr_w(lpWindowName),dwStyle,X,Y,
1628 nWidth,nHeight,hWndParent,hInstance,lParam);
1629 return (HWND32)NULL;
1630 }
1631
1632
1633 /******************************************************************************
1634 * CreateMDIWindow32W [USER32.80] Creates a MDI child window
1635 * single threaded version of CreateMDIWindow
1636 * called by CreateWindowEx32W().
1637 */
1638 HWND32 MDI_CreateMDIWindow32W(
1639 LPCWSTR lpClassName, /* [in] Pointer to registered child class name */
1640 LPCWSTR lpWindowName, /* [in] Pointer to window name */
1641 DWORD dwStyle, /* [in] Window style */
1642 INT32 X, /* [in] Horizontal position of window */
1643 INT32 Y, /* [in] Vertical position of window */
1644 INT32 nWidth, /* [in] Width of window */
1645 INT32 nHeight, /* [in] Height of window */
1646 HWND32 hWndParent, /* [in] Handle to parent window */
1647 HINSTANCE32 hInstance, /* [in] Handle to application instance */
1648 LPARAM lParam) /* [in] Application-defined value */
1649 {
1650 FIXME(mdi, "(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld): stub\n",
1651 debugstr_w(lpClassName),debugstr_w(lpWindowName),dwStyle,X,Y,
1652 nWidth,nHeight,hWndParent,hInstance,lParam);
1653 return (HWND32)NULL;
1654 }
1655
1656
1657 /**********************************************************************
1658 * TranslateMDISysAccel32 (USER32.555)
1659 */
1660 BOOL32 WINAPI TranslateMDISysAccel32( HWND32 hwndClient, LPMSG32 msg )
1661 {
1662 MSG16 msg16;
1663
1664 STRUCT32_MSG32to16(msg,&msg16);
1665 /* MDICLIENTINFO is still the same for win32 and win16 ... */
1666 return TranslateMDISysAccel16(hwndClient,&msg16);
1667 }
1668
1669
1670 /**********************************************************************
1671 * TranslateMDISysAccel16 (USER.451)
1672 */
1673 BOOL16 WINAPI TranslateMDISysAccel16( HWND16 hwndClient, LPMSG16 msg )
1674 {
1675 WND* clientWnd = WIN_FindWndPtr( hwndClient);
1676
1677 if( clientWnd && (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN))
1678 {
1679 MDICLIENTINFO *ci = NULL;
1680 WND* wnd;
1681
1682 ci = (MDICLIENTINFO*) clientWnd->wExtra;
1683 wnd = WIN_FindWndPtr(ci->hwndActiveChild);
1684 if( wnd && !(wnd->dwStyle & WS_DISABLED) )
1685 {
1686 WPARAM16 wParam = 0;
1687
1688 /* translate if the Ctrl key is down and Alt not. */
1689
1690 if( (GetKeyState32(VK_CONTROL) & 0x8000) &&
1691 !(GetKeyState32(VK_MENU) & 0x8000))
1692 {
1693 switch( msg->wParam )
1694 {
1695 case VK_F6:
1696 case VK_TAB:
1697 wParam = ( GetKeyState32(VK_SHIFT) & 0x8000 )
1698 ? SC_NEXTWINDOW : SC_PREVWINDOW;
1699 break;
1700 case VK_F4:
1701 case VK_RBUTTON:
1702 wParam = SC_CLOSE;
1703 break;
1704 default:
1705 return 0;
1706 }
1707 TRACE(mdi,"wParam = %04x\n", wParam);
1708 SendMessage16( ci->hwndActiveChild, WM_SYSCOMMAND,
1709 wParam, (LPARAM)msg->wParam);
1710 return 1;
1711 }
1712 }
1713 }
1714 return 0; /* failure */
1715 }
1716
1717
1718 /***********************************************************************
1719 * CalcChildScroll (USER.462)
1720 */
1721 void WINAPI CalcChildScroll( HWND16 hwnd, WORD scroll )
1722 {
1723 SCROLLINFO info;
1724 RECT32 childRect, clientRect;
1725 INT32 vmin, vmax, hmin, hmax, vpos, hpos;
1726 WND *pWnd, *Wnd;
1727
1728 if (!(Wnd = pWnd = WIN_FindWndPtr( hwnd ))) return;
1729 GetClientRect32( hwnd, &clientRect );
1730 SetRectEmpty32( &childRect );
1731
1732 for ( pWnd = pWnd->child; pWnd; pWnd = pWnd->next )
1733 {
1734 if( pWnd->dwStyle & WS_MAXIMIZE )
1735 {
1736 ShowScrollBar32(hwnd, SB_BOTH, FALSE);
1737 return;
1738 }
1739 UnionRect32( &childRect, &pWnd->rectWindow, &childRect );
1740 }
1741 UnionRect32( &childRect, &clientRect, &childRect );
1742
1743 hmin = childRect.left; hmax = childRect.right - clientRect.right;
1744 hpos = clientRect.left - childRect.left;
1745 vmin = childRect.top; vmax = childRect.bottom - clientRect.bottom;
1746 vpos = clientRect.top - childRect.top;
1747
1748 switch( scroll )
1749 {
1750 case SB_HORZ:
1751 vpos = hpos; vmin = hmin; vmax = hmax;
1752 case SB_VERT:
1753 info.cbSize = sizeof(info);
1754 info.nMax = vmax; info.nMin = vmin; info.nPos = vpos;
1755 info.fMask = SIF_POS | SIF_RANGE;
1756 SetScrollInfo32(hwnd, scroll, &info, TRUE);
1757 break;
1758 case SB_BOTH:
1759 SCROLL_SetNCSbState( Wnd, vmin, vmax, vpos,
1760 hmin, hmax, hpos);
1761 }
1762 }
1763
1764
1765 /***********************************************************************
1766 * ScrollChildren16 (USER.463)
1767 */
1768 void WINAPI ScrollChildren16(HWND16 hWnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam)
1769 {
1770 return ScrollChildren32( hWnd, uMsg, wParam, lParam );
1771 }
1772
1773
1774 /***********************************************************************
1775 * ScrollChildren32 (USER32.448)
1776 */
1777 void WINAPI ScrollChildren32(HWND32 hWnd, UINT32 uMsg, WPARAM32 wParam,
1778 LPARAM lParam)
1779 {
1780 WND *wndPtr = WIN_FindWndPtr(hWnd);
1781 INT32 newPos = -1;
1782 INT32 curPos, length, minPos, maxPos, shift;
1783
1784 if( !wndPtr ) return;
1785
1786 if( uMsg == WM_HSCROLL )
1787 {
1788 GetScrollRange32(hWnd,SB_HORZ,&minPos,&maxPos);
1789 curPos = GetScrollPos32(hWnd,SB_HORZ);
1790 length = (wndPtr->rectClient.right - wndPtr->rectClient.left)/2;
1791 shift = SYSMETRICS_CYHSCROLL;
1792 }
1793 else if( uMsg == WM_VSCROLL )
1794 {
1795 GetScrollRange32(hWnd,SB_VERT,&minPos,&maxPos);
1796 curPos = GetScrollPos32(hWnd,SB_VERT);
1797 length = (wndPtr->rectClient.bottom - wndPtr->rectClient.top)/2;
1798 shift = SYSMETRICS_CXVSCROLL;
1799 }
1800 else return;
1801
1802 switch( wParam )
1803 {
1804 case SB_LINEUP:
1805 newPos = curPos - shift;
1806 break;
1807 case SB_LINEDOWN:
1808 newPos = curPos + shift;
1809 break;
1810 case SB_PAGEUP:
1811 newPos = curPos - length;
1812 break;
1813 case SB_PAGEDOWN:
1814 newPos = curPos + length;
1815 break;
1816
1817 case SB_THUMBPOSITION:
1818 newPos = LOWORD(lParam);
1819 break;
1820
1821 case SB_THUMBTRACK:
1822 return;
1823
1824 case SB_TOP:
1825 newPos = minPos;
1826 break;
1827 case SB_BOTTOM:
1828 newPos = maxPos;
1829 break;
1830 case SB_ENDSCROLL:
1831 CalcChildScroll(hWnd,(uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ);
1832 return;
1833 }
1834
1835 if( newPos > maxPos )
1836 newPos = maxPos;
1837 else
1838 if( newPos < minPos )
1839 newPos = minPos;
1840
1841 SetScrollPos32(hWnd, (uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ , newPos, TRUE);
1842
1843 if( uMsg == WM_VSCROLL )
1844 ScrollWindowEx32(hWnd ,0 ,curPos - newPos, NULL, NULL, 0, NULL,
1845 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
1846 else
1847 ScrollWindowEx32(hWnd ,curPos - newPos, 0, NULL, NULL, 0, NULL,
1848 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
1849 }
1850
1851
1852 /******************************************************************************
1853 * CascadeWindows [USER32.21] Cascades MDI child windows
1854 *
1855 * RETURNS
1856 * Success: Number of cascaded windows.
1857 * Failure: 0
1858 */
1859 WORD WINAPI
1860 CascadeWindows (HWND32 hwndParent, UINT32 wFlags, const LPRECT32 lpRect,
1861 UINT32 cKids, const HWND32 *lpKids)
1862 {
1863 FIXME (mdi, "(0x%08x,0x%08x,...,%u,...): stub\n",
1864 hwndParent, wFlags, cKids);
1865
1866 return 0;
1867 }
1868
1869
1870 /******************************************************************************
1871 * TileWindows [USER32.545] Tiles MDI child windows
1872 *
1873 * RETURNS
1874 * Success: Number of tiled windows.
1875 * Failure: 0
1876 */
1877 WORD WINAPI
1878 TileWindows (HWND32 hwndParent, UINT32 wFlags, const LPRECT32 lpRect,
1879 UINT32 cKids, const HWND32 *lpKids)
1880 {
1881 FIXME (mdi, "(0x%08x,0x%08x,...,%u,...): stub\n",
1882 hwndParent, wFlags, cKids);
1883
1884 return 0;
1885 }
1886
Windows API implementation