?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Change xterm mouse tracking mode to BTN_EVENT_MOUSE (track if pressed).
[wine.git] / windows / mdi.c
blobd482e48c8e680ea3e87aa34d24388c9d080688f3
1 /* MDI.C
2 *
3 * Copyright 1994, Bob Amstadt
4 * 1995,1996 Alex Korobka
5 *
6 * This file contains routines to support MDI (Multiple Document
7 * Interface) features .
8 *
9 * Notes: Fairly complete implementation.
10 * Also, Excel and WinWord do _not_ use MDI so if you're trying
11 * to fix them look elsewhere.
12 *
13 * Notes on how the "More Windows..." is implemented:
14 *
15 * When we have more than 9 opened windows, a "More Windows..."
16 * option appears in the "Windows" menu. Each child window has
17 * a WND* associated with it, accesible via the children list of
18 * the parent window. This WND* has a wIDmenu member, which reflects
19 * the position of the child in the window list. For example, with
20 * 9 child windows, we could have the following pattern:
21 *
22 *
23 *
24 * Name of the child window pWndChild->wIDmenu
25 * Doc1 5000
26 * Doc2 5001
27 * Doc3 5002
28 * Doc4 5003
29 * Doc5 5004
30 * Doc6 5005
31 * Doc7 5006
32 * Doc8 5007
33 * Doc9 5008
34 *
35 *
36 * The "Windows" menu, as the "More windows..." dialog, are constructed
37 * in this order. If we add a child, we would have the following list:
38 *
39 *
40 * Name of the child window pWndChild->wIDmenu
41 * Doc1 5000
42 * Doc2 5001
43 * Doc3 5002
44 * Doc4 5003
45 * Doc5 5004
46 * Doc6 5005
47 * Doc7 5006
48 * Doc8 5007
49 * Doc9 5008
50 * Doc10 5009
51 *
52 * But only 5000 to 5008 would be displayed in the "Windows" menu. We want
53 * the last created child to be in the menu, so we swap the last child with
54 * the 9th... Doc9 will be accessible via the "More Windows..." option.
55 *
56 * Doc1 5000
57 * Doc2 5001
58 * Doc3 5002
59 * Doc4 5003
60 * Doc5 5004
61 * Doc6 5005
62 * Doc7 5006
63 * Doc8 5007
64 * Doc9 5009
65 * Doc10 5008
66 *
67 */
68
69 #include <stdlib.h>
70 #include <stdio.h>
71 #include <string.h>
72 #include <math.h>
73 #include "windef.h"
74 #include "wingdi.h"
75 #include "winuser.h"
76 #include "wine/unicode.h"
77 #include "win.h"
78 #include "heap.h"
79 #include "nonclient.h"
80 #include "mdi.h"
81 #include "user.h"
82 #include "menu.h"
83 #include "scroll.h"
84 #include "struct32.h"
85 #include "tweak.h"
86 #include "debugtools.h"
87 #include "dlgs.h"
88
89 DEFAULT_DEBUG_CHANNEL(mdi);
90
91 #define MDIF_NEEDUPDATE 0x0001
92
93 static HBITMAP16 hBmpClose = 0;
94 static HBITMAP16 hBmpRestore = 0;
95
96 /* ----------------- declarations ----------------- */
97 static void MDI_UpdateFrameText(WND *, HWND, BOOL, LPCWSTR);
98 static BOOL MDI_AugmentFrameMenu(MDICLIENTINFO*, WND *, HWND);
99 static BOOL MDI_RestoreFrameMenu(WND *, HWND);
100
101 static LONG MDI_ChildActivate( WND*, HWND );
102
103 static HWND MDI_MoreWindowsDialog(WND*);
104 static void MDI_SwapMenuItems(WND *, UINT, UINT);
105 /* -------- Miscellaneous service functions ----------
106 *
107 * MDI_GetChildByID
108 */
109
110 static HWND MDI_GetChildByID(WND* wndPtr, INT id)
111 {
112 for (wndPtr = wndPtr->child; wndPtr; wndPtr = wndPtr->next)
113 if (wndPtr->wIDmenu == id) return wndPtr->hwndSelf;
114 return 0;
115 }
116
117 static void MDI_PostUpdate(HWND hwnd, MDICLIENTINFO* ci, WORD recalc)
118 {
119 if( !(ci->mdiFlags & MDIF_NEEDUPDATE) )
120 {
121 ci->mdiFlags |= MDIF_NEEDUPDATE;
122 PostMessageA( hwnd, WM_MDICALCCHILDSCROLL, 0, 0);
123 }
124 ci->sbRecalc = recalc;
125 }
126
127 /**********************************************************************
128 * MDI_MenuModifyItem
129 */
130 static BOOL MDI_MenuModifyItem(WND* clientWnd, HWND hWndChild )
131 {
132 WCHAR buffer[128];
133 static const WCHAR format[] = {'%','d',' ',0};
134 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
135 WND *wndPtr = WIN_FindWndPtr(hWndChild);
136 UINT n = wsprintfW(buffer, format,
137 wndPtr->wIDmenu - clientInfo->idFirstChild + 1);
138 BOOL bRet = 0;
139
140 if( !clientInfo->hWindowMenu )
141 {
142 bRet = FALSE;
143 goto END;
144 }
145
146 if (wndPtr->text) lstrcpynW(buffer + n, wndPtr->text, sizeof(buffer)/sizeof(WCHAR) - n );
147
148 n = GetMenuState(clientInfo->hWindowMenu,wndPtr->wIDmenu ,MF_BYCOMMAND);
149 bRet = ModifyMenuW(clientInfo->hWindowMenu , wndPtr->wIDmenu,
150 MF_BYCOMMAND | MF_STRING, wndPtr->wIDmenu, buffer );
151 CheckMenuItem(clientInfo->hWindowMenu ,wndPtr->wIDmenu , n & MF_CHECKED);
152 END:
153 WIN_ReleaseWndPtr(wndPtr);
154 return bRet;
155 }
156
157 /**********************************************************************
158 * MDI_MenuDeleteItem
159 */
160 static BOOL MDI_MenuDeleteItem(WND* clientWnd, HWND hWndChild )
161 {
162 WCHAR buffer[128];
163 static const WCHAR format[] = {'&','%','d',' ',0};
164 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
165 WND *wndPtr = WIN_FindWndPtr(hWndChild);
166 UINT index = 0,id,n;
167 BOOL retvalue;
168
169 if( !clientInfo->nActiveChildren ||
170 !clientInfo->hWindowMenu )
171 {
172 retvalue = FALSE;
173 goto END;
174 }
175
176 id = wndPtr->wIDmenu;
177 DeleteMenu(clientInfo->hWindowMenu,id,MF_BYCOMMAND);
178
179 /* walk the rest of MDI children to prevent gaps in the id
180 * sequence and in the menu child list */
181
182 for( index = id+1; index <= clientInfo->nActiveChildren +
183 clientInfo->idFirstChild; index++ )
184 {
185 WND *tmpWnd = WIN_FindWndPtr(MDI_GetChildByID(clientWnd,index));
186 if( !tmpWnd )
187 {
188 TRACE("no window for id=%i\n",index);
189 WIN_ReleaseWndPtr(tmpWnd);
190 continue;
191 }
192
193 /* set correct id */
194 tmpWnd->wIDmenu--;
195
196 n = wsprintfW(buffer, format ,index - clientInfo->idFirstChild);
197 if (tmpWnd->text)
198 lstrcpynW(buffer + n, tmpWnd->text, sizeof(buffer)/sizeof(WCHAR) - n );
199
200 /* change menu if the current child is to be shown in the
201 * "Windows" menu
202 */
203 if (index <= clientInfo->idFirstChild + MDI_MOREWINDOWSLIMIT)
204 ModifyMenuW(clientInfo->hWindowMenu ,index ,MF_BYCOMMAND | MF_STRING,
205 index - 1 , buffer );
206 WIN_ReleaseWndPtr(tmpWnd);
207 }
208
209 /* We must restore the "More Windows..." option if there is enough child
210 */
211 if (clientInfo->nActiveChildren - 1 > MDI_MOREWINDOWSLIMIT)
212 {
213 char szTmp[50];
214 LoadStringA(GetModuleHandleA("USER32"), MDI_IDS_MOREWINDOWS, szTmp, 50);
215
216 AppendMenuA(clientInfo->hWindowMenu ,MF_STRING ,clientInfo->idFirstChild + MDI_MOREWINDOWSLIMIT, szTmp );
217 }
218 retvalue = TRUE;
219 END:
220 WIN_ReleaseWndPtr(wndPtr);
221 return retvalue;
222 }
223
224 /**********************************************************************
225 * MDI_GetWindow
226 *
227 * returns "activateable" child different from the current or zero
228 */
229 static HWND MDI_GetWindow(WND *clientWnd, HWND hWnd, BOOL bNext,
230 DWORD dwStyleMask )
231 {
232 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
233 WND *wndPtr, *pWnd, *pWndLast = NULL;
234
235 dwStyleMask |= WS_DISABLED | WS_VISIBLE;
236 if( !hWnd ) hWnd = clientInfo->hwndActiveChild;
237
238 if( !(wndPtr = WIN_FindWndPtr(hWnd)) ) return 0;
239
240 for ( pWnd = WIN_LockWndPtr(wndPtr->next); ; WIN_UpdateWndPtr(&pWnd,pWnd->next))
241 {
242 if (!pWnd ) WIN_UpdateWndPtr(&pWnd,wndPtr->parent->child);
243
244 if ( pWnd == wndPtr ) break; /* went full circle */
245
246 if (!pWnd->owner && (pWnd->dwStyle & dwStyleMask) == WS_VISIBLE )
247 {
248 pWndLast = pWnd;
249 if ( bNext ) break;
250 }
251 }
252 WIN_ReleaseWndPtr(wndPtr);
253 WIN_ReleaseWndPtr(pWnd);
254 return pWndLast ? pWndLast->hwndSelf : 0;
255 }
256
257 /**********************************************************************
258 * MDI_CalcDefaultChildPos
259 *
260 * It seems that the default height is about 2/3 of the client rect
261 */
262 static void MDI_CalcDefaultChildPos( WND* w, WORD n, LPPOINT lpPos,
263 INT delta)
264 {
265 INT nstagger;
266 RECT rect = w->rectClient;
267 INT spacing = GetSystemMetrics(SM_CYCAPTION) +
268 GetSystemMetrics(SM_CYFRAME) - 1;
269
270 if( rect.bottom - rect.top - delta >= spacing )
271 rect.bottom -= delta;
272
273 nstagger = (rect.bottom - rect.top)/(3 * spacing);
274 lpPos[1].x = (rect.right - rect.left - nstagger * spacing);
275 lpPos[1].y = (rect.bottom - rect.top - nstagger * spacing);
276 lpPos[0].x = lpPos[0].y = spacing * (n%(nstagger+1));
277 }
278
279 /**********************************************************************
280 * MDISetMenu
281 */
282 static LRESULT MDISetMenu( HWND hwnd, HMENU hmenuFrame,
283 HMENU hmenuWindow)
284 {
285 WND *w;
286 MDICLIENTINFO *ci;
287 HWND hwndFrame = GetParent(hwnd);
288 HMENU oldFrameMenu = GetMenu(hwndFrame);
289
290 TRACE("%04x %04x %04x\n",
291 hwnd, hmenuFrame, hmenuWindow);
292
293 if (hmenuFrame && !IsMenu(hmenuFrame))
294 {
295 WARN("hmenuFrame is not a menu handle\n");
296 return 0L;
297 }
298
299 if (hmenuWindow && !IsMenu(hmenuWindow))
300 {
301 WARN("hmenuWindow is not a menu handle\n");
302 return 0L;
303 }
304
305 w = WIN_FindWndPtr(hwnd);
306 ci = (MDICLIENTINFO *) w->wExtra;
307
308 if( ci->hwndChildMaximized && hmenuFrame && hmenuFrame!=oldFrameMenu )
309 MDI_RestoreFrameMenu(w->parent, ci->hwndChildMaximized );
310
311 if( hmenuWindow && ci->hWindowMenu && hmenuWindow!=ci->hWindowMenu )
312 {
313 /* delete menu items from ci->hWindowMenu
314 * and add them to hmenuWindow */
315
316 INT i = GetMenuItemCount(ci->hWindowMenu) - 1;
317 INT pos = GetMenuItemCount(hmenuWindow) + 1;
318
319 AppendMenuA( hmenuWindow, MF_SEPARATOR, 0, NULL);
320
321 if( ci->nActiveChildren )
322 {
323 INT j;
324 LPWSTR buffer = NULL;
325 MENUITEMINFOW mii;
326 INT nbWindowsMenuItems; /* num of documents shown + "More Windows..." if present */
327
328 if (ci->nActiveChildren <= MDI_MOREWINDOWSLIMIT)
329 nbWindowsMenuItems = ci->nActiveChildren;
330 else
331 nbWindowsMenuItems = MDI_MOREWINDOWSLIMIT + 1;
332
333 j = i - nbWindowsMenuItems + 1;
334
335 for( ; i >= j ; i-- )
336 {
337 memset(&mii, 0, sizeof(mii));
338 mii.cbSize = sizeof(mii);
339 mii.fMask = MIIM_CHECKMARKS | MIIM_DATA | MIIM_ID | MIIM_STATE
340 | MIIM_SUBMENU | MIIM_TYPE | MIIM_BITMAP;
341
342 GetMenuItemInfoW(ci->hWindowMenu, i, TRUE, &mii);
343 if(mii.cch) { /* Menu is MFT_STRING */
344 mii.cch++; /* add room for '\0' */
345 buffer = HeapAlloc(GetProcessHeap(), 0,
346 mii.cch * sizeof(WCHAR));
347 mii.dwTypeData = buffer;
348 GetMenuItemInfoW(ci->hWindowMenu, i, TRUE, &mii);
349 }
350 DeleteMenu(ci->hWindowMenu, i, MF_BYPOSITION);
351 InsertMenuItemW(hmenuWindow, pos, TRUE, &mii);
352 if(buffer) {
353 HeapFree(GetProcessHeap(), 0, buffer);
354 buffer = NULL;
355 }
356 }
357 }
358
359 /* remove separator */
360 DeleteMenu(ci->hWindowMenu, i, MF_BYPOSITION);
361
362 ci->hWindowMenu = hmenuWindow;
363 }
364
365 if (hmenuFrame)
366 {
367 SetMenu(hwndFrame, hmenuFrame);
368 if( hmenuFrame!=oldFrameMenu )
369 {
370 if( ci->hwndChildMaximized )
371 MDI_AugmentFrameMenu(ci, w->parent, ci->hwndChildMaximized );
372 WIN_ReleaseWndPtr(w);
373 return oldFrameMenu;
374 }
375 }
376 else
377 {
378 INT nItems = GetMenuItemCount(w->parent->wIDmenu) - 1;
379 UINT iId = GetMenuItemID(w->parent->wIDmenu,nItems) ;
380
381 if( !(iId == SC_RESTORE || iId == SC_CLOSE) )
382 {
383 /* SetMenu() may already have been called, meaning that this window
384 * already has its menu. But they may have done a SetMenu() on
385 * an MDI window, and called MDISetMenu() after the fact, meaning
386 * that the "if" to this "else" wouldn't catch the need to
387 * augment the frame menu.
388 */
389 if( ci->hwndChildMaximized )
390 MDI_AugmentFrameMenu(ci, w->parent, ci->hwndChildMaximized );
391 }
392 }
393 WIN_ReleaseWndPtr(w);
394 return 0;
395 }
396
397 /**********************************************************************
398 * MDIRefreshMenu
399 */
400 static LRESULT MDIRefreshMenu( HWND hwnd, HMENU hmenuFrame,
401 HMENU hmenuWindow)
402 {
403 HWND hwndFrame = GetParent(hwnd);
404 HMENU oldFrameMenu = GetMenu(hwndFrame);
405
406 TRACE("%04x %04x %04x\n",
407 hwnd, hmenuFrame, hmenuWindow);
408
409 FIXME("partially function stub\n");
410
411 return oldFrameMenu;
412 }
413
414
415 /* ------------------ MDI child window functions ---------------------- */
416
417
418 /**********************************************************************
419 * MDICreateChild
420 */
421 static HWND MDICreateChild( WND *w, MDICLIENTINFO *ci, HWND parent,
422 LPMDICREATESTRUCTA cs )
423 {
424 POINT pos[2];
425 DWORD style = cs->style | (WS_CHILD | WS_CLIPSIBLINGS);
426 HWND hwnd, hwndMax = 0;
427 WORD wIDmenu = ci->idFirstChild + ci->nActiveChildren;
428 char lpstrDef[]="junk!";
429
430 TRACE("origin %i,%i - dim %i,%i, style %08x\n",
431 cs->x, cs->y, cs->cx, cs->cy, (unsigned)cs->style);
432 /* calculate placement */
433 MDI_CalcDefaultChildPos(w, ci->nTotalCreated++, pos, 0);
434
435 if (cs->cx == CW_USEDEFAULT || !cs->cx) cs->cx = pos[1].x;
436 if (cs->cy == CW_USEDEFAULT || !cs->cy) cs->cy = pos[1].y;
437
438 if( cs->x == CW_USEDEFAULT )
439 {
440 cs->x = pos[0].x;
441 cs->y = pos[0].y;
442 }
443
444 /* restore current maximized child */
445 if( style & WS_VISIBLE && ci->hwndChildMaximized )
446 {
447 if( style & WS_MAXIMIZE )
448 SendMessageA(w->hwndSelf, WM_SETREDRAW, FALSE, 0L );
449 hwndMax = ci->hwndChildMaximized;
450 ShowWindow( hwndMax, SW_SHOWNOACTIVATE );
451 if( style & WS_MAXIMIZE )
452 SendMessageA(w->hwndSelf, WM_SETREDRAW, TRUE, 0L );
453 }
454
455 if (ci->nActiveChildren <= MDI_MOREWINDOWSLIMIT)
456 /* this menu is needed to set a check mark in MDI_ChildActivate */
457 if (ci->hWindowMenu != 0)
458 AppendMenuA(ci->hWindowMenu ,MF_STRING ,wIDmenu, lpstrDef );
459
460 ci->nActiveChildren++;
461
462 /* fix window style */
463 if( !(w->dwStyle & MDIS_ALLCHILDSTYLES) )
464 {
465 style &= (WS_CHILD | WS_CLIPSIBLINGS | WS_MINIMIZE | WS_MAXIMIZE |
466 WS_CLIPCHILDREN | WS_DISABLED | WS_VSCROLL | WS_HSCROLL );
467 style |= (WS_VISIBLE | WS_OVERLAPPEDWINDOW);
468 }
469
470 if( w->flags & WIN_ISWIN32 )
471 {
472 hwnd = CreateWindowA( cs->szClass, cs->szTitle, style,
473 cs->x, cs->y, cs->cx, cs->cy, parent,
474 (HMENU16)wIDmenu, cs->hOwner, cs );
475 }
476 else
477 {
478 MDICREATESTRUCT16 *cs16;
479 LPSTR title, cls;
480
481 cs16 = SEGPTR_NEW(MDICREATESTRUCT16);
482 STRUCT32_MDICREATESTRUCT32Ato16( cs, cs16 );
483 title = SEGPTR_STRDUP( cs->szTitle );
484 cls = SEGPTR_STRDUP( cs->szClass );
485 cs16->szTitle = SEGPTR_GET(title);
486 cs16->szClass = SEGPTR_GET(cls);
487
488 hwnd = CreateWindow16( cs->szClass, cs->szTitle, style,
489 cs16->x, cs16->y, cs16->cx, cs16->cy, parent,
490 (HMENU)wIDmenu, cs16->hOwner,
491 (LPVOID)SEGPTR_GET(cs16) );
492 SEGPTR_FREE( title );
493 SEGPTR_FREE( cls );
494 SEGPTR_FREE( cs16 );
495 }
496
497 /* MDI windows are WS_CHILD so they won't be activated by CreateWindow */
498
499 if (hwnd)
500 {
501 WND* wnd = WIN_FindWndPtr( hwnd );
502
503 /* All MDI child windows have the WS_EX_MDICHILD style */
504 wnd->dwExStyle |= WS_EX_MDICHILD;
505
506 /* If we have more than 9 windows, we must insert the new one at the
507 * 9th position in order to see it in the "Windows" menu
508 */
509 if (ci->nActiveChildren > MDI_MOREWINDOWSLIMIT)
510 MDI_SwapMenuItems(wnd->parent, wnd->wIDmenu, ci->idFirstChild + MDI_MOREWINDOWSLIMIT - 1);
511
512 MDI_MenuModifyItem(w ,hwnd);
513
514 /* Have we hit the "More Windows..." limit? If so, we must
515 * add a "More Windows..." option
516 */
517 if (ci->nActiveChildren == MDI_MOREWINDOWSLIMIT + 1)
518 {
519 char szTmp[50];
520 LoadStringA(GetModuleHandleA("USER32"), MDI_IDS_MOREWINDOWS, szTmp, 50);
521
522 ModifyMenuA(ci->hWindowMenu,
523 ci->idFirstChild + MDI_MOREWINDOWSLIMIT,
524 MF_BYCOMMAND | MF_STRING,
525 ci->idFirstChild + MDI_MOREWINDOWSLIMIT,
526 szTmp);
527 }
528
529 if( wnd->dwStyle & WS_MINIMIZE && ci->hwndActiveChild )
530 ShowWindow( hwnd, SW_SHOWMINNOACTIVE );
531 else
532 {
533 /* WS_VISIBLE is clear if a) the MDI client has
534 * MDIS_ALLCHILDSTYLES style and 2) the flag is cleared in the
535 * MDICreateStruct. If so the created window is not shown nor
536 * activated.
537 */
538 int showflag=wnd->dwStyle & WS_VISIBLE;
539 /* clear visible flag, otherwise SetWindoPos32 ignores
540 * the SWP_SHOWWINDOW command.
541 */
542 wnd->dwStyle &= ~WS_VISIBLE;
543 if(showflag){
544 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE );
545
546 /* Set maximized state here in case hwnd didn't receive WM_SIZE
547 * during CreateWindow - bad!
548 */
549
550 if((wnd->dwStyle & WS_MAXIMIZE) && !ci->hwndChildMaximized )
551 {
552 ci->hwndChildMaximized = wnd->hwndSelf;
553 MDI_AugmentFrameMenu( ci, w->parent, hwnd );
554 MDI_UpdateFrameText( w->parent, ci->self, MDI_REPAINTFRAME, NULL );
555 }
556 }else
557 /* needed, harmless ? */
558 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE );
559
560 }
561 WIN_ReleaseWndPtr(wnd);
562 TRACE("created child - %04x\n",hwnd);
563 }
564 else
565 {
566 ci->nActiveChildren--;
567 DeleteMenu(ci->hWindowMenu,wIDmenu,MF_BYCOMMAND);
568 if( IsWindow(hwndMax) )
569 ShowWindow(hwndMax, SW_SHOWMAXIMIZED);
570 }
571
572 return hwnd;
573 }
574
575 /**********************************************************************
576 * MDI_ChildGetMinMaxInfo
577 *
578 * Note: The rule here is that client rect of the maximized MDI child
579 * is equal to the client rect of the MDI client window.
580 */
581 static void MDI_ChildGetMinMaxInfo( WND* clientWnd, HWND hwnd,
582 MINMAXINFO16* lpMinMax )
583 {
584 WND* childWnd = WIN_FindWndPtr(hwnd);
585 RECT rect = clientWnd->rectClient;
586
587 MapWindowPoints( clientWnd->parent->hwndSelf,
588 ((MDICLIENTINFO*)clientWnd->wExtra)->self, (LPPOINT)&rect, 2);
589 AdjustWindowRectEx( &rect, childWnd->dwStyle, 0, childWnd->dwExStyle );
590
591 lpMinMax->ptMaxSize.x = rect.right -= rect.left;
592 lpMinMax->ptMaxSize.y = rect.bottom -= rect.top;
593
594 lpMinMax->ptMaxPosition.x = rect.left;
595 lpMinMax->ptMaxPosition.y = rect.top;
596
597 WIN_ReleaseWndPtr(childWnd);
598
599 TRACE("max rect (%i,%i - %i, %i)\n",
600 rect.left,rect.top,rect.right,rect.bottom);
601
602 }
603
604 /**********************************************************************
605 * MDI_SwitchActiveChild
606 *
607 * Note: SetWindowPos sends WM_CHILDACTIVATE to the child window that is
608 * being activated
609 */
610 static void MDI_SwitchActiveChild( HWND clientHwnd, HWND childHwnd,
611 BOOL bNextWindow )
612 {
613 WND *w = WIN_FindWndPtr(clientHwnd);
614 HWND hwndTo = 0;
615 HWND hwndPrev = 0;
616 MDICLIENTINFO *ci;
617
618 hwndTo = MDI_GetWindow(w, childHwnd, bNextWindow, 0);
619
620 ci = (MDICLIENTINFO *) w->wExtra;
621
622 TRACE("from %04x, to %04x\n",childHwnd,hwndTo);
623
624 if ( !hwndTo ) goto END; /* no window to switch to */
625
626 hwndPrev = ci->hwndActiveChild;
627
628 if ( hwndTo != hwndPrev )
629 {
630 BOOL bOptimize = 0;
631
632 if( ci->hwndChildMaximized )
633 {
634 bOptimize = 1;
635 w->dwStyle &= ~WS_VISIBLE;
636 }
637
638 SetWindowPos( hwndTo, HWND_TOP, 0, 0, 0, 0,
639 SWP_NOMOVE | SWP_NOSIZE );
640
641 if( bNextWindow && hwndPrev )
642 SetWindowPos( hwndPrev, HWND_BOTTOM, 0, 0, 0, 0,
643 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE );
644 if( bOptimize )
645 ShowWindow( clientHwnd, SW_SHOW );
646 }
647 END:
648 WIN_ReleaseWndPtr(w);
649 }
650
651
652 /**********************************************************************
653 * MDIDestroyChild
654 */
655 static LRESULT MDIDestroyChild( WND *w_parent, MDICLIENTINFO *ci,
656 HWND parent, HWND child,
657 BOOL flagDestroy )
658 {
659 WND *childPtr = WIN_FindWndPtr(child);
660
661 if( childPtr )
662 {
663 MDI_MenuDeleteItem(w_parent, child);
664
665 if( child == ci->hwndActiveChild )
666 {
667 MDI_SwitchActiveChild(parent, child, TRUE);
668
669 if( child == ci->hwndActiveChild )
670 {
671 ShowWindow( child, SW_HIDE);
672 if( child == ci->hwndChildMaximized )
673 {
674 MDI_RestoreFrameMenu(w_parent->parent, child);
675 ci->hwndChildMaximized = 0;
676 MDI_UpdateFrameText(w_parent->parent,parent,TRUE,NULL);
677 }
678
679 MDI_ChildActivate(w_parent, 0);
680 }
681 }
682
683 WIN_ReleaseWndPtr(childPtr);
684
685 ci->nActiveChildren--;
686
687 TRACE("child destroyed - %04x\n",child);
688
689 if (flagDestroy)
690 {
691 MDI_PostUpdate(GetParent(child), ci, SB_BOTH+1);
692 DestroyWindow(child);
693 }
694 }
695
696 return 0;
697 }
698
699
700 /**********************************************************************
701 * MDI_ChildActivate
702 *
703 * Note: hWndChild is NULL when last child is being destroyed
704 */
705 static LONG MDI_ChildActivate( WND *clientPtr, HWND hWndChild )
706 {
707 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientPtr->wExtra;
708 HWND prevActiveWnd = clientInfo->hwndActiveChild;
709 WND *wndPtr = WIN_FindWndPtr( hWndChild );
710 WND *wndPrev = WIN_FindWndPtr( prevActiveWnd );
711 BOOL isActiveFrameWnd = 0;
712 LONG retvalue;
713
714 if( wndPtr )
715 {
716 if( wndPtr->dwStyle & WS_DISABLED )
717 {
718 retvalue = 0L;
719 goto END;
720 }
721 }
722
723 /* Don't activate if it is already active. Might happen
724 since ShowWindow DOES activate MDI children */
725 if (clientInfo->hwndActiveChild == hWndChild)
726 {
727 retvalue = 0L;
728 goto END;
729 }
730
731 TRACE("%04x\n", hWndChild);
732
733 if( GetActiveWindow() == clientPtr->parent->hwndSelf )
734 isActiveFrameWnd = TRUE;
735
736 /* deactivate prev. active child */
737 if( wndPrev )
738 {
739 wndPrev->dwStyle |= WS_SYSMENU;
740 SendMessageA( prevActiveWnd, WM_NCACTIVATE, FALSE, 0L );
741 SendMessageA( prevActiveWnd, WM_MDIACTIVATE, (WPARAM)prevActiveWnd,
742 (LPARAM)hWndChild);
743 /* uncheck menu item */
744 if( clientInfo->hWindowMenu )
745 {
746 WORD wPrevID = wndPrev->wIDmenu - clientInfo->idFirstChild;
747
748 if (wPrevID < MDI_MOREWINDOWSLIMIT)
749 CheckMenuItem( clientInfo->hWindowMenu,
750 wndPrev->wIDmenu, 0);
751 else
752 CheckMenuItem( clientInfo->hWindowMenu,
753 clientInfo->idFirstChild + MDI_MOREWINDOWSLIMIT - 1, 0);
754 }
755 }
756
757 /* set appearance */
758 if( clientInfo->hwndChildMaximized )
759 {
760 if( clientInfo->hwndChildMaximized != hWndChild ) {
761 if( hWndChild ) {
762 clientInfo->hwndActiveChild = hWndChild;
763 ShowWindow( hWndChild, SW_SHOWMAXIMIZED);
764 } else
765 ShowWindow( clientInfo->hwndActiveChild, SW_SHOWNORMAL );
766 }
767 }
768
769 clientInfo->hwndActiveChild = hWndChild;
770
771 /* check if we have any children left */
772 if( !hWndChild )
773 {
774 if( isActiveFrameWnd )
775 SetFocus( clientInfo->self );
776 retvalue = 0;
777 goto END;
778 }
779
780 /* check menu item */
781 if( clientInfo->hWindowMenu )
782 {
783 /* The window to be activated must be displayed in the "Windows" menu */
784 if (wndPtr->wIDmenu >= clientInfo->idFirstChild + MDI_MOREWINDOWSLIMIT)
785 {
786 MDI_SwapMenuItems(wndPtr->parent, wndPtr->wIDmenu, clientInfo->idFirstChild + MDI_MOREWINDOWSLIMIT - 1);
787 MDI_MenuModifyItem(wndPtr->parent ,wndPtr->hwndSelf);
788 }
789
790 CheckMenuItem(clientInfo->hWindowMenu, wndPtr->wIDmenu, MF_CHECKED);
791 }
792 /* bring active child to the top */
793 SetWindowPos( hWndChild, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
794
795 if( isActiveFrameWnd )
796 {
797 SendMessageA( hWndChild, WM_NCACTIVATE, TRUE, 0L);
798 if( GetFocus() == clientInfo->self )
799 SendMessageA( clientInfo->self, WM_SETFOCUS,
800 (WPARAM)clientInfo->self, 0L );
801 else
802 SetFocus( clientInfo->self );
803 }
804 SendMessageA( hWndChild, WM_MDIACTIVATE, (WPARAM)prevActiveWnd,
805 (LPARAM)hWndChild );
806 retvalue = 1;
807 END:
808 WIN_ReleaseWndPtr(wndPtr);
809 WIN_ReleaseWndPtr(wndPrev);
810 return retvalue;
811 }
812
813 /* -------------------- MDI client window functions ------------------- */
814
815 /**********************************************************************
816 * CreateMDIMenuBitmap
817 */
818 static HBITMAP16 CreateMDIMenuBitmap(void)
819 {
820 HDC hDCSrc = CreateCompatibleDC(0);
821 HDC hDCDest = CreateCompatibleDC(hDCSrc);
822 HBITMAP16 hbClose = LoadBitmap16(0, MAKEINTRESOURCE16(OBM_CLOSE) );
823 HBITMAP16 hbCopy;
824 HANDLE16 hobjSrc, hobjDest;
825
826 hobjSrc = SelectObject(hDCSrc, hbClose);
827 hbCopy = CreateCompatibleBitmap(hDCSrc,GetSystemMetrics(SM_CXSIZE),GetSystemMetrics(SM_CYSIZE));
828 hobjDest = SelectObject(hDCDest, hbCopy);
829
830 BitBlt(hDCDest, 0, 0, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
831 hDCSrc, GetSystemMetrics(SM_CXSIZE), 0, SRCCOPY);
832
833 SelectObject(hDCSrc, hobjSrc);
834 DeleteObject(hbClose);
835 DeleteDC(hDCSrc);
836
837 hobjSrc = SelectObject( hDCDest, GetStockObject(BLACK_PEN) );
838
839 MoveToEx( hDCDest, GetSystemMetrics(SM_CXSIZE) - 1, 0, NULL );
840 LineTo( hDCDest, GetSystemMetrics(SM_CXSIZE) - 1, GetSystemMetrics(SM_CYSIZE) - 1);
841
842 SelectObject(hDCDest, hobjSrc );
843 SelectObject(hDCDest, hobjDest);
844 DeleteDC(hDCDest);
845
846 return hbCopy;
847 }
848
849 /**********************************************************************
850 * MDICascade
851 */
852 static LONG MDICascade(WND* clientWnd, MDICLIENTINFO *ci)
853 {
854 WND** ppWnd;
855 UINT total;
856
857 if (ci->hwndChildMaximized)
858 SendMessageA( clientWnd->hwndSelf, WM_MDIRESTORE,
859 (WPARAM)ci->hwndChildMaximized, 0);
860
861 if (ci->nActiveChildren == 0) return 0;
862
863 if ((ppWnd = WIN_BuildWinArray(clientWnd, BWA_SKIPHIDDEN | BWA_SKIPOWNED |
864 BWA_SKIPICONIC, &total)))
865 {
866 WND** heapPtr = ppWnd;
867 if( total )
868 {
869 INT delta = 0, n = 0;
870 POINT pos[2];
871 if( total < ci->nActiveChildren )
872 delta = GetSystemMetrics(SM_CYICONSPACING) +
873 GetSystemMetrics(SM_CYICON);
874
875 /* walk the list (backwards) and move windows */
876 while (*ppWnd) ppWnd++;
877 while (ppWnd != heapPtr)
878 {
879 ppWnd--;
880 TRACE("move %04x to (%ld,%ld) size [%ld,%ld]\n",
881 (*ppWnd)->hwndSelf, pos[0].x, pos[0].y, pos[1].x, pos[1].y);
882
883 MDI_CalcDefaultChildPos(clientWnd, n++, pos, delta);
884 SetWindowPos( (*ppWnd)->hwndSelf, 0, pos[0].x, pos[0].y,
885 pos[1].x, pos[1].y,
886 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
887 }
888 }
889 WIN_ReleaseWinArray(heapPtr);
890 }
891
892 if( total < ci->nActiveChildren )
893 ArrangeIconicWindows( clientWnd->hwndSelf );
894 return 0;
895 }
896
897 /**********************************************************************
898 * MDITile
899 */
900 static void MDITile( WND* wndClient, MDICLIENTINFO *ci, WPARAM wParam )
901 {
902 WND** ppWnd;
903 UINT total = 0;
904
905 if (ci->hwndChildMaximized)
906 SendMessageA( wndClient->hwndSelf, WM_MDIRESTORE,
907 (WPARAM)ci->hwndChildMaximized, 0);
908
909 if (ci->nActiveChildren == 0) return;
910
911 ppWnd = WIN_BuildWinArray(wndClient, BWA_SKIPHIDDEN | BWA_SKIPOWNED | BWA_SKIPICONIC |
912 ((wParam & MDITILE_SKIPDISABLED)? BWA_SKIPDISABLED : 0), &total );
913
914 TRACE("%u windows to tile\n", total);
915
916 if( ppWnd )
917 {
918 WND** heapPtr = ppWnd;
919
920 if( total )
921 {
922 RECT rect;
923 int x, y, xsize, ysize;
924 int rows, columns, r, c, i;
925
926 GetClientRect(wndClient->hwndSelf,&rect);
927 rows = (int) sqrt((double)total);
928 columns = total / rows;
929
930 if( wParam & MDITILE_HORIZONTAL ) /* version >= 3.1 */
931 {
932 i = rows;
933 rows = columns; /* exchange r and c */
934 columns = i;
935 }
936
937 if( total != ci->nActiveChildren)
938 {
939 y = rect.bottom - 2 * GetSystemMetrics(SM_CYICONSPACING) - GetSystemMetrics(SM_CYICON);
940 rect.bottom = ( y - GetSystemMetrics(SM_CYICON) < rect.top )? rect.bottom: y;
941 }
942
943 ysize = rect.bottom / rows;
944 xsize = rect.right / columns;
945
946 for (x = i = 0, c = 1; c <= columns && *ppWnd; c++)
947 {
948 if (c == columns)
949 {
950 rows = total - i;
951 ysize = rect.bottom / rows;
952 }
953
954 y = 0;
955 for (r = 1; r <= rows && *ppWnd; r++, i++)
956 {
957 SetWindowPos((*ppWnd)->hwndSelf, 0, x, y, xsize, ysize,
958 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
959 y += ysize;
960 ppWnd++;
961 }
962 x += xsize;
963 }
964 }
965 WIN_ReleaseWinArray(heapPtr);
966 }
967
968 if( total < ci->nActiveChildren ) ArrangeIconicWindows( wndClient->hwndSelf );
969 }
970
971 /* ----------------------- Frame window ---------------------------- */
972
973
974 /**********************************************************************
975 * MDI_AugmentFrameMenu
976 */
977 static BOOL MDI_AugmentFrameMenu( MDICLIENTINFO* ci, WND *frame,
978 HWND hChild )
979 {
980 WND* child = WIN_FindWndPtr(hChild);
981 HMENU hSysPopup = 0;
982 HBITMAP hSysMenuBitmap = 0;
983
984 TRACE("frame %p,child %04x\n",frame,hChild);
985
986 if( !frame->wIDmenu || !child->hSysMenu )
987 {
988 WIN_ReleaseWndPtr(child);
989 return 0;
990 }
991 WIN_ReleaseWndPtr(child);
992
993 /* create a copy of sysmenu popup and insert it into frame menu bar */
994
995 if (!(hSysPopup = LoadMenuA(GetModuleHandleA("USER32"), "SYSMENU")))
996 return 0;
997
998 TRACE("\tgot popup %04x in sysmenu %04x\n",
999 hSysPopup, child->hSysMenu);
1000
1001 AppendMenuA(frame->wIDmenu,MF_HELP | MF_BITMAP,
1002 SC_MINIMIZE, (LPSTR)(DWORD)HBMMENU_MBAR_MINIMIZE ) ;
1003 AppendMenuA(frame->wIDmenu,MF_HELP | MF_BITMAP,
1004 SC_RESTORE, (LPSTR)(DWORD)HBMMENU_MBAR_RESTORE );
1005
1006 /* In Win 95 look, the system menu is replaced by the child icon */
1007
1008 if(TWEAK_WineLook > WIN31_LOOK)
1009 {
1010 HICON hIcon = GetClassLongA(hChild, GCL_HICONSM);
1011 if (!hIcon)
1012 hIcon = GetClassLongA(hChild, GCL_HICON);
1013 if (hIcon)
1014 {
1015 HDC hMemDC;
1016 HBITMAP hBitmap, hOldBitmap;
1017 HBRUSH hBrush;
1018 HDC hdc = GetDC(hChild);
1019
1020 if (hdc)
1021 {
1022 int cx, cy;
1023 cx = GetSystemMetrics(SM_CXSMICON);
1024 cy = GetSystemMetrics(SM_CYSMICON);
1025 hMemDC = CreateCompatibleDC(hdc);
1026 hBitmap = CreateCompatibleBitmap(hdc, cx, cy);
1027 hOldBitmap = SelectObject(hMemDC, hBitmap);
1028 SetMapMode(hMemDC, MM_TEXT);
1029 hBrush = CreateSolidBrush(GetSysColor(COLOR_MENU));
1030 DrawIconEx(hMemDC, 0, 0, hIcon, cx, cy, 0, hBrush, DI_NORMAL);
1031 SelectObject (hMemDC, hOldBitmap);
1032 DeleteObject(hBrush);
1033 DeleteDC(hMemDC);
1034 ReleaseDC(hChild, hdc);
1035 hSysMenuBitmap = hBitmap;
1036 }
1037 }
1038 }
1039 else
1040 hSysMenuBitmap = hBmpClose;
1041
1042 if( !InsertMenuA(frame->wIDmenu,0,MF_BYPOSITION | MF_BITMAP | MF_POPUP,
1043 hSysPopup, (LPSTR)(DWORD)hSysMenuBitmap))
1044 {
1045 TRACE("not inserted\n");
1046 DestroyMenu(hSysPopup);
1047 return 0;
1048 }
1049
1050 /* The close button is only present in Win 95 look */
1051 if(TWEAK_WineLook > WIN31_LOOK)
1052 {
1053 AppendMenuA(frame->wIDmenu,MF_HELP | MF_BITMAP,
1054 SC_CLOSE, (LPSTR)(DWORD)HBMMENU_MBAR_CLOSE );
1055 }
1056
1057 EnableMenuItem(hSysPopup, SC_SIZE, MF_BYCOMMAND | MF_GRAYED);
1058 EnableMenuItem(hSysPopup, SC_MOVE, MF_BYCOMMAND | MF_GRAYED);
1059 EnableMenuItem(hSysPopup, SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED);
1060 SetMenuDefaultItem(hSysPopup, SC_CLOSE, FALSE);
1061
1062 /* redraw menu */
1063 DrawMenuBar(frame->hwndSelf);
1064
1065 return 1;
1066 }
1067
1068 /**********************************************************************
1069 * MDI_RestoreFrameMenu
1070 */
1071 static BOOL MDI_RestoreFrameMenu( WND *frameWnd, HWND hChild )
1072 {
1073 MENUITEMINFOA menuInfo;
1074 INT nItems = GetMenuItemCount(frameWnd->wIDmenu) - 1;
1075 UINT iId = GetMenuItemID(frameWnd->wIDmenu,nItems) ;
1076
1077 TRACE("frameWnd %p,(%04x),child %04x,nIt=%d,iId=%d\n",
1078 frameWnd,frameWnd->hwndSelf,hChild,nItems,iId);
1079
1080 if(!(iId == SC_RESTORE || iId == SC_CLOSE) )
1081 return 0;
1082
1083 /*
1084 * Remove the system menu, If that menu is the icon of the window
1085 * as it is in win95, we have to delete the bitmap.
1086 */
1087 menuInfo.cbSize = sizeof(MENUITEMINFOA);
1088 menuInfo.fMask = MIIM_DATA | MIIM_TYPE;
1089
1090 GetMenuItemInfoA(frameWnd->wIDmenu,
1091 0,
1092 TRUE,
1093 &menuInfo);
1094
1095 RemoveMenu(frameWnd->wIDmenu,0,MF_BYPOSITION);
1096
1097 if ( (menuInfo.fType & MFT_BITMAP) &&
1098 (LOWORD(menuInfo.dwTypeData)!=0) &&
1099 (LOWORD(menuInfo.dwTypeData)!=hBmpClose) )
1100 {
1101 DeleteObject((HBITMAP)LOWORD(menuInfo.dwTypeData));
1102 }
1103
1104 if(TWEAK_WineLook > WIN31_LOOK)
1105 {
1106 /* close */
1107 DeleteMenu(frameWnd->wIDmenu,GetMenuItemCount(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
1108 }
1109 /* restore */
1110 DeleteMenu(frameWnd->wIDmenu,GetMenuItemCount(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
1111 /* minimize */
1112 DeleteMenu(frameWnd->wIDmenu,GetMenuItemCount(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
1113
1114 DrawMenuBar(frameWnd->hwndSelf);
1115
1116 return 1;
1117 }
1118
1119
1120 /**********************************************************************
1121 * MDI_UpdateFrameText
1122 *
1123 * used when child window is maximized/restored
1124 *
1125 * Note: lpTitle can be NULL
1126 */
1127 static void MDI_UpdateFrameText( WND *frameWnd, HWND hClient,
1128 BOOL repaint, LPCWSTR lpTitle )
1129 {
1130 WCHAR lpBuffer[MDI_MAXTITLELENGTH+1];
1131 WND* clientWnd = WIN_FindWndPtr(hClient);
1132 MDICLIENTINFO *ci = (MDICLIENTINFO *) clientWnd->wExtra;
1133
1134 TRACE("repaint %i, frameText %s\n", repaint, (lpTitle)?debugstr_w(lpTitle):"NULL");
1135
1136 if (!clientWnd)
1137 return;
1138
1139 if (!ci)
1140 {
1141 WIN_ReleaseWndPtr(clientWnd);
1142 return;
1143 }
1144
1145 /* store new "default" title if lpTitle is not NULL */
1146 if (lpTitle)
1147 {
1148 if (ci->frameTitle) HeapFree( SystemHeap, 0, ci->frameTitle );
1149 ci->frameTitle = HEAP_strdupW( SystemHeap, 0, lpTitle );
1150 }
1151
1152 if (ci->frameTitle)
1153 {
1154 WND* childWnd = WIN_FindWndPtr( ci->hwndChildMaximized );
1155
1156 if( childWnd && childWnd->text )
1157 {
1158 /* combine frame title and child title if possible */
1159
1160 static const WCHAR lpBracket[] = {' ','-',' ','[',0};
1161 static const WCHAR lpBracket2[] = {']',0};
1162 int i_frame_text_length = strlenW(ci->frameTitle);
1163 int i_child_text_length = strlenW(childWnd->text);
1164
1165 lstrcpynW( lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH);
1166
1167 if( i_frame_text_length + 6 < MDI_MAXTITLELENGTH )
1168 {
1169 strcatW( lpBuffer, lpBracket );
1170
1171 if( i_frame_text_length + i_child_text_length + 6 < MDI_MAXTITLELENGTH )
1172 {
1173 strcatW( lpBuffer, childWnd->text );
1174 strcatW( lpBuffer, lpBracket2 );
1175 }
1176 else
1177 {
1178 lstrcpynW( lpBuffer + i_frame_text_length + 4,
1179 childWnd->text, MDI_MAXTITLELENGTH - i_frame_text_length - 5 );
1180 strcatW( lpBuffer, lpBracket2 );
1181 }
1182 }
1183 }
1184 else
1185 {
1186 lstrcpynW(lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH+1 );
1187 }
1188 WIN_ReleaseWndPtr(childWnd);
1189
1190 }
1191 else
1192 lpBuffer[0] = '\0';
1193
1194 DEFWND_SetTextW( frameWnd, lpBuffer );
1195 if( repaint == MDI_REPAINTFRAME)
1196 SetWindowPos( frameWnd->hwndSelf, 0,0,0,0,0, SWP_FRAMECHANGED |
1197 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER );
1198
1199 WIN_ReleaseWndPtr(clientWnd);
1200
1201 }
1202
1203
1204 /* ----------------------------- Interface ---------------------------- */
1205
1206
1207 /**********************************************************************
1208 * MDIClientWndProc
1209 *
1210 * This function handles all MDI requests.
1211 */
1212 LRESULT WINAPI MDIClientWndProc( HWND hwnd, UINT message, WPARAM wParam,
1213 LPARAM lParam )
1214 {
1215 LPCREATESTRUCTA cs;
1216 MDICLIENTINFO *ci;
1217 RECT rect;
1218 WND *w, *frameWnd;
1219 INT nItems;
1220 LRESULT retvalue;
1221
1222 if ( ( w = WIN_FindWndPtr(hwnd) ) == NULL )
1223 return 0;
1224
1225 if ( ( frameWnd = WIN_LockWndPtr(w->parent) ) == NULL ) {
1226 WIN_ReleaseWndPtr(w);
1227 return 0;
1228 }
1229
1230 ci = (MDICLIENTINFO *) w->wExtra;
1231
1232 switch (message)
1233 {
1234 case WM_CREATE:
1235
1236 cs = (LPCREATESTRUCTA)lParam;
1237
1238 /* Translation layer doesn't know what's in the cs->lpCreateParams
1239 * so we have to keep track of what environment we're in. */
1240
1241 if( w->flags & WIN_ISWIN32 )
1242 {
1243 #define ccs ((LPCLIENTCREATESTRUCT)cs->lpCreateParams)
1244 ci->hWindowMenu = ccs->hWindowMenu;
1245 ci->idFirstChild = ccs->idFirstChild;
1246 #undef ccs
1247 }
1248 else
1249 {
1250 LPCLIENTCREATESTRUCT16 ccs = (LPCLIENTCREATESTRUCT16)
1251 PTR_SEG_TO_LIN(cs->lpCreateParams);
1252 ci->hWindowMenu = ccs->hWindowMenu;
1253 ci->idFirstChild = ccs->idFirstChild;
1254 }
1255
1256 ci->hwndChildMaximized = 0;
1257 ci->nActiveChildren = 0;
1258 ci->nTotalCreated = 0;
1259 ci->frameTitle = NULL;
1260 ci->mdiFlags = 0;
1261 ci->self = hwnd;
1262 w->dwStyle |= WS_CLIPCHILDREN;
1263
1264 if (!hBmpClose)
1265 {
1266 hBmpClose = CreateMDIMenuBitmap();
1267 hBmpRestore = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1268 }
1269 MDI_UpdateFrameText(frameWnd, hwnd, MDI_NOFRAMEREPAINT,frameWnd->text);
1270
1271 if (ci->hWindowMenu != 0)
1272 AppendMenuA( ci->hWindowMenu, MF_SEPARATOR, 0, NULL );
1273
1274 GetClientRect(frameWnd->hwndSelf, &rect);
1275 NC_HandleNCCalcSize( w, &rect );
1276 w->rectClient = rect;
1277
1278 TRACE("Client created - hwnd = %04x, idFirst = %u\n",
1279 hwnd, ci->idFirstChild );
1280
1281 retvalue = 0;
1282 goto END;
1283
1284 case WM_DESTROY:
1285 if( ci->hwndChildMaximized )
1286 MDI_RestoreFrameMenu(w->parent, ci->hwndChildMaximized);
1287 if((ci->hWindowMenu != 0) &&
1288 (nItems = GetMenuItemCount(ci->hWindowMenu)) > 0)
1289 {
1290 ci->idFirstChild = nItems - 1;
1291 ci->nActiveChildren++; /* to delete a separator */
1292 while( ci->nActiveChildren-- )
1293 DeleteMenu(ci->hWindowMenu,MF_BYPOSITION,ci->idFirstChild--);
1294 }
1295 retvalue = 0;
1296 goto END;
1297
1298 case WM_MDIACTIVATE:
1299 if( ci->hwndActiveChild != (HWND)wParam )
1300 SetWindowPos((HWND)wParam, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE);
1301 retvalue = 0;
1302 goto END;
1303
1304 case WM_MDICASCADE:
1305 retvalue = MDICascade(w, ci);
1306 goto END;
1307
1308 case WM_MDICREATE:
1309 if (lParam) retvalue = MDICreateChild( w, ci, hwnd,
1310 (MDICREATESTRUCTA*)lParam );
1311 else retvalue = 0;
1312 goto END;
1313
1314 case WM_MDIDESTROY:
1315 retvalue = MDIDestroyChild( w, ci, hwnd, (HWND)wParam, TRUE );
1316 goto END;
1317
1318 case WM_MDIGETACTIVE:
1319 if (lParam) *(BOOL *)lParam = (ci->hwndChildMaximized > 0);
1320 retvalue = ci->hwndActiveChild;
1321 goto END;
1322
1323 case WM_MDIICONARRANGE:
1324 ci->mdiFlags |= MDIF_NEEDUPDATE;
1325 ArrangeIconicWindows(hwnd);
1326 ci->sbRecalc = SB_BOTH+1;
1327 SendMessageA(hwnd, WM_MDICALCCHILDSCROLL, 0, 0L);
1328 retvalue = 0;
1329 goto END;
1330
1331 case WM_MDIMAXIMIZE:
1332 ShowWindow( (HWND)wParam, SW_MAXIMIZE );
1333 retvalue = 0;
1334 goto END;
1335
1336 case WM_MDINEXT: /* lParam != 0 means previous window */
1337 MDI_SwitchActiveChild(hwnd, (HWND)wParam, (lParam)? FALSE : TRUE );
1338 break;
1339
1340 case WM_MDIRESTORE:
1341 SendMessageA( (HWND)wParam, WM_SYSCOMMAND, SC_RESTORE, 0);
1342 retvalue = 0;
1343 goto END;
1344
1345 case WM_MDISETMENU:
1346 retvalue = MDISetMenu( hwnd, (HMENU)wParam, (HMENU)lParam );
1347 goto END;
1348 case WM_MDIREFRESHMENU:
1349 retvalue = MDIRefreshMenu( hwnd, (HMENU)wParam, (HMENU)lParam );
1350 goto END;
1351
1352 case WM_MDITILE:
1353 ci->mdiFlags |= MDIF_NEEDUPDATE;
1354 ShowScrollBar(hwnd,SB_BOTH,FALSE);
1355 MDITile(w, ci, wParam);
1356 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1357 retvalue = 0;
1358 goto END;
1359
1360 case WM_VSCROLL:
1361 case WM_HSCROLL:
1362 ci->mdiFlags |= MDIF_NEEDUPDATE;
1363 ScrollChildren(hwnd, message, wParam, lParam);
1364 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1365 retvalue = 0;
1366 goto END;
1367
1368 case WM_SETFOCUS:
1369 if( ci->hwndActiveChild )
1370 {
1371 WND* pw = WIN_FindWndPtr( ci->hwndActiveChild );
1372 if( !(pw->dwStyle & WS_MINIMIZE) )
1373 SetFocus( ci->hwndActiveChild );
1374 WIN_ReleaseWndPtr(pw);
1375 }
1376 retvalue = 0;
1377 goto END;
1378
1379 case WM_NCACTIVATE:
1380 if( ci->hwndActiveChild )
1381 SendMessageA(ci->hwndActiveChild, message, wParam, lParam);
1382 break;
1383
1384 case WM_PARENTNOTIFY:
1385 if (LOWORD(wParam) == WM_LBUTTONDOWN)
1386 {
1387 POINT16 pt = MAKEPOINT16(lParam);
1388 HWND16 child = ChildWindowFromPoint16(hwnd, pt);
1389
1390 TRACE("notification from %04x (%i,%i)\n",child,pt.x,pt.y);
1391
1392 if( child && child != hwnd && child != ci->hwndActiveChild )
1393 SetWindowPos(child, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
1394 }
1395 retvalue = 0;
1396 goto END;
1397
1398 case WM_SIZE:
1399 if( IsWindow(ci->hwndChildMaximized) )
1400 {
1401 WND* child = WIN_FindWndPtr(ci->hwndChildMaximized);
1402 RECT rect;
1403
1404 rect.left = 0;
1405 rect.top = 0;
1406 rect.right = LOWORD(lParam);
1407 rect.bottom = HIWORD(lParam);
1408
1409 AdjustWindowRectEx(&rect, child->dwStyle, 0, child->dwExStyle);
1410 MoveWindow(ci->hwndChildMaximized, rect.left, rect.top,
1411 rect.right - rect.left, rect.bottom - rect.top, 1);
1412 WIN_ReleaseWndPtr(child);
1413 }
1414 else
1415 MDI_PostUpdate(hwnd, ci, SB_BOTH+1);
1416
1417 break;
1418
1419 case WM_MDICALCCHILDSCROLL:
1420 if( (ci->mdiFlags & MDIF_NEEDUPDATE) && ci->sbRecalc )
1421 {
1422 CalcChildScroll16(hwnd, ci->sbRecalc-1);
1423 ci->sbRecalc = 0;
1424 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1425 }
1426 retvalue = 0;
1427 goto END;
1428 }
1429
1430 retvalue = DefWindowProcA( hwnd, message, wParam, lParam );
1431 END:
1432 WIN_ReleaseWndPtr(w);
1433 WIN_ReleaseWndPtr(frameWnd);
1434 return retvalue;
1435 }
1436
1437
1438 /***********************************************************************
1439 * DefFrameProc16 (USER.445)
1440 */
1441 LRESULT WINAPI DefFrameProc16( HWND16 hwnd, HWND16 hwndMDIClient,
1442 UINT16 message, WPARAM16 wParam, LPARAM lParam )
1443 {
1444 HWND16 childHwnd;
1445 MDICLIENTINFO* ci;
1446 WND* wndPtr;
1447
1448 if (hwndMDIClient)
1449 {
1450 switch (message)
1451 {
1452 case WM_COMMAND:
1453 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1454
1455 if (!wndPtr) {
1456 ERR("null wndPtr for mdi window hwndMDIClient=%04x\n",
1457 hwndMDIClient);
1458 return 0;
1459 }
1460
1461 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1462
1463 /* check for possible syscommands for maximized MDI child */
1464 WIN_ReleaseWndPtr(wndPtr);
1465
1466 if( ci && (
1467 wParam < ci->idFirstChild ||
1468 wParam >= ci->idFirstChild + ci->nActiveChildren
1469 )){
1470 if( (wParam - 0xF000) & 0xF00F ) break;
1471 switch( wParam )
1472 {
1473 case SC_SIZE:
1474 case SC_MOVE:
1475 case SC_MINIMIZE:
1476 case SC_MAXIMIZE:
1477 case SC_NEXTWINDOW:
1478 case SC_PREVWINDOW:
1479 case SC_CLOSE:
1480 case SC_RESTORE:
1481 if( ci->hwndChildMaximized )
1482 return SendMessage16( ci->hwndChildMaximized, WM_SYSCOMMAND,
1483 wParam, lParam);
1484 }
1485 }
1486 else
1487 {
1488 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1489 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1490
1491 if (wParam - ci->idFirstChild == MDI_MOREWINDOWSLIMIT)
1492 /* User chose "More Windows..." */
1493 childHwnd = MDI_MoreWindowsDialog(wndPtr);
1494 else
1495 /* User chose one of the windows listed in the "Windows" menu */
1496 childHwnd = MDI_GetChildByID(wndPtr,wParam );
1497
1498 WIN_ReleaseWndPtr(wndPtr);
1499 if( childHwnd )
1500 SendMessage16(hwndMDIClient, WM_MDIACTIVATE,
1501 (WPARAM16)childHwnd , 0L);
1502 }
1503 break;
1504
1505 case WM_NCACTIVATE:
1506 SendMessage16(hwndMDIClient, message, wParam, lParam);
1507 break;
1508
1509 case WM_SETTEXT:
1510 {
1511 LPWSTR text = HEAP_strdupAtoW( GetProcessHeap(), 0,
1512 (LPCSTR)PTR_SEG_TO_LIN(lParam) );
1513 wndPtr = WIN_FindWndPtr(hwnd);
1514 MDI_UpdateFrameText(wndPtr, hwndMDIClient,
1515 MDI_REPAINTFRAME, text );
1516 WIN_ReleaseWndPtr(wndPtr);
1517 HeapFree( GetProcessHeap(), 0, text );
1518 }
1519 return 0;
1520
1521 case WM_SETFOCUS:
1522 SetFocus(hwndMDIClient);
1523 break;
1524
1525 case WM_SIZE:
1526 MoveWindow16(hwndMDIClient, 0, 0,
1527 LOWORD(lParam), HIWORD(lParam), TRUE);
1528 break;
1529
1530 case WM_NEXTMENU:
1531
1532 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1533 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1534
1535 if( !(wndPtr->parent->dwStyle & WS_MINIMIZE)
1536 && ci->hwndActiveChild && !ci->hwndChildMaximized )
1537 {
1538 /* control menu is between the frame system menu and
1539 * the first entry of menu bar */
1540
1541 if( (wParam == VK_LEFT &&
1542 wndPtr->parent->wIDmenu == LOWORD(lParam)) ||
1543 (wParam == VK_RIGHT &&
1544 GetSubMenu16(wndPtr->parent->hSysMenu, 0) == LOWORD(lParam)) )
1545 {
1546 LRESULT retvalue;
1547 WIN_ReleaseWndPtr(wndPtr);
1548 wndPtr = WIN_FindWndPtr(ci->hwndActiveChild);
1549 retvalue = MAKELONG( GetSubMenu16(wndPtr->hSysMenu, 0),
1550 ci->hwndActiveChild);
1551 WIN_ReleaseWndPtr(wndPtr);
1552 return retvalue;
1553 }
1554 }
1555 WIN_ReleaseWndPtr(wndPtr);
1556 break;
1557 }
1558 }
1559
1560 return DefWindowProc16(hwnd, message, wParam, lParam);
1561 }
1562
1563
1564 /***********************************************************************
1565 * DefFrameProcA (USER32.122)
1566 */
1567 LRESULT WINAPI DefFrameProcA( HWND hwnd, HWND hwndMDIClient,
1568 UINT message, WPARAM wParam, LPARAM lParam)
1569 {
1570 if (hwndMDIClient)
1571 {
1572 switch (message)
1573 {
1574 case WM_COMMAND:
1575 return DefFrameProc16( hwnd, hwndMDIClient, message,
1576 (WPARAM16)wParam,
1577 MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ) );
1578
1579 case WM_NCACTIVATE:
1580 SendMessageA(hwndMDIClient, message, wParam, lParam);
1581 break;
1582
1583 case WM_SETTEXT: {
1584 LRESULT ret;
1585 LPSTR segstr = SEGPTR_STRDUP((LPSTR)lParam);
1586
1587 ret = DefFrameProc16(hwnd, hwndMDIClient, message,
1588 wParam, (LPARAM)SEGPTR_GET(segstr) );
1589 SEGPTR_FREE(segstr);
1590 return ret;
1591 }
1592
1593 case WM_NEXTMENU:
1594 case WM_SETFOCUS:
1595 case WM_SIZE:
1596 return DefFrameProc16( hwnd, hwndMDIClient, message,
1597 wParam, lParam );
1598 }
1599 }
1600
1601 return DefWindowProcA(hwnd, message, wParam, lParam);
1602 }
1603
1604
1605 /***********************************************************************
1606 * DefFrameProcW (USER32.123)
1607 */
1608 LRESULT WINAPI DefFrameProcW( HWND hwnd, HWND hwndMDIClient,
1609 UINT message, WPARAM wParam, LPARAM lParam)
1610 {
1611 if (hwndMDIClient)
1612 {
1613 switch (message)
1614 {
1615 case WM_COMMAND:
1616 return DefFrameProc16( hwnd, hwndMDIClient, message,
1617 (WPARAM16)wParam,
1618 MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ) );
1619
1620 case WM_NCACTIVATE:
1621 SendMessageW(hwndMDIClient, message, wParam, lParam);
1622 break;
1623
1624 case WM_SETTEXT:
1625 {
1626 LPSTR txt = HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)lParam);
1627 LRESULT ret = DefFrameProcA( hwnd, hwndMDIClient, message,
1628 wParam, (DWORD)txt );
1629 HeapFree(GetProcessHeap(),0,txt);
1630 return ret;
1631 }
1632 case WM_NEXTMENU:
1633 case WM_SETFOCUS:
1634 case WM_SIZE:
1635 return DefFrameProcA( hwnd, hwndMDIClient, message,
1636 wParam, lParam );
1637 }
1638 }
1639
1640 return DefWindowProcW( hwnd, message, wParam, lParam );
1641 }
1642
1643
1644 /***********************************************************************
1645 * DefMDIChildProc16 (USER.447)
1646 */
1647 LRESULT WINAPI DefMDIChildProc16( HWND16 hwnd, UINT16 message,
1648 WPARAM16 wParam, LPARAM lParam )
1649 {
1650 MDICLIENTINFO *ci;
1651 WND *clientWnd,*tmpWnd = 0;
1652 LRESULT retvalue;
1653
1654 tmpWnd = WIN_FindWndPtr(hwnd);
1655 if (!tmpWnd) return 0;
1656 clientWnd = WIN_FindWndPtr(tmpWnd->parent->hwndSelf);
1657 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1658 WIN_ReleaseWndPtr(tmpWnd);
1659
1660 switch (message)
1661 {
1662 case WM_SETTEXT:
1663 DefWindowProc16(hwnd, message, wParam, lParam);
1664 MDI_MenuModifyItem(clientWnd,hwnd);
1665 if( ci->hwndChildMaximized == hwnd )
1666 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1667 MDI_REPAINTFRAME, NULL );
1668 retvalue = 0;
1669 goto END;
1670
1671 case WM_CLOSE:
1672 SendMessage16(ci->self,WM_MDIDESTROY,(WPARAM16)hwnd,0L);
1673 retvalue = 0;
1674 goto END;
1675
1676 case WM_SETFOCUS:
1677 if( ci->hwndActiveChild != hwnd )
1678 MDI_ChildActivate(clientWnd, hwnd);
1679 break;
1680
1681 case WM_CHILDACTIVATE:
1682 MDI_ChildActivate(clientWnd, hwnd);
1683 retvalue = 0;
1684 goto END;
1685
1686 case WM_NCPAINT:
1687 TRACE("WM_NCPAINT for %04x, active %04x\n",
1688 hwnd, ci->hwndActiveChild );
1689 break;
1690
1691 case WM_SYSCOMMAND:
1692 switch( wParam )
1693 {
1694 case SC_MOVE:
1695 if( ci->hwndChildMaximized == hwnd)
1696 {
1697 retvalue = 0;
1698 goto END;
1699 }
1700 break;
1701 case SC_RESTORE:
1702 case SC_MINIMIZE:
1703 tmpWnd = WIN_FindWndPtr(hwnd);
1704 tmpWnd->dwStyle |= WS_SYSMENU;
1705 WIN_ReleaseWndPtr(tmpWnd);
1706 break;
1707 case SC_MAXIMIZE:
1708 if( ci->hwndChildMaximized == hwnd)
1709 {
1710 retvalue = SendMessage16( clientWnd->parent->hwndSelf,
1711 message, wParam, lParam);
1712 goto END;
1713 }
1714 tmpWnd = WIN_FindWndPtr(hwnd);
1715 tmpWnd->dwStyle &= ~WS_SYSMENU;
1716 WIN_ReleaseWndPtr(tmpWnd);
1717 break;
1718 case SC_NEXTWINDOW:
1719 SendMessage16( ci->self, WM_MDINEXT, 0, 0);
1720 retvalue = 0;
1721 goto END;
1722 case SC_PREVWINDOW:
1723 SendMessage16( ci->self, WM_MDINEXT, 0, 1);
1724 retvalue = 0;
1725 goto END;
1726 }
1727 break;
1728
1729 case WM_GETMINMAXINFO:
1730 MDI_ChildGetMinMaxInfo(clientWnd, hwnd, (MINMAXINFO16*) PTR_SEG_TO_LIN(lParam));
1731 retvalue = 0;
1732 goto END;
1733
1734 case WM_SETVISIBLE:
1735 if( ci->hwndChildMaximized) ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1736 else
1737 MDI_PostUpdate(clientWnd->hwndSelf, ci, SB_BOTH+1);
1738 break;
1739
1740 case WM_SIZE:
1741 /* do not change */
1742
1743 if( ci->hwndActiveChild == hwnd && wParam != SIZE_MAXIMIZED )
1744 {
1745 ci->hwndChildMaximized = 0;
1746
1747 MDI_RestoreFrameMenu( clientWnd->parent, hwnd);
1748 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1749 MDI_REPAINTFRAME, NULL );
1750 }
1751
1752 if( wParam == SIZE_MAXIMIZED )
1753 {
1754 HWND16 hMaxChild = ci->hwndChildMaximized;
1755
1756 if( hMaxChild == hwnd ) break;
1757
1758 if( hMaxChild)
1759 {
1760 SendMessage16( hMaxChild, WM_SETREDRAW, FALSE, 0L );
1761
1762 MDI_RestoreFrameMenu( clientWnd->parent, hMaxChild);
1763 ShowWindow16( hMaxChild, SW_SHOWNOACTIVATE);
1764
1765 SendMessage16( hMaxChild, WM_SETREDRAW, TRUE, 0L );
1766 }
1767
1768 TRACE("maximizing child %04x\n", hwnd );
1769
1770 /*
1771 * Keep track of the maximized window.
1772 */
1773 ci->hwndChildMaximized = hwnd; /* !!! */
1774
1775 /*
1776 * The maximized window should also be the active window
1777 */
1778 MDI_ChildActivate(clientWnd, hwnd);
1779
1780 MDI_AugmentFrameMenu( ci, clientWnd->parent, hwnd);
1781 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1782 MDI_REPAINTFRAME, NULL );
1783 }
1784
1785 if( wParam == SIZE_MINIMIZED )
1786 {
1787 HWND16 switchTo = MDI_GetWindow(clientWnd, hwnd, TRUE, WS_MINIMIZE);
1788
1789 if( switchTo )
1790 SendMessage16( switchTo, WM_CHILDACTIVATE, 0, 0L);
1791 }
1792
1793 MDI_PostUpdate(clientWnd->hwndSelf, ci, SB_BOTH+1);
1794 break;
1795
1796 case WM_MENUCHAR:
1797
1798 /* MDI children don't have menu bars */
1799 retvalue = 0x00010000L;
1800 goto END;
1801
1802 case WM_NEXTMENU:
1803
1804 if( wParam == VK_LEFT ) /* switch to frame system menu */
1805 {
1806 retvalue = MAKELONG( GetSubMenu16(clientWnd->parent->hSysMenu, 0),
1807 clientWnd->parent->hwndSelf );
1808 goto END;
1809 }
1810 if( wParam == VK_RIGHT ) /* to frame menu bar */
1811 {
1812 retvalue = MAKELONG( clientWnd->parent->wIDmenu,
1813 clientWnd->parent->hwndSelf );
1814 goto END;
1815 }
1816
1817 break;
1818
1819 case WM_SYSCHAR:
1820 if (wParam == '-')
1821 {
1822 SendMessage16(hwnd,WM_SYSCOMMAND,
1823 (WPARAM16)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
1824 retvalue = 0;
1825 goto END;
1826 }
1827 }
1828
1829 retvalue = DefWindowProc16(hwnd, message, wParam, lParam);
1830 END:
1831 WIN_ReleaseWndPtr(clientWnd);
1832 return retvalue;
1833 }
1834
1835
1836 /***********************************************************************
1837 * DefMDIChildProcA (USER32.124)
1838 */
1839 LRESULT WINAPI DefMDIChildProcA( HWND hwnd, UINT message,
1840 WPARAM wParam, LPARAM lParam )
1841 {
1842 MDICLIENTINFO *ci;
1843 WND *clientWnd,*tmpWnd;
1844 LRESULT retvalue;
1845
1846 tmpWnd = WIN_FindWndPtr(hwnd);
1847 if (!tmpWnd) return 0;
1848 clientWnd = WIN_FindWndPtr(tmpWnd->parent->hwndSelf);
1849 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1850 WIN_ReleaseWndPtr(tmpWnd);
1851
1852 switch (message)
1853 {
1854 case WM_SETTEXT:
1855 DefWindowProcA(hwnd, message, wParam, lParam);
1856 MDI_MenuModifyItem(clientWnd,hwnd);
1857 if( ci->hwndChildMaximized == hwnd )
1858 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1859 MDI_REPAINTFRAME, NULL );
1860 retvalue = 0;
1861 goto END;
1862
1863 case WM_GETMINMAXINFO:
1864 {
1865 MINMAXINFO16 mmi;
1866 STRUCT32_MINMAXINFO32to16( (MINMAXINFO *)lParam, &mmi );
1867 MDI_ChildGetMinMaxInfo( clientWnd, hwnd, &mmi );
1868 STRUCT32_MINMAXINFO16to32( &mmi, (MINMAXINFO *)lParam );
1869 }
1870 retvalue = 0;
1871 goto END;
1872
1873 case WM_MENUCHAR:
1874
1875 /* MDI children don't have menu bars */
1876 retvalue = 0x00010000L;
1877 goto END;
1878
1879 case WM_CLOSE:
1880 case WM_SETFOCUS:
1881 case WM_CHILDACTIVATE:
1882 case WM_NCPAINT:
1883 case WM_SYSCOMMAND:
1884 case WM_SETVISIBLE:
1885 case WM_SIZE:
1886 case WM_NEXTMENU:
1887 retvalue = DefMDIChildProc16( hwnd, message, (WPARAM16)wParam, lParam );
1888 goto END;
1889
1890 case WM_SYSCHAR:
1891 if (wParam == '-')
1892 {
1893 SendMessageA(hwnd,WM_SYSCOMMAND,
1894 (WPARAM)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
1895 retvalue = 0;
1896 goto END;
1897 }
1898 }
1899 retvalue = DefWindowProcA(hwnd, message, wParam, lParam);
1900 END:
1901 WIN_ReleaseWndPtr(clientWnd);
1902 return retvalue;
1903 }
1904
1905
1906 /***********************************************************************
1907 * DefMDIChildProcW (USER32.125)
1908 */
1909 LRESULT WINAPI DefMDIChildProcW( HWND hwnd, UINT message,
1910 WPARAM wParam, LPARAM lParam )
1911 {
1912 MDICLIENTINFO *ci;
1913 WND *clientWnd,*tmpWnd;
1914 LRESULT retvalue;
1915
1916 tmpWnd = WIN_FindWndPtr(hwnd);
1917 if (!tmpWnd) return 0;
1918 clientWnd = WIN_FindWndPtr(tmpWnd->parent->hwndSelf);
1919 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1920 WIN_ReleaseWndPtr(tmpWnd);
1921
1922 switch (message)
1923 {
1924 case WM_SETTEXT:
1925 DefWindowProcW(hwnd, message, wParam, lParam);
1926 MDI_MenuModifyItem(clientWnd,hwnd);
1927 if( ci->hwndChildMaximized == hwnd )
1928 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1929 MDI_REPAINTFRAME, NULL );
1930 retvalue = 0;
1931 goto END;
1932
1933 case WM_GETMINMAXINFO:
1934 case WM_MENUCHAR:
1935 case WM_CLOSE:
1936 case WM_SETFOCUS:
1937 case WM_CHILDACTIVATE:
1938 case WM_NCPAINT:
1939 case WM_SYSCOMMAND:
1940 case WM_SETVISIBLE:
1941 case WM_SIZE:
1942 case WM_NEXTMENU:
1943 retvalue = DefMDIChildProcA( hwnd, message, (WPARAM16)wParam, lParam );
1944 goto END;
1945
1946 case WM_SYSCHAR:
1947 if (wParam == '-')
1948 {
1949 SendMessageW(hwnd,WM_SYSCOMMAND,
1950 (WPARAM)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
1951 retvalue = 0;
1952 goto END;
1953 }
1954 }
1955 retvalue = DefWindowProcW(hwnd, message, wParam, lParam);
1956 END:
1957 WIN_ReleaseWndPtr(clientWnd);
1958 return retvalue;
1959
1960 }
1961
1962
1963 /**********************************************************************
1964 * CreateMDIWindowA [USER32.79] Creates a MDI child in new thread
1965 * FIXME: its in the same thread now
1966 *
1967 * RETURNS
1968 * Success: Handle to created window
1969 * Failure: NULL
1970 */
1971 HWND WINAPI CreateMDIWindowA(
1972 LPCSTR lpClassName, /* [in] Pointer to registered child class name */
1973 LPCSTR lpWindowName, /* [in] Pointer to window name */
1974 DWORD dwStyle, /* [in] Window style */
1975 INT X, /* [in] Horizontal position of window */
1976 INT Y, /* [in] Vertical position of window */
1977 INT nWidth, /* [in] Width of window */
1978 INT nHeight, /* [in] Height of window */
1979 HWND hWndParent, /* [in] Handle to parent window */
1980 HINSTANCE hInstance, /* [in] Handle to application instance */
1981 LPARAM lParam) /* [in] Application-defined value */
1982 {
1983 WARN("is only single threaded!\n");
1984 return MDI_CreateMDIWindowA(lpClassName, lpWindowName, dwStyle, X, Y,
1985 nWidth, nHeight, hWndParent, hInstance, lParam);
1986 }
1987
1988 /**********************************************************************
1989 * MDI_CreateMDIWindowA
1990 * single threaded version of CreateMDIWindowA
1991 * called by CreateWindowExA
1992 */
1993 HWND MDI_CreateMDIWindowA(
1994 LPCSTR lpClassName,
1995 LPCSTR lpWindowName,
1996 DWORD dwStyle,
1997 INT X,
1998 INT Y,
1999 INT nWidth,
2000 INT nHeight,
2001 HWND hWndParent,
2002 HINSTANCE hInstance,
2003 LPARAM lParam)
2004 {
2005 MDICLIENTINFO* pCi;
2006 MDICREATESTRUCTA cs;
2007 WND *pWnd=WIN_FindWndPtr(hWndParent);
2008 HWND retvalue;
2009
2010 TRACE("(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld)\n",
2011 debugstr_a(lpClassName),debugstr_a(lpWindowName),dwStyle,X,Y,
2012 nWidth,nHeight,hWndParent,hInstance,lParam);
2013
2014 if(!pWnd){
2015 ERR(" bad hwnd for MDI-client: %d\n",hWndParent);
2016 return 0;
2017 }
2018 cs.szClass=lpClassName;
2019 cs.szTitle=lpWindowName;
2020 cs.hOwner=hInstance;
2021 cs.x=X;
2022 cs.y=Y;
2023 cs.cx=nWidth;
2024 cs.cy=nHeight;
2025 cs.style=dwStyle;
2026 cs.lParam=lParam;
2027
2028 pCi=(MDICLIENTINFO *)pWnd->wExtra;
2029
2030 retvalue = MDICreateChild(pWnd,pCi,hWndParent,&cs);
2031 WIN_ReleaseWndPtr(pWnd);
2032 return retvalue;
2033 }
2034
2035 /***********************************************************************
2036 * CreateMDIWindowW [USER32.80] Creates a MDI child in new thread
2037 *
2038 * RETURNS
2039 * Success: Handle to created window
2040 * Failure: NULL
2041 */
2042 HWND WINAPI CreateMDIWindowW(
2043 LPCWSTR lpClassName, /* [in] Pointer to registered child class name */
2044 LPCWSTR lpWindowName, /* [in] Pointer to window name */
2045 DWORD dwStyle, /* [in] Window style */
2046 INT X, /* [in] Horizontal position of window */
2047 INT Y, /* [in] Vertical position of window */
2048 INT nWidth, /* [in] Width of window */
2049 INT nHeight, /* [in] Height of window */
2050 HWND hWndParent, /* [in] Handle to parent window */
2051 HINSTANCE hInstance, /* [in] Handle to application instance */
2052 LPARAM lParam) /* [in] Application-defined value */
2053 {
2054 FIXME("(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld): stub\n",
2055 debugstr_w(lpClassName),debugstr_w(lpWindowName),dwStyle,X,Y,
2056 nWidth,nHeight,hWndParent,hInstance,lParam);
2057 return (HWND)NULL;
2058 }
2059
2060
2061 /******************************************************************************
2062 * CreateMDIWindowW [USER32.80] Creates a MDI child window
2063 * single threaded version of CreateMDIWindow
2064 * called by CreateWindowExW().
2065 */
2066 HWND MDI_CreateMDIWindowW(
2067 LPCWSTR lpClassName, /* [in] Pointer to registered child class name */
2068 LPCWSTR lpWindowName, /* [in] Pointer to window name */
2069 DWORD dwStyle, /* [in] Window style */
2070 INT X, /* [in] Horizontal position of window */
2071 INT Y, /* [in] Vertical position of window */
2072 INT nWidth, /* [in] Width of window */
2073 INT nHeight, /* [in] Height of window */
2074 HWND hWndParent, /* [in] Handle to parent window */
2075 HINSTANCE hInstance, /* [in] Handle to application instance */
2076 LPARAM lParam) /* [in] Application-defined value */
2077 {
2078 FIXME("(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld): stub\n",
2079 debugstr_w(lpClassName),debugstr_w(lpWindowName),dwStyle,X,Y,
2080 nWidth,nHeight,hWndParent,hInstance,lParam);
2081 return (HWND)NULL;
2082 }
2083
2084
2085 /**********************************************************************
2086 * TranslateMDISysAccel (USER32.555)
2087 */
2088 BOOL WINAPI TranslateMDISysAccel( HWND hwndClient, LPMSG msg )
2089 {
2090 MSG16 msg16;
2091
2092 STRUCT32_MSG32to16(msg,&msg16);
2093 /* MDICLIENTINFO is still the same for win32 and win16 ... */
2094 return TranslateMDISysAccel16(hwndClient,&msg16);
2095 }
2096
2097
2098 /**********************************************************************
2099 * TranslateMDISysAccel16 (USER.451)
2100 */
2101 BOOL16 WINAPI TranslateMDISysAccel16( HWND16 hwndClient, LPMSG16 msg )
2102 {
2103
2104 if( IsWindow(hwndClient) && (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN))
2105 {
2106 MDICLIENTINFO *ci = NULL;
2107 HWND wnd;
2108 WND *clientWnd = WIN_FindWndPtr(hwndClient);
2109
2110 ci = (MDICLIENTINFO*) clientWnd->wExtra;
2111 wnd = ci->hwndActiveChild;
2112
2113 WIN_ReleaseWndPtr(clientWnd);
2114
2115 if( IsWindow(wnd) && !(GetWindowLongA(wnd,GWL_STYLE) & WS_DISABLED) )
2116 {
2117 WPARAM16 wParam = 0;
2118
2119 /* translate if the Ctrl key is down and Alt not. */
2120
2121 if( (GetKeyState(VK_CONTROL) & 0x8000) &&
2122 !(GetKeyState(VK_MENU) & 0x8000))
2123 {
2124 switch( msg->wParam )
2125 {
2126 case VK_F6:
2127 case VK_TAB:
2128 wParam = ( GetKeyState(VK_SHIFT) & 0x8000 )
2129 ? SC_NEXTWINDOW : SC_PREVWINDOW;
2130 break;
2131 case VK_F4:
2132 case VK_RBUTTON:
2133 wParam = SC_CLOSE;
2134 break;
2135 default:
2136 return 0;
2137 }
2138 TRACE("wParam = %04x\n", wParam);
2139 SendMessage16( ci->hwndActiveChild, WM_SYSCOMMAND,
2140 wParam, (LPARAM)msg->wParam);
2141 return 1;
2142 }
2143 }
2144 }
2145 return 0; /* failure */
2146 }
2147
2148
2149 /***********************************************************************
2150 * CalcChildScroll (USER.462)
2151 */
2152 void WINAPI CalcChildScroll16( HWND16 hwnd, WORD scroll )
2153 {
2154 SCROLLINFO info;
2155 RECT childRect, clientRect;
2156 INT vmin, vmax, hmin, hmax, vpos, hpos;
2157 WND *pWnd, *Wnd;
2158
2159 if (!(pWnd = WIN_FindWndPtr( hwnd ))) return;
2160 Wnd = WIN_FindWndPtr(hwnd);
2161 GetClientRect( hwnd, &clientRect );
2162 SetRectEmpty( &childRect );
2163
2164 for ( WIN_UpdateWndPtr(&pWnd,pWnd->child); pWnd; WIN_UpdateWndPtr(&pWnd,pWnd->next))
2165 {
2166 if( pWnd->dwStyle & WS_MAXIMIZE )
2167 {
2168 ShowScrollBar(hwnd, SB_BOTH, FALSE);
2169 WIN_ReleaseWndPtr(pWnd);
2170 WIN_ReleaseWndPtr(Wnd);
2171 return;
2172 }
2173 UnionRect( &childRect, &pWnd->rectWindow, &childRect );
2174 }
2175 WIN_ReleaseWndPtr(pWnd);
2176 UnionRect( &childRect, &clientRect, &childRect );
2177
2178 hmin = childRect.left; hmax = childRect.right - clientRect.right;
2179 hpos = clientRect.left - childRect.left;
2180 vmin = childRect.top; vmax = childRect.bottom - clientRect.bottom;
2181 vpos = clientRect.top - childRect.top;
2182
2183 switch( scroll )
2184 {
2185 case SB_HORZ:
2186 vpos = hpos; vmin = hmin; vmax = hmax;
2187 case SB_VERT:
2188 info.cbSize = sizeof(info);
2189 info.nMax = vmax; info.nMin = vmin; info.nPos = vpos;
2190 info.fMask = SIF_POS | SIF_RANGE;
2191 SetScrollInfo(hwnd, scroll, &info, TRUE);
2192 break;
2193 case SB_BOTH:
2194 SCROLL_SetNCSbState( Wnd, vmin, vmax, vpos,
2195 hmin, hmax, hpos);
2196 }
2197 WIN_ReleaseWndPtr(Wnd);
2198 }
2199
2200
2201 /***********************************************************************
2202 * ScrollChildren16 (USER.463)
2203 */
2204 void WINAPI ScrollChildren16(HWND16 hWnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam)
2205 {
2206 ScrollChildren( hWnd, uMsg, wParam, lParam );
2207 }
2208
2209
2210 /***********************************************************************
2211 * ScrollChildren (USER32.448)
2212 */
2213 void WINAPI ScrollChildren(HWND hWnd, UINT uMsg, WPARAM wParam,
2214 LPARAM lParam)
2215 {
2216 WND *wndPtr = WIN_FindWndPtr(hWnd);
2217 INT newPos = -1;
2218 INT curPos, length, minPos, maxPos, shift;
2219
2220 if( !wndPtr ) return;
2221
2222 if( uMsg == WM_HSCROLL )
2223 {
2224 GetScrollRange(hWnd,SB_HORZ,&minPos,&maxPos);
2225 curPos = GetScrollPos(hWnd,SB_HORZ);
2226 length = (wndPtr->rectClient.right - wndPtr->rectClient.left)/2;
2227 shift = GetSystemMetrics(SM_CYHSCROLL);
2228 }
2229 else if( uMsg == WM_VSCROLL )
2230 {
2231 GetScrollRange(hWnd,SB_VERT,&minPos,&maxPos);
2232 curPos = GetScrollPos(hWnd,SB_VERT);
2233 length = (wndPtr->rectClient.bottom - wndPtr->rectClient.top)/2;
2234 shift = GetSystemMetrics(SM_CXVSCROLL);
2235 }
2236 else
2237 {
2238 WIN_ReleaseWndPtr(wndPtr);
2239 return;
2240 }
2241
2242 WIN_ReleaseWndPtr(wndPtr);
2243 switch( wParam )
2244 {
2245 case SB_LINEUP:
2246 newPos = curPos - shift;
2247 break;
2248 case SB_LINEDOWN:
2249 newPos = curPos + shift;
2250 break;
2251 case SB_PAGEUP:
2252 newPos = curPos - length;
2253 break;
2254 case SB_PAGEDOWN:
2255 newPos = curPos + length;
2256 break;
2257
2258 case SB_THUMBPOSITION:
2259 newPos = LOWORD(lParam);
2260 break;
2261
2262 case SB_THUMBTRACK:
2263 return;
2264
2265 case SB_TOP:
2266 newPos = minPos;
2267 break;
2268 case SB_BOTTOM:
2269 newPos = maxPos;
2270 break;
2271 case SB_ENDSCROLL:
2272 CalcChildScroll16(hWnd,(uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ);
2273 return;
2274 }
2275
2276 if( newPos > maxPos )
2277 newPos = maxPos;
2278 else
2279 if( newPos < minPos )
2280 newPos = minPos;
2281
2282 SetScrollPos(hWnd, (uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ , newPos, TRUE);
2283
2284 if( uMsg == WM_VSCROLL )
2285 ScrollWindowEx(hWnd ,0 ,curPos - newPos, NULL, NULL, 0, NULL,
2286 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
2287 else
2288 ScrollWindowEx(hWnd ,curPos - newPos, 0, NULL, NULL, 0, NULL,
2289 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
2290 }
2291
2292
2293 /******************************************************************************
2294 * CascadeWindows [USER32.21] Cascades MDI child windows
2295 *
2296 * RETURNS
2297 * Success: Number of cascaded windows.
2298 * Failure: 0
2299 */
2300 WORD WINAPI
2301 CascadeWindows (HWND hwndParent, UINT wFlags, const LPRECT lpRect,
2302 UINT cKids, const HWND *lpKids)
2303 {
2304 FIXME("(0x%08x,0x%08x,...,%u,...): stub\n",
2305 hwndParent, wFlags, cKids);
2306
2307 return 0;
2308 }
2309
2310
2311 /******************************************************************************
2312 * TileWindows [USER32.545] Tiles MDI child windows
2313 *
2314 * RETURNS
2315 * Success: Number of tiled windows.
2316 * Failure: 0
2317 */
2318 WORD WINAPI
2319 TileWindows (HWND hwndParent, UINT wFlags, const LPRECT lpRect,
2320 UINT cKids, const HWND *lpKids)
2321 {
2322 FIXME("(0x%08x,0x%08x,...,%u,...): stub\n",
2323 hwndParent, wFlags, cKids);
2324
2325 return 0;
2326 }
2327
2328 /************************************************************************
2329 * "More Windows..." functionality
2330 */
2331
2332 /* MDI_MoreWindowsDlgProc
2333 *
2334 * This function will process the messages sent to the "More Windows..."
2335 * dialog.
2336 * Return values: 0 = cancel pressed
2337 * HWND = ok pressed or double-click in the list...
2338 *
2339 */
2340
2341 static BOOL WINAPI MDI_MoreWindowsDlgProc (HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
2342 {
2343 switch (iMsg)
2344 {
2345 case WM_INITDIALOG:
2346 {
2347 WND *pWnd;
2348 UINT widest = 0;
2349 UINT length;
2350 UINT i;
2351 WND *pParentWnd = (WND *)lParam;
2352 MDICLIENTINFO *ci = (MDICLIENTINFO*)pParentWnd->wExtra;
2353 HWND hListBox = GetDlgItem(hDlg, MDI_IDC_LISTBOX);
2354
2355 /* Fill the list, sorted by id... */
2356 for (i = 0; i < ci->nActiveChildren; i++)
2357 {
2358
2359 /* Find the window with the current ID */
2360 for (pWnd = WIN_LockWndPtr(pParentWnd->child); pWnd; WIN_UpdateWndPtr(&pWnd, pWnd->next))
2361 if (pWnd->wIDmenu == ci->idFirstChild + i)
2362 break;
2363
2364 SendMessageW(hListBox, LB_ADDSTRING, 0, (LPARAM) pWnd->text);
2365 SendMessageA(hListBox, LB_SETITEMDATA, i, (LPARAM) pWnd);
2366 length = strlenW(pWnd->text);
2367 WIN_ReleaseWndPtr(pWnd);
2368
2369 if (length > widest)
2370 widest = length;
2371 }
2372 /* Make sure the horizontal scrollbar scrolls ok */
2373 SendMessageA(hListBox, LB_SETHORIZONTALEXTENT, widest * 6, 0);
2374
2375 /* Set the current selection */
2376 SendMessageA(hListBox, LB_SETCURSEL, MDI_MOREWINDOWSLIMIT, 0);
2377 return TRUE;
2378 }
2379
2380 case WM_COMMAND:
2381 switch (LOWORD(wParam))
2382 {
2383 case IDOK:
2384 {
2385 /* windows are sorted by menu ID, so we must return the
2386 * window associated to the given id
2387 */
2388 HWND hListBox = GetDlgItem(hDlg, MDI_IDC_LISTBOX);
2389 UINT index = SendMessageA(hListBox, LB_GETCURSEL, 0, 0);
2390 WND* pWnd = (WND*) SendMessageA(hListBox, LB_GETITEMDATA, index, 0);
2391
2392 EndDialog(hDlg, pWnd->hwndSelf);
2393 return TRUE;
2394 }
2395 case IDCANCEL:
2396 EndDialog(hDlg, 0);
2397 return TRUE;
2398
2399 default:
2400 switch (HIWORD(wParam))
2401 {
2402 case LBN_DBLCLK:
2403 {
2404 /* windows are sorted by menu ID, so we must return the
2405 * window associated to the given id
2406 */
2407 HWND hListBox = GetDlgItem(hDlg, MDI_IDC_LISTBOX);
2408 UINT index = SendMessageA(hListBox, LB_GETCURSEL, 0, 0);
2409 WND* pWnd = (WND*) SendMessageA(hListBox, LB_GETITEMDATA, index, 0);
2410
2411 EndDialog(hDlg, pWnd->hwndSelf);
2412 return TRUE;
2413 }
2414 }
2415 break;
2416 }
2417 break;
2418 }
2419 return FALSE;
2420 }
2421
2422 /*
2423 *
2424 * MDI_MoreWindowsDialog
2425 *
2426 * Prompts the user with a listbox containing the opened
2427 * documents. The user can then choose a windows and click
2428 * on OK to set the current window to the one selected, or
2429 * CANCEL to cancel. The function returns a handle to the
2430 * selected window.
2431 */
2432
2433 static HWND MDI_MoreWindowsDialog(WND* wndPtr)
2434 {
2435 LPCVOID template;
2436 HRSRC hRes;
2437 HANDLE hDlgTmpl;
2438
2439 hRes = FindResourceA(GetModuleHandleA("USER32"), "MDI_MOREWINDOWS", RT_DIALOGA);
2440
2441 if (hRes == 0)
2442 return 0;
2443
2444 hDlgTmpl = LoadResource(GetModuleHandleA("USER32"), hRes );
2445
2446 if (hDlgTmpl == 0)
2447 return 0;
2448
2449 template = LockResource( hDlgTmpl );
2450
2451 if (template == 0)
2452 return 0;
2453
2454 return (HWND) DialogBoxIndirectParamA(GetModuleHandleA("USER32"),
2455 (LPDLGTEMPLATEA) template,
2456 wndPtr->hwndSelf,
2457 (DLGPROC) MDI_MoreWindowsDlgProc,
2458 (LPARAM) wndPtr);
2459 }
2460
2461 /*
2462 *
2463 * MDI_SwapMenuItems
2464 *
2465 * Will swap the menu IDs for the given 2 positions.
2466 * pos1 and pos2 are menu IDs
2467 *
2468 *
2469 */
2470
2471 static void MDI_SwapMenuItems(WND *parentWnd, UINT pos1, UINT pos2)
2472 {
2473 WND *pWnd;
2474
2475 for (pWnd = WIN_LockWndPtr(parentWnd->child); pWnd; WIN_UpdateWndPtr(&pWnd,pWnd->next))
2476 {
2477 if (pWnd->wIDmenu == pos1)
2478 pWnd->wIDmenu = pos2;
2479 else
2480 if (pWnd->wIDmenu == pos2)
2481 pWnd->wIDmenu = pos1;
2482 }
2483
2484 WIN_ReleaseWndPtr(pWnd);
2485 }
2486
Windows API implementation