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 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 *
23 * Notes: Fairly complete implementation.
24 * Also, Excel and WinWord do _not_ use MDI so if you're trying
25 * to fix them look elsewhere.
26 *
27 * Notes on how the "More Windows..." is implemented:
28 *
29 * When we have more than 9 opened windows, a "More Windows..."
30 * option appears in the "Windows" menu. Each child window has
31 * a WND* associated with it, accessible via the children list of
32 * the parent window. This WND* has a wIDmenu member, which reflects
33 * the position of the child in the window list. For example, with
34 * 9 child windows, we could have the following pattern:
35 *
36 *
37 *
38 * Name of the child window pWndChild->wIDmenu
39 * Doc1 5000
40 * Doc2 5001
41 * Doc3 5002
42 * Doc4 5003
43 * Doc5 5004
44 * Doc6 5005
45 * Doc7 5006
46 * Doc8 5007
47 * Doc9 5008
48 *
49 *
50 * The "Windows" menu, as the "More windows..." dialog, are constructed
51 * in this order. If we add a child, we would have the following list:
52 *
53 *
54 * Name of the child window pWndChild->wIDmenu
55 * Doc1 5000
56 * Doc2 5001
57 * Doc3 5002
58 * Doc4 5003
59 * Doc5 5004
60 * Doc6 5005
61 * Doc7 5006
62 * Doc8 5007
63 * Doc9 5008
64 * Doc10 5009
65 *
66 * But only 5000 to 5008 would be displayed in the "Windows" menu. We want
67 * the last created child to be in the menu, so we swap the last child with
68 * the 9th... Doc9 will be accessible via the "More Windows..." option.
69 *
70 * Doc1 5000
71 * Doc2 5001
72 * Doc3 5002
73 * Doc4 5003
74 * Doc5 5004
75 * Doc6 5005
76 * Doc7 5006
77 * Doc8 5007
78 * Doc9 5009
79 * Doc10 5008
80 *
81 */
82
83 #include <stdlib.h>
84 #include <stdarg.h>
85 #include <stdio.h>
86 #include <string.h>
87 #include <math.h>
88
89 #define OEMRESOURCE
90
91 #include "windef.h"
92 #include "winbase.h"
93 #include "wingdi.h"
94 #include "winuser.h"
95 #include "wownt32.h"
96 #include "wine/winuser16.h"
97 #include "wine/unicode.h"
98 #include "win.h"
99 #include "controls.h"
100 #include "user_private.h"
101 #include "wine/debug.h"
102
103 WINE_DEFAULT_DEBUG_CHANNEL(mdi);
104
105 #define MDI_MAXTITLELENGTH 0xa1
106
107 #define WM_MDICALCCHILDSCROLL 0x10ac /* this is exactly what Windows uses */
108
109 /* "More Windows..." definitions */
110 #define MDI_MOREWINDOWSLIMIT 9 /* after this number of windows, a "More Windows..."
111 option will appear under the Windows menu */
112 #define MDI_IDC_LISTBOX 100
113 #define IDS_MDI_MOREWINDOWS 13
114
115 #define MDIF_NEEDUPDATE 0x0001
116
117 typedef struct
118 {
119 /* At some points, particularly when switching MDI children, active and
120 * maximized MDI children may be not the same window, so we need to track
121 * them separately.
122 * The only place where we switch to/from maximized state is DefMDIChildProc
123 * WM_SIZE/SIZE_MAXIMIZED handler. We get that notification only after the
124 * ShowWindow(SW_SHOWMAXIMIZED) request, therefore window is guaranteed to
125 * be visible at the time we get the notification, and it's safe to assume
126 * that hwndChildMaximized is always visible.
127 * If the app plays games with WS_VISIBLE, WS_MAXIMIZE or any other window
128 * states it must keep coherency with USER32 on its own. This is true for
129 * Windows as well.
130 */
131 UINT nActiveChildren;
132 HWND hwndChildMaximized;
133 HWND hwndActiveChild;
134 HWND *child; /* array of tracked children */
135 HMENU hFrameMenu;
136 HMENU hWindowMenu;
137 UINT idFirstChild;
138 LPWSTR frameTitle;
139 UINT nTotalCreated;
140 UINT mdiFlags;
141 UINT sbRecalc; /* SB_xxx flags for scrollbar fixup */
142 } MDICLIENTINFO;
143
144 static HBITMAP hBmpClose = 0;
145
146 /* ----------------- declarations ----------------- */
147 static void MDI_UpdateFrameText( HWND, HWND, BOOL, LPCWSTR);
148 static BOOL MDI_AugmentFrameMenu( HWND, HWND );
149 static BOOL MDI_RestoreFrameMenu( HWND, HWND );
150 static LONG MDI_ChildActivate( HWND, HWND );
151 static LRESULT MDI_RefreshMenu(MDICLIENTINFO *);
152
153 static HWND MDI_MoreWindowsDialog(HWND);
154 static LRESULT WINAPI MDIClientWndProcA( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );
155 static LRESULT WINAPI MDIClientWndProcW( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );
156
157 /* -------- Miscellaneous service functions ----------
158 *
159 * MDI_GetChildByID
160 */
161 static HWND MDI_GetChildByID(HWND hwnd, UINT id, MDICLIENTINFO *ci)
162 {
163 int i;
164
165 for (i = 0; ci->nActiveChildren; i++)
166 {
167 if (GetWindowLongPtrW( ci->child[i], GWLP_ID ) == id)
168 return ci->child[i];
169 }
170 return 0;
171 }
172
173 static void MDI_PostUpdate(HWND hwnd, MDICLIENTINFO* ci, WORD recalc)
174 {
175 if( !(ci->mdiFlags & MDIF_NEEDUPDATE) )
176 {
177 ci->mdiFlags |= MDIF_NEEDUPDATE;
178 PostMessageA( hwnd, WM_MDICALCCHILDSCROLL, 0, 0);
179 }
180 ci->sbRecalc = recalc;
181 }
182
183
184 /*********************************************************************
185 * MDIClient class descriptor
186 */
187 static const WCHAR mdiclientW[] = {'M','D','I','C','l','i','e','n','t',0};
188 const struct builtin_class_descr MDICLIENT_builtin_class =
189 {
190 mdiclientW, /* name */
191 0, /* style */
192 MDIClientWndProcA, /* procA */
193 MDIClientWndProcW, /* procW */
194 sizeof(MDICLIENTINFO), /* extra */
195 IDC_ARROW, /* cursor */
196 (HBRUSH)(COLOR_APPWORKSPACE+1) /* brush */
197 };
198
199
200 static MDICLIENTINFO *get_client_info( HWND client )
201 {
202 MDICLIENTINFO *ret = NULL;
203 WND *win = WIN_GetPtr( client );
204 if (win)
205 {
206 if (win == WND_OTHER_PROCESS || win == WND_DESKTOP)
207 {
208 if (IsWindow(client)) WARN( "client %p belongs to other process\n", client );
209 return NULL;
210 }
211 if (win->flags & WIN_ISMDICLIENT)
212 ret = (MDICLIENTINFO *)win->wExtra;
213 else
214 WARN( "%p is not an MDI client\n", client );
215 WIN_ReleasePtr( win );
216 }
217 return ret;
218 }
219
220 static BOOL is_close_enabled(HWND hwnd, HMENU hSysMenu)
221 {
222 if (GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE) return FALSE;
223
224 if (!hSysMenu) hSysMenu = GetSystemMenu(hwnd, FALSE);
225 if (hSysMenu)
226 {
227 UINT state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
228 if (state == 0xFFFFFFFF || (state & (MF_DISABLED | MF_GRAYED)))
229 return FALSE;
230 }
231 return TRUE;
232 }
233
234 /**********************************************************************
235 * MDI_GetWindow
236 *
237 * returns "activatable" child different from the current or zero
238 */
239 static HWND MDI_GetWindow(MDICLIENTINFO *clientInfo, HWND hWnd, BOOL bNext,
240 DWORD dwStyleMask )
241 {
242 int i;
243 HWND *list;
244 HWND last = 0;
245
246 dwStyleMask |= WS_DISABLED | WS_VISIBLE;
247 if( !hWnd ) hWnd = clientInfo->hwndActiveChild;
248
249 if (!(list = WIN_ListChildren( GetParent(hWnd) ))) return 0;
250 i = 0;
251 /* start from next after hWnd */
252 while (list[i] && list[i] != hWnd) i++;
253 if (list[i]) i++;
254
255 for ( ; list[i]; i++)
256 {
257 if (GetWindow( list[i], GW_OWNER )) continue;
258 if ((GetWindowLongW( list[i], GWL_STYLE ) & dwStyleMask) != WS_VISIBLE) continue;
259 last = list[i];
260 if (bNext) goto found;
261 }
262 /* now restart from the beginning */
263 for (i = 0; list[i] && list[i] != hWnd; i++)
264 {
265 if (GetWindow( list[i], GW_OWNER )) continue;
266 if ((GetWindowLongW( list[i], GWL_STYLE ) & dwStyleMask) != WS_VISIBLE) continue;
267 last = list[i];
268 if (bNext) goto found;
269 }
270 found:
271 HeapFree( GetProcessHeap(), 0, list );
272 return last;
273 }
274
275 /**********************************************************************
276 * MDI_CalcDefaultChildPos
277 *
278 * It seems that the default height is about 2/3 of the client rect
279 */
280 void MDI_CalcDefaultChildPos( HWND hwndClient, INT total, LPPOINT lpPos, INT delta, UINT *id )
281 {
282 INT nstagger;
283 RECT rect;
284 INT spacing = GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFRAME) - 1;
285
286 if (total < 0) /* we are called from CreateWindow */
287 {
288 MDICLIENTINFO *ci = get_client_info(hwndClient);
289 total = ci ? ci->nTotalCreated : 0;
290 *id = ci->idFirstChild + ci->nActiveChildren;
291 TRACE("MDI child id %04x\n", *id);
292 }
293
294 GetClientRect( hwndClient, &rect );
295 if( rect.bottom - rect.top - delta >= spacing )
296 rect.bottom -= delta;
297
298 nstagger = (rect.bottom - rect.top)/(3 * spacing);
299 lpPos[1].x = (rect.right - rect.left - nstagger * spacing);
300 lpPos[1].y = (rect.bottom - rect.top - nstagger * spacing);
301 lpPos[0].x = lpPos[0].y = spacing * (total%(nstagger+1));
302 }
303
304 /**********************************************************************
305 * MDISetMenu
306 */
307 static LRESULT MDISetMenu( HWND hwnd, HMENU hmenuFrame,
308 HMENU hmenuWindow)
309 {
310 MDICLIENTINFO *ci;
311 HWND hwndFrame = GetParent(hwnd);
312
313 TRACE("%p, frame menu %p, window menu %p\n", hwnd, hmenuFrame, hmenuWindow);
314
315 if (hmenuFrame && !IsMenu(hmenuFrame))
316 {
317 WARN("hmenuFrame is not a menu handle\n");
318 return 0L;
319 }
320
321 if (hmenuWindow && !IsMenu(hmenuWindow))
322 {
323 WARN("hmenuWindow is not a menu handle\n");
324 return 0L;
325 }
326
327 if (!(ci = get_client_info( hwnd ))) return 0;
328
329 TRACE("old frame menu %p, old window menu %p\n", ci->hFrameMenu, ci->hWindowMenu);
330
331 if (hmenuFrame)
332 {
333 if (hmenuFrame == ci->hFrameMenu) return (LRESULT)hmenuFrame;
334
335 if (ci->hwndChildMaximized)
336 MDI_RestoreFrameMenu( hwndFrame, ci->hwndChildMaximized );
337 }
338
339 if( hmenuWindow && hmenuWindow != ci->hWindowMenu )
340 {
341 /* delete menu items from ci->hWindowMenu
342 * and add them to hmenuWindow */
343 /* Agent newsreader calls this function with ci->hWindowMenu == NULL */
344 if( ci->hWindowMenu && ci->nActiveChildren )
345 {
346 UINT nActiveChildren_old = ci->nActiveChildren;
347
348 /* Remove all items from old Window menu */
349 ci->nActiveChildren = 0;
350 MDI_RefreshMenu(ci);
351
352 ci->hWindowMenu = hmenuWindow;
353
354 /* Add items to the new Window menu */
355 ci->nActiveChildren = nActiveChildren_old;
356 MDI_RefreshMenu(ci);
357 }
358 else
359 ci->hWindowMenu = hmenuWindow;
360 }
361
362 if (hmenuFrame)
363 {
364 SetMenu(hwndFrame, hmenuFrame);
365 if( hmenuFrame != ci->hFrameMenu )
366 {
367 HMENU oldFrameMenu = ci->hFrameMenu;
368
369 ci->hFrameMenu = hmenuFrame;
370 if (ci->hwndChildMaximized)
371 MDI_AugmentFrameMenu( hwndFrame, ci->hwndChildMaximized );
372
373 return (LRESULT)oldFrameMenu;
374 }
375 }
376 else
377 {
378 /* SetMenu() may already have been called, meaning that this window
379 * already has its menu. But they may have done a SetMenu() on
380 * an MDI window, and called MDISetMenu() after the fact, meaning
381 * that the "if" to this "else" wouldn't catch the need to
382 * augment the frame menu.
383 */
384 if( ci->hwndChildMaximized )
385 MDI_AugmentFrameMenu( hwndFrame, ci->hwndChildMaximized );
386 }
387
388 return 0;
389 }
390
391 /**********************************************************************
392 * MDIRefreshMenu
393 */
394 static LRESULT MDI_RefreshMenu(MDICLIENTINFO *ci)
395 {
396 UINT i, count, visible, id;
397 WCHAR buf[MDI_MAXTITLELENGTH];
398
399 TRACE("children %u, window menu %p\n", ci->nActiveChildren, ci->hWindowMenu);
400
401 if (!ci->hWindowMenu)
402 return 0;
403
404 if (!IsMenu(ci->hWindowMenu))
405 {
406 WARN("Window menu handle %p is no more valid\n", ci->hWindowMenu);
407 return 0;
408 }
409
410 /* Windows finds the last separator in the menu, and if after it
411 * there is a menu item with MDI magic ID removes all existing
412 * menu items after it, and then adds visible MDI children.
413 */
414 count = GetMenuItemCount(ci->hWindowMenu);
415 for (i = 0; i < count; i++)
416 {
417 MENUITEMINFOW mii;
418
419 memset(&mii, 0, sizeof(mii));
420 mii.cbSize = sizeof(mii);
421 mii.fMask = MIIM_TYPE;
422 if (GetMenuItemInfoW(ci->hWindowMenu, i, TRUE, &mii))
423 {
424 if (mii.fType & MF_SEPARATOR)
425 {
426 /* Windows checks only ID of the menu item */
427 memset(&mii, 0, sizeof(mii));
428 mii.cbSize = sizeof(mii);
429 mii.fMask = MIIM_ID;
430 if (GetMenuItemInfoW(ci->hWindowMenu, i + 1, TRUE, &mii))
431 {
432 if (mii.wID == ci->idFirstChild)
433 {
434 TRACE("removing %u items including separator\n", count - i);
435 while (RemoveMenu(ci->hWindowMenu, i, MF_BYPOSITION))
436 /* nothing */;
437
438 break;
439 }
440 }
441 }
442 }
443 }
444
445 visible = 0;
446 for (i = 0; i < ci->nActiveChildren; i++)
447 {
448 if (GetWindowLongW(ci->child[i], GWL_STYLE) & WS_VISIBLE)
449 {
450 id = ci->idFirstChild + visible;
451
452 if (visible == MDI_MOREWINDOWSLIMIT)
453 {
454 LoadStringW(user32_module, IDS_MDI_MOREWINDOWS, buf, sizeof(buf)/sizeof(WCHAR));
455 AppendMenuW(ci->hWindowMenu, MF_STRING, id, buf);
456 break;
457 }
458
459 if (!visible)
460 /* Visio expects that separator has id 0 */
461 AppendMenuW(ci->hWindowMenu, MF_SEPARATOR, 0, NULL);
462
463 visible++;
464
465 SetWindowLongPtrW(ci->child[i], GWLP_ID, id);
466
467 buf[0] = '&';
468 buf[1] = '' + visible;
469 buf[2] = ' ';
470 InternalGetWindowText(ci->child[i], buf + 3, sizeof(buf)/sizeof(WCHAR) - 3);
471 TRACE("Adding %p, id %u %s\n", ci->child[i], id, debugstr_w(buf));
472 AppendMenuW(ci->hWindowMenu, MF_STRING, id, buf);
473
474 if (ci->child[i] == ci->hwndActiveChild)
475 CheckMenuItem(ci->hWindowMenu, id, MF_CHECKED);
476 }
477 else
478 TRACE("MDI child %p is not visible, skipping\n", ci->child[i]);
479 }
480
481 return (LRESULT)ci->hFrameMenu;
482 }
483
484
485 /* ------------------ MDI child window functions ---------------------- */
486
487 /**********************************************************************
488 * MDI_ChildGetMinMaxInfo
489 *
490 * Note: The rule here is that client rect of the maximized MDI child
491 * is equal to the client rect of the MDI client window.
492 */
493 static void MDI_ChildGetMinMaxInfo( HWND client, HWND hwnd, MINMAXINFO* lpMinMax )
494 {
495 RECT rect;
496
497 GetClientRect( client, &rect );
498 AdjustWindowRectEx( &rect, GetWindowLongW( hwnd, GWL_STYLE ),
499 0, GetWindowLongW( hwnd, GWL_EXSTYLE ));
500
501 lpMinMax->ptMaxSize.x = rect.right -= rect.left;
502 lpMinMax->ptMaxSize.y = rect.bottom -= rect.top;
503
504 lpMinMax->ptMaxPosition.x = rect.left;
505 lpMinMax->ptMaxPosition.y = rect.top;
506
507 TRACE("max rect (%d,%d - %d, %d)\n",
508 rect.left,rect.top,rect.right,rect.bottom);
509 }
510
511 /**********************************************************************
512 * MDI_SwitchActiveChild
513 *
514 * Note: SetWindowPos sends WM_CHILDACTIVATE to the child window that is
515 * being activated
516 */
517 static void MDI_SwitchActiveChild( MDICLIENTINFO *ci, HWND hwndTo, BOOL activate )
518 {
519 HWND hwndPrev;
520
521 hwndPrev = ci->hwndActiveChild;
522
523 TRACE("from %p, to %p\n", hwndPrev, hwndTo);
524
525 if ( hwndTo != hwndPrev )
526 {
527 BOOL was_zoomed = IsZoomed(hwndPrev);
528
529 if (was_zoomed)
530 {
531 /* restore old MDI child */
532 SendMessageW( hwndPrev, WM_SETREDRAW, FALSE, 0 );
533 ShowWindow( hwndPrev, SW_RESTORE );
534 SendMessageW( hwndPrev, WM_SETREDRAW, TRUE, 0 );
535
536 /* activate new MDI child */
537 SetWindowPos( hwndTo, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE );
538 /* maximize new MDI child */
539 ShowWindow( hwndTo, SW_MAXIMIZE );
540 }
541 /* activate new MDI child */
542 SetWindowPos( hwndTo, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | (activate ? 0 : SWP_NOACTIVATE) );
543 }
544 }
545
546
547 /**********************************************************************
548 * MDIDestroyChild
549 */
550 static LRESULT MDIDestroyChild( HWND client, MDICLIENTINFO *ci,
551 HWND child, BOOL flagDestroy )
552 {
553 UINT i;
554
555 TRACE("# of managed children %u\n", ci->nActiveChildren);
556
557 if( child == ci->hwndActiveChild )
558 {
559 HWND next = MDI_GetWindow(ci, child, TRUE, 0);
560 /* flagDestroy == 0 means we were called from WM_PARENTNOTIFY handler */
561 if (flagDestroy && next)
562 MDI_SwitchActiveChild(ci, next, TRUE);
563 else
564 {
565 ShowWindow(child, SW_HIDE);
566 if (child == ci->hwndChildMaximized)
567 {
568 HWND frame = GetParent(client);
569 MDI_RestoreFrameMenu(frame, child);
570 ci->hwndChildMaximized = 0;
571 MDI_UpdateFrameText(frame, client, TRUE, NULL);
572 }
573 if (flagDestroy)
574 MDI_ChildActivate(client, 0);
575 }
576 }
577
578 for (i = 0; i < ci->nActiveChildren; i++)
579 {
580 if (ci->child[i] == child)
581 {
582 HWND *new_child = HeapAlloc(GetProcessHeap(), 0, (ci->nActiveChildren - 1) * sizeof(HWND));
583 memcpy(new_child, ci->child, i * sizeof(HWND));
584 if (i + 1 < ci->nActiveChildren)
585 memcpy(new_child + i, ci->child + i + 1, (ci->nActiveChildren - i - 1) * sizeof(HWND));
586 HeapFree(GetProcessHeap(), 0, ci->child);
587 ci->child = new_child;
588
589 ci->nActiveChildren--;
590 break;
591 }
592 }
593
594 if (flagDestroy)
595 {
596 SendMessageW(client, WM_MDIREFRESHMENU, 0, 0);
597 MDI_PostUpdate(GetParent(child), ci, SB_BOTH+1);
598 DestroyWindow(child);
599 }
600
601 TRACE("child destroyed - %p\n", child);
602 return 0;
603 }
604
605
606 /**********************************************************************
607 * MDI_ChildActivate
608 *
609 * Called in response to WM_CHILDACTIVATE, or when last MDI child
610 * is being deactivated.
611 */
612 static LONG MDI_ChildActivate( HWND client, HWND child )
613 {
614 MDICLIENTINFO *clientInfo;
615 HWND prevActiveWnd, frame;
616 BOOL isActiveFrameWnd;
617
618 clientInfo = get_client_info( client );
619
620 if (clientInfo->hwndActiveChild == child) return 0;
621
622 TRACE("%p\n", child);
623
624 frame = GetParent(client);
625 isActiveFrameWnd = (GetActiveWindow() == frame);
626 prevActiveWnd = clientInfo->hwndActiveChild;
627
628 /* deactivate prev. active child */
629 if(prevActiveWnd)
630 {
631 SendMessageW( prevActiveWnd, WM_NCACTIVATE, FALSE, 0L );
632 SendMessageW( prevActiveWnd, WM_MDIACTIVATE, (WPARAM)prevActiveWnd, (LPARAM)child);
633 }
634
635 MDI_SwitchActiveChild( clientInfo, child, FALSE );
636 clientInfo->hwndActiveChild = child;
637
638 MDI_RefreshMenu(clientInfo);
639
640 if( isActiveFrameWnd )
641 {
642 SendMessageW( child, WM_NCACTIVATE, TRUE, 0L);
643 /* Let the client window manage focus for children, but if the focus
644 * is already on the client (for instance this is the 1st child) then
645 * SetFocus won't work. It appears that Windows sends WM_SETFOCUS
646 * manually in this case.
647 */
648 if (SetFocus(client) == client)
649 SendMessageW( client, WM_SETFOCUS, (WPARAM)client, 0 );
650 }
651
652 SendMessageW( child, WM_MDIACTIVATE, (WPARAM)prevActiveWnd, (LPARAM)child );
653 return TRUE;
654 }
655
656 /* -------------------- MDI client window functions ------------------- */
657
658 /**********************************************************************
659 * CreateMDIMenuBitmap
660 */
661 static HBITMAP CreateMDIMenuBitmap(void)
662 {
663 HDC hDCSrc = CreateCompatibleDC(0);
664 HDC hDCDest = CreateCompatibleDC(hDCSrc);
665 HBITMAP hbClose = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_OLD_CLOSE) );
666 HBITMAP hbCopy;
667 HBITMAP hobjSrc, hobjDest;
668
669 hobjSrc = SelectObject(hDCSrc, hbClose);
670 hbCopy = CreateCompatibleBitmap(hDCSrc,GetSystemMetrics(SM_CXSIZE),GetSystemMetrics(SM_CYSIZE));
671 hobjDest = SelectObject(hDCDest, hbCopy);
672
673 BitBlt(hDCDest, 0, 0, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
674 hDCSrc, GetSystemMetrics(SM_CXSIZE), 0, SRCCOPY);
675
676 SelectObject(hDCSrc, hobjSrc);
677 DeleteObject(hbClose);
678 DeleteDC(hDCSrc);
679
680 hobjSrc = SelectObject( hDCDest, GetStockObject(BLACK_PEN) );
681
682 MoveToEx( hDCDest, GetSystemMetrics(SM_CXSIZE) - 1, 0, NULL );
683 LineTo( hDCDest, GetSystemMetrics(SM_CXSIZE) - 1, GetSystemMetrics(SM_CYSIZE) - 1);
684
685 SelectObject(hDCDest, hobjSrc );
686 SelectObject(hDCDest, hobjDest);
687 DeleteDC(hDCDest);
688
689 return hbCopy;
690 }
691
692 /**********************************************************************
693 * MDICascade
694 */
695 static LONG MDICascade( HWND client, MDICLIENTINFO *ci )
696 {
697 HWND *win_array;
698 BOOL has_icons = FALSE;
699 int i, total;
700
701 if (ci->hwndChildMaximized)
702 SendMessageW(client, WM_MDIRESTORE, (WPARAM)ci->hwndChildMaximized, 0);
703
704 if (ci->nActiveChildren == 0) return 0;
705
706 if (!(win_array = WIN_ListChildren( client ))) return 0;
707
708 /* remove all the windows we don't want */
709 for (i = total = 0; win_array[i]; i++)
710 {
711 if (!IsWindowVisible( win_array[i] )) continue;
712 if (GetWindow( win_array[i], GW_OWNER )) continue; /* skip owned windows */
713 if (IsIconic( win_array[i] ))
714 {
715 has_icons = TRUE;
716 continue;
717 }
718 win_array[total++] = win_array[i];
719 }
720 win_array[total] = 0;
721
722 if (total)
723 {
724 INT delta = 0, n = 0, i;
725 POINT pos[2];
726 if (has_icons) delta = GetSystemMetrics(SM_CYICONSPACING) + GetSystemMetrics(SM_CYICON);
727
728 /* walk the list (backwards) and move windows */
729 for (i = total - 1; i >= 0; i--)
730 {
731 LONG style;
732 LONG posOptions = SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER;
733
734 MDI_CalcDefaultChildPos(client, n++, pos, delta, NULL);
735 TRACE("move %p to (%d,%d) size [%d,%d]\n",
736 win_array[i], pos[0].x, pos[0].y, pos[1].x, pos[1].y);
737 style = GetWindowLongW(win_array[i], GWL_STYLE);
738
739 if (!(style & WS_SIZEBOX)) posOptions |= SWP_NOSIZE;
740 SetWindowPos( win_array[i], 0, pos[0].x, pos[0].y, pos[1].x, pos[1].y,
741 posOptions);
742 }
743 }
744 HeapFree( GetProcessHeap(), 0, win_array );
745
746 if (has_icons) ArrangeIconicWindows( client );
747 return 0;
748 }
749
750 /**********************************************************************
751 * MDITile
752 */
753 static void MDITile( HWND client, MDICLIENTINFO *ci, WPARAM wParam )
754 {
755 HWND *win_array;
756 int i, total;
757 BOOL has_icons = FALSE;
758
759 if (ci->hwndChildMaximized)
760 SendMessageW(client, WM_MDIRESTORE, (WPARAM)ci->hwndChildMaximized, 0);
761
762 if (ci->nActiveChildren == 0) return;
763
764 if (!(win_array = WIN_ListChildren( client ))) return;
765
766 /* remove all the windows we don't want */
767 for (i = total = 0; win_array[i]; i++)
768 {
769 if (!IsWindowVisible( win_array[i] )) continue;
770 if (GetWindow( win_array[i], GW_OWNER )) continue; /* skip owned windows (icon titles) */
771 if (IsIconic( win_array[i] ))
772 {
773 has_icons = TRUE;
774 continue;
775 }
776 if ((wParam & MDITILE_SKIPDISABLED) && !IsWindowEnabled( win_array[i] )) continue;
777 win_array[total++] = win_array[i];
778 }
779 win_array[total] = 0;
780
781 TRACE("%u windows to tile\n", total);
782
783 if (total)
784 {
785 HWND *pWnd = win_array;
786 RECT rect;
787 int x, y, xsize, ysize;
788 int rows, columns, r, c, i;
789
790 GetClientRect(client,&rect);
791 rows = (int) sqrt((double)total);
792 columns = total / rows;
793
794 if( wParam & MDITILE_HORIZONTAL ) /* version >= 3.1 */
795 {
796 i = rows;
797 rows = columns; /* exchange r and c */
798 columns = i;
799 }
800
801 if (has_icons)
802 {
803 y = rect.bottom - 2 * GetSystemMetrics(SM_CYICONSPACING) - GetSystemMetrics(SM_CYICON);
804 rect.bottom = ( y - GetSystemMetrics(SM_CYICON) < rect.top )? rect.bottom: y;
805 }
806
807 ysize = rect.bottom / rows;
808 xsize = rect.right / columns;
809
810 for (x = i = 0, c = 1; c <= columns && *pWnd; c++)
811 {
812 if (c == columns)
813 {
814 rows = total - i;
815 ysize = rect.bottom / rows;
816 }
817
818 y = 0;
819 for (r = 1; r <= rows && *pWnd; r++, i++)
820 {
821 LONG posOptions = SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER;
822 LONG style = GetWindowLongW(win_array[i], GWL_STYLE);
823 if (!(style & WS_SIZEBOX)) posOptions |= SWP_NOSIZE;
824
825 SetWindowPos(*pWnd, 0, x, y, xsize, ysize, posOptions);
826 y += ysize;
827 pWnd++;
828 }
829 x += xsize;
830 }
831 }
832 HeapFree( GetProcessHeap(), 0, win_array );
833 if (has_icons) ArrangeIconicWindows( client );
834 }
835
836 /* ----------------------- Frame window ---------------------------- */
837
838
839 /**********************************************************************
840 * MDI_AugmentFrameMenu
841 */
842 static BOOL MDI_AugmentFrameMenu( HWND frame, HWND hChild )
843 {
844 HMENU menu = GetMenu( frame );
845 HMENU hSysPopup = 0;
846 HBITMAP hSysMenuBitmap = 0;
847 HICON hIcon;
848
849 TRACE("frame %p,child %p\n",frame,hChild);
850
851 if( !menu ) return 0;
852
853 /* create a copy of sysmenu popup and insert it into frame menu bar */
854 if (!(hSysPopup = GetSystemMenu(hChild, FALSE)))
855 {
856 TRACE("child %p doesn't have a system menu\n", hChild);
857 return 0;
858 }
859
860 AppendMenuW(menu, MF_HELP | MF_BITMAP,
861 SC_CLOSE, is_close_enabled(hChild, hSysPopup) ?
862 (LPCWSTR)HBMMENU_MBAR_CLOSE : (LPCWSTR)HBMMENU_MBAR_CLOSE_D );
863 AppendMenuW(menu, MF_HELP | MF_BITMAP,
864 SC_RESTORE, (LPCWSTR)HBMMENU_MBAR_RESTORE );
865 AppendMenuW(menu, MF_HELP | MF_BITMAP,
866 SC_MINIMIZE, (LPCWSTR)HBMMENU_MBAR_MINIMIZE ) ;
867
868 /* The system menu is replaced by the child icon */
869 hIcon = (HICON)SendMessageW(hChild, WM_GETICON, ICON_SMALL, 0);
870 if (!hIcon)
871 hIcon = (HICON)SendMessageW(hChild, WM_GETICON, ICON_BIG, 0);
872 if (!hIcon)
873 hIcon = LoadImageW(0, MAKEINTRESOURCEW(IDI_WINLOGO), IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
874 if (hIcon)
875 {
876 HDC hMemDC;
877 HBITMAP hBitmap, hOldBitmap;
878 HBRUSH hBrush;
879 HDC hdc = GetDC(hChild);
880
881 if (hdc)
882 {
883 int cx, cy;
884 cx = GetSystemMetrics(SM_CXSMICON);
885 cy = GetSystemMetrics(SM_CYSMICON);
886 hMemDC = CreateCompatibleDC(hdc);
887 hBitmap = CreateCompatibleBitmap(hdc, cx, cy);
888 hOldBitmap = SelectObject(hMemDC, hBitmap);
889 SetMapMode(hMemDC, MM_TEXT);
890 hBrush = CreateSolidBrush(GetSysColor(COLOR_MENU));
891 DrawIconEx(hMemDC, 0, 0, hIcon, cx, cy, 0, hBrush, DI_NORMAL);
892 SelectObject (hMemDC, hOldBitmap);
893 DeleteObject(hBrush);
894 DeleteDC(hMemDC);
895 ReleaseDC(hChild, hdc);
896 hSysMenuBitmap = hBitmap;
897 }
898 }
899
900 if( !InsertMenuA(menu,0,MF_BYPOSITION | MF_BITMAP | MF_POPUP,
901 (UINT_PTR)hSysPopup, (LPSTR)hSysMenuBitmap))
902 {
903 TRACE("not inserted\n");
904 DestroyMenu(hSysPopup);
905 return 0;
906 }
907
908 EnableMenuItem(hSysPopup, SC_SIZE, MF_BYCOMMAND | MF_GRAYED);
909 EnableMenuItem(hSysPopup, SC_MOVE, MF_BYCOMMAND | MF_GRAYED);
910 EnableMenuItem(hSysPopup, SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED);
911 SetMenuDefaultItem(hSysPopup, SC_CLOSE, FALSE);
912
913 /* redraw menu */
914 DrawMenuBar(frame);
915
916 return 1;
917 }
918
919 /**********************************************************************
920 * MDI_RestoreFrameMenu
921 */
922 static BOOL MDI_RestoreFrameMenu( HWND frame, HWND hChild )
923 {
924 MENUITEMINFOW menuInfo;
925 HMENU menu = GetMenu( frame );
926 INT nItems;
927 UINT iId;
928
929 TRACE("frame %p, child %p\n", frame, hChild);
930
931 if( !menu ) return 0;
932
933 /* if there is no system buttons then nothing to do */
934 nItems = GetMenuItemCount(menu) - 1;
935 iId = GetMenuItemID(menu, nItems);
936 if ( !(iId == SC_RESTORE || iId == SC_CLOSE) )
937 return 0;
938
939 /*
940 * Remove the system menu, If that menu is the icon of the window
941 * as it is in win95, we have to delete the bitmap.
942 */
943 memset(&menuInfo, 0, sizeof(menuInfo));
944 menuInfo.cbSize = sizeof(menuInfo);
945 menuInfo.fMask = MIIM_DATA | MIIM_TYPE;
946
947 GetMenuItemInfoW(menu,
948 0,
949 TRUE,
950 &menuInfo);
951
952 RemoveMenu(menu,0,MF_BYPOSITION);
953
954 if ( (menuInfo.fType & MFT_BITMAP) &&
955 (LOWORD(menuInfo.dwTypeData)!=0) &&
956 (LOWORD(menuInfo.dwTypeData)!=HBITMAP_16(hBmpClose)) )
957 {
958 DeleteObject(HBITMAP_32(LOWORD(menuInfo.dwTypeData)));
959 }
960
961 /* close */
962 DeleteMenu(menu, SC_CLOSE, MF_BYCOMMAND);
963 /* restore */
964 DeleteMenu(menu, SC_RESTORE, MF_BYCOMMAND);
965 /* minimize */
966 DeleteMenu(menu, SC_MINIMIZE, MF_BYCOMMAND);
967
968 DrawMenuBar(frame);
969
970 return 1;
971 }
972
973
974 /**********************************************************************
975 * MDI_UpdateFrameText
976 *
977 * used when child window is maximized/restored
978 *
979 * Note: lpTitle can be NULL
980 */
981 static void MDI_UpdateFrameText( HWND frame, HWND hClient, BOOL repaint, LPCWSTR lpTitle )
982 {
983 WCHAR lpBuffer[MDI_MAXTITLELENGTH+1];
984 MDICLIENTINFO *ci = get_client_info( hClient );
985
986 TRACE("frameText %s\n", debugstr_w(lpTitle));
987
988 if (!ci) return;
989
990 if (!lpTitle && !ci->frameTitle) /* first time around, get title from the frame window */
991 {
992 GetWindowTextW( frame, lpBuffer, sizeof(lpBuffer)/sizeof(WCHAR) );
993 lpTitle = lpBuffer;
994 }
995
996 /* store new "default" title if lpTitle is not NULL */
997 if (lpTitle)
998 {
999 HeapFree( GetProcessHeap(), 0, ci->frameTitle );
1000 if ((ci->frameTitle = HeapAlloc( GetProcessHeap(), 0, (strlenW(lpTitle)+1)*sizeof(WCHAR))))
1001 strcpyW( ci->frameTitle, lpTitle );
1002 }
1003
1004 if (ci->frameTitle)
1005 {
1006 if (ci->hwndChildMaximized)
1007 {
1008 /* combine frame title and child title if possible */
1009
1010 static const WCHAR lpBracket[] = {' ','-',' ','[',0};
1011 static const WCHAR lpBracket2[] = {']',0};
1012 int i_frame_text_length = strlenW(ci->frameTitle);
1013
1014 lstrcpynW( lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH);
1015
1016 if( i_frame_text_length + 6 < MDI_MAXTITLELENGTH )
1017 {
1018 strcatW( lpBuffer, lpBracket );
1019 if (GetWindowTextW( ci->hwndActiveChild, lpBuffer + i_frame_text_length + 4,
1020 MDI_MAXTITLELENGTH - i_frame_text_length - 5 ))
1021 strcatW( lpBuffer, lpBracket2 );
1022 else
1023 lpBuffer[i_frame_text_length] = 0; /* remove bracket */
1024 }
1025 }
1026 else
1027 {
1028 lstrcpynW(lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH+1 );
1029 }
1030 }
1031 else
1032 lpBuffer[0] = '\0';
1033
1034 DefWindowProcW( frame, WM_SETTEXT, 0, (LPARAM)lpBuffer );
1035
1036 if (repaint)
1037 SetWindowPos( frame, 0,0,0,0,0, SWP_FRAMECHANGED |
1038 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER );
1039 }
1040
1041
1042 /* ----------------------------- Interface ---------------------------- */
1043
1044
1045 /**********************************************************************
1046 * MDIClientWndProc_common
1047 */
1048 static LRESULT MDIClientWndProc_common( HWND hwnd, UINT message,
1049 WPARAM wParam, LPARAM lParam, BOOL unicode )
1050 {
1051 MDICLIENTINFO *ci;
1052
1053 TRACE("%p %04x (%s) %08lx %08lx\n", hwnd, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1054
1055 if (!(ci = get_client_info( hwnd )))
1056 {
1057 if (message == WM_NCCREATE)
1058 {
1059 WND *wndPtr = WIN_GetPtr( hwnd );
1060 wndPtr->flags |= WIN_ISMDICLIENT;
1061 WIN_ReleasePtr( wndPtr );
1062 }
1063 return unicode ? DefWindowProcW( hwnd, message, wParam, lParam ) :
1064 DefWindowProcA( hwnd, message, wParam, lParam );
1065 }
1066
1067 switch (message)
1068 {
1069 case WM_CREATE:
1070 {
1071 /* Since we are using only cs->lpCreateParams, we can safely
1072 * cast to LPCREATESTRUCTA here */
1073 LPCREATESTRUCTA cs = (LPCREATESTRUCTA)lParam;
1074 WND *wndPtr = WIN_GetPtr( hwnd );
1075
1076 /* Translation layer doesn't know what's in the cs->lpCreateParams
1077 * so we have to keep track of what environment we're in. */
1078
1079 if( wndPtr->flags & WIN_ISWIN32 )
1080 {
1081 LPCLIENTCREATESTRUCT ccs = cs->lpCreateParams;
1082 ci->hWindowMenu = ccs->hWindowMenu;
1083 ci->idFirstChild = ccs->idFirstChild;
1084 }
1085 else
1086 {
1087 LPCLIENTCREATESTRUCT16 ccs = MapSL(PtrToUlong(cs->lpCreateParams));
1088 ci->hWindowMenu = HMENU_32(ccs->hWindowMenu);
1089 ci->idFirstChild = ccs->idFirstChild;
1090 }
1091 WIN_ReleasePtr( wndPtr );
1092
1093 ci->hwndChildMaximized = 0;
1094 ci->child = NULL;
1095 ci->nActiveChildren = 0;
1096 ci->nTotalCreated = 0;
1097 ci->frameTitle = NULL;
1098 ci->mdiFlags = 0;
1099 ci->hFrameMenu = GetMenu(cs->hwndParent);
1100
1101 if (!hBmpClose) hBmpClose = CreateMDIMenuBitmap();
1102
1103 TRACE("Client created: hwnd %p, Window menu %p, idFirst = %04x\n",
1104 hwnd, ci->hWindowMenu, ci->idFirstChild );
1105 return 0;
1106 }
1107
1108 case WM_DESTROY:
1109 {
1110 if( ci->hwndChildMaximized )
1111 MDI_RestoreFrameMenu(GetParent(hwnd), ci->hwndChildMaximized);
1112
1113 ci->nActiveChildren = 0;
1114 MDI_RefreshMenu(ci);
1115
1116 HeapFree( GetProcessHeap(), 0, ci->child );
1117 HeapFree( GetProcessHeap(), 0, ci->frameTitle );
1118
1119 return 0;
1120 }
1121
1122 case WM_MDIACTIVATE:
1123 {
1124 if( ci->hwndActiveChild != (HWND)wParam )
1125 SetWindowPos((HWND)wParam, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE);
1126 return 0;
1127 }
1128
1129 case WM_MDICASCADE:
1130 return MDICascade(hwnd, ci);
1131
1132 case WM_MDICREATE:
1133 if (lParam)
1134 {
1135 HWND child;
1136
1137 if (unicode)
1138 {
1139 MDICREATESTRUCTW *csW = (MDICREATESTRUCTW *)lParam;
1140 child = CreateWindowExW(WS_EX_MDICHILD, csW->szClass,
1141 csW->szTitle, csW->style,
1142 csW->x, csW->y, csW->cx, csW->cy,
1143 hwnd, 0, csW->hOwner,
1144 (LPVOID)csW->lParam);
1145 }
1146 else
1147 {
1148 MDICREATESTRUCTA *csA = (MDICREATESTRUCTA *)lParam;
1149 child = CreateWindowExA(WS_EX_MDICHILD, csA->szClass,
1150 csA->szTitle, csA->style,
1151 csA->x, csA->y, csA->cx, csA->cy,
1152 hwnd, 0, csA->hOwner,
1153 (LPVOID)csA->lParam);
1154 }
1155 return (LRESULT)child;
1156 }
1157 return 0;
1158
1159 case WM_MDIDESTROY:
1160 return MDIDestroyChild( hwnd, ci, WIN_GetFullHandle( (HWND)wParam ), TRUE );
1161
1162 case WM_MDIGETACTIVE:
1163 if (lParam) *(BOOL *)lParam = IsZoomed(ci->hwndActiveChild);
1164 return (LRESULT)ci->hwndActiveChild;
1165
1166 case WM_MDIICONARRANGE:
1167 ci->mdiFlags |= MDIF_NEEDUPDATE;
1168 ArrangeIconicWindows( hwnd );
1169 ci->sbRecalc = SB_BOTH+1;
1170 SendMessageW( hwnd, WM_MDICALCCHILDSCROLL, 0, 0 );
1171 return 0;
1172
1173 case WM_MDIMAXIMIZE:
1174 ShowWindow( (HWND)wParam, SW_MAXIMIZE );
1175 return 0;
1176
1177 case WM_MDINEXT: /* lParam != 0 means previous window */
1178 {
1179 HWND next = MDI_GetWindow( ci, WIN_GetFullHandle( (HWND)wParam ), !lParam, 0 );
1180 MDI_SwitchActiveChild( ci, next, TRUE );
1181 break;
1182 }
1183
1184 case WM_MDIRESTORE:
1185 ShowWindow( (HWND)wParam, SW_SHOWNORMAL );
1186 return 0;
1187
1188 case WM_MDISETMENU:
1189 return MDISetMenu( hwnd, (HMENU)wParam, (HMENU)lParam );
1190
1191 case WM_MDIREFRESHMENU:
1192 return MDI_RefreshMenu( ci );
1193
1194 case WM_MDITILE:
1195 ci->mdiFlags |= MDIF_NEEDUPDATE;
1196 ShowScrollBar( hwnd, SB_BOTH, FALSE );
1197 MDITile( hwnd, ci, wParam );
1198 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1199 return 0;
1200
1201 case WM_VSCROLL:
1202 case WM_HSCROLL:
1203 ci->mdiFlags |= MDIF_NEEDUPDATE;
1204 ScrollChildren( hwnd, message, wParam, lParam );
1205 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1206 return 0;
1207
1208 case WM_SETFOCUS:
1209 if (ci->hwndActiveChild && !IsIconic( ci->hwndActiveChild ))
1210 SetFocus( ci->hwndActiveChild );
1211 return 0;
1212
1213 case WM_NCACTIVATE:
1214 if( ci->hwndActiveChild )
1215 SendMessageW(ci->hwndActiveChild, message, wParam, lParam);
1216 break;
1217
1218 case WM_PARENTNOTIFY:
1219 switch (LOWORD(wParam))
1220 {
1221 case WM_CREATE:
1222 if (GetWindowLongW((HWND)lParam, GWL_EXSTYLE) & WS_EX_MDICHILD)
1223 {
1224 ci->nTotalCreated++;
1225 ci->nActiveChildren++;
1226
1227 if (!ci->child)
1228 ci->child = HeapAlloc(GetProcessHeap(), 0, sizeof(HWND));
1229 else
1230 ci->child = HeapReAlloc(GetProcessHeap(), 0, ci->child, sizeof(HWND) * ci->nActiveChildren);
1231
1232 TRACE("Adding MDI child %p, # of children %d\n",
1233 (HWND)lParam, ci->nActiveChildren);
1234
1235 ci->child[ci->nActiveChildren - 1] = (HWND)lParam;
1236 }
1237 break;
1238
1239 case WM_LBUTTONDOWN:
1240 {
1241 HWND child;
1242 POINT pt;
1243 pt.x = (short)LOWORD(lParam);
1244 pt.y = (short)HIWORD(lParam);
1245 child = ChildWindowFromPoint(hwnd, pt);
1246
1247 TRACE("notification from %p (%i,%i)\n",child,pt.x,pt.y);
1248
1249 if( child && child != hwnd && child != ci->hwndActiveChild )
1250 SetWindowPos(child, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
1251 break;
1252 }
1253
1254 case WM_DESTROY:
1255 return MDIDestroyChild( hwnd, ci, WIN_GetFullHandle( (HWND)lParam ), FALSE );
1256 }
1257 return 0;
1258
1259 case WM_SIZE:
1260 if( ci->hwndActiveChild && IsZoomed(ci->hwndActiveChild) )
1261 {
1262 RECT rect;
1263
1264 rect.left = 0;
1265 rect.top = 0;
1266 rect.right = LOWORD(lParam);
1267 rect.bottom = HIWORD(lParam);
1268 AdjustWindowRectEx(&rect, GetWindowLongA(ci->hwndActiveChild, GWL_STYLE),
1269 0, GetWindowLongA(ci->hwndActiveChild, GWL_EXSTYLE) );
1270 MoveWindow(ci->hwndActiveChild, rect.left, rect.top,
1271 rect.right - rect.left, rect.bottom - rect.top, 1);
1272 }
1273 else
1274 MDI_PostUpdate(hwnd, ci, SB_BOTH+1);
1275
1276 break;
1277
1278 case WM_MDICALCCHILDSCROLL:
1279 if( (ci->mdiFlags & MDIF_NEEDUPDATE) && ci->sbRecalc )
1280 {
1281 CalcChildScroll(hwnd, ci->sbRecalc-1);
1282 ci->sbRecalc = 0;
1283 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1284 }
1285 return 0;
1286 }
1287 return unicode ? DefWindowProcW( hwnd, message, wParam, lParam ) :
1288 DefWindowProcA( hwnd, message, wParam, lParam );
1289 }
1290
1291 /***********************************************************************
1292 * MDIClientWndProcA
1293 */
1294 static LRESULT WINAPI MDIClientWndProcA( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
1295 {
1296 if (!IsWindow(hwnd)) return 0;
1297 return MDIClientWndProc_common( hwnd, message, wParam, lParam, FALSE );
1298 }
1299
1300 /***********************************************************************
1301 * MDIClientWndProcW
1302 */
1303 static LRESULT WINAPI MDIClientWndProcW( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
1304 {
1305 if (!IsWindow(hwnd)) return 0;
1306 return MDIClientWndProc_common( hwnd, message, wParam, lParam, TRUE );
1307 }
1308
1309 /***********************************************************************
1310 * DefFrameProcA (USER32.@)
1311 */
1312 LRESULT WINAPI DefFrameProcA( HWND hwnd, HWND hwndMDIClient,
1313 UINT message, WPARAM wParam, LPARAM lParam)
1314 {
1315 if (hwndMDIClient)
1316 {
1317 switch (message)
1318 {
1319 case WM_SETTEXT:
1320 {
1321 DWORD len = MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, NULL, 0 );
1322 LPWSTR text = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1323 MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, text, len );
1324 MDI_UpdateFrameText( hwnd, hwndMDIClient, FALSE, text );
1325 HeapFree( GetProcessHeap(), 0, text );
1326 }
1327 return 1; /* success. FIXME: check text length */
1328
1329 case WM_COMMAND:
1330 case WM_NCACTIVATE:
1331 case WM_NEXTMENU:
1332 case WM_SETFOCUS:
1333 case WM_SIZE:
1334 return DefFrameProcW( hwnd, hwndMDIClient, message, wParam, lParam );
1335 }
1336 }
1337 return DefWindowProcA(hwnd, message, wParam, lParam);
1338 }
1339
1340
1341 /***********************************************************************
1342 * DefFrameProcW (USER32.@)
1343 */
1344 LRESULT WINAPI DefFrameProcW( HWND hwnd, HWND hwndMDIClient,
1345 UINT message, WPARAM wParam, LPARAM lParam)
1346 {
1347 MDICLIENTINFO *ci = get_client_info( hwndMDIClient );
1348
1349 TRACE("%p %p %04x (%s) %08lx %08lx\n", hwnd, hwndMDIClient, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1350
1351 if (ci)
1352 {
1353 switch (message)
1354 {
1355 case WM_COMMAND:
1356 {
1357 WORD id = LOWORD(wParam);
1358 /* check for possible syscommands for maximized MDI child */
1359 if (id < ci->idFirstChild || id >= ci->idFirstChild + ci->nActiveChildren)
1360 {
1361 if( (id - 0xf000) & 0xf00f ) break;
1362 if( !ci->hwndChildMaximized ) break;
1363 switch( id )
1364 {
1365 case SC_CLOSE:
1366 if (!is_close_enabled(ci->hwndActiveChild, 0)) break;
1367 case SC_SIZE:
1368 case SC_MOVE:
1369 case SC_MINIMIZE:
1370 case SC_MAXIMIZE:
1371 case SC_NEXTWINDOW:
1372 case SC_PREVWINDOW:
1373 case SC_RESTORE:
1374 return SendMessageW( ci->hwndChildMaximized, WM_SYSCOMMAND,
1375 wParam, lParam);
1376 }
1377 }
1378 else
1379 {
1380 HWND childHwnd;
1381 if (id - ci->idFirstChild == MDI_MOREWINDOWSLIMIT)
1382 /* User chose "More Windows..." */
1383 childHwnd = MDI_MoreWindowsDialog(hwndMDIClient);
1384 else
1385 /* User chose one of the windows listed in the "Windows" menu */
1386 childHwnd = MDI_GetChildByID(hwndMDIClient, id, ci);
1387
1388 if( childHwnd )
1389 SendMessageW( hwndMDIClient, WM_MDIACTIVATE, (WPARAM)childHwnd, 0 );
1390 }
1391 }
1392 break;
1393
1394 case WM_NCACTIVATE:
1395 SendMessageW(hwndMDIClient, message, wParam, lParam);
1396 break;
1397
1398 case WM_SETTEXT:
1399 MDI_UpdateFrameText( hwnd, hwndMDIClient, FALSE, (LPWSTR)lParam );
1400 return 1; /* success. FIXME: check text length */
1401
1402 case WM_SETFOCUS:
1403 SetFocus(hwndMDIClient);
1404 break;
1405
1406 case WM_SIZE:
1407 MoveWindow(hwndMDIClient, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
1408 break;
1409
1410 case WM_NEXTMENU:
1411 {
1412 MDINEXTMENU *next_menu = (MDINEXTMENU *)lParam;
1413
1414 if (!IsIconic(hwnd) && ci->hwndActiveChild && !IsZoomed(ci->hwndActiveChild))
1415 {
1416 /* control menu is between the frame system menu and
1417 * the first entry of menu bar */
1418 WND *wndPtr = WIN_GetPtr(hwnd);
1419
1420 if( (wParam == VK_LEFT && GetMenu(hwnd) == next_menu->hmenuIn) ||
1421 (wParam == VK_RIGHT && GetSubMenu(wndPtr->hSysMenu, 0) == next_menu->hmenuIn) )
1422 {
1423 WIN_ReleasePtr(wndPtr);
1424 wndPtr = WIN_GetPtr(ci->hwndActiveChild);
1425 next_menu->hmenuNext = GetSubMenu(wndPtr->hSysMenu, 0);
1426 next_menu->hwndNext = ci->hwndActiveChild;
1427 }
1428 WIN_ReleasePtr(wndPtr);
1429 }
1430 return 0;
1431 }
1432 }
1433 }
1434
1435 return DefWindowProcW( hwnd, message, wParam, lParam );
1436 }
1437
1438 /***********************************************************************
1439 * DefMDIChildProcA (USER32.@)
1440 */
1441 LRESULT WINAPI DefMDIChildProcA( HWND hwnd, UINT message,
1442 WPARAM wParam, LPARAM lParam )
1443 {
1444 HWND client = GetParent(hwnd);
1445 MDICLIENTINFO *ci = get_client_info( client );
1446
1447 TRACE("%p %04x (%s) %08lx %08lx\n", hwnd, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1448
1449 hwnd = WIN_GetFullHandle( hwnd );
1450 if (!ci) return DefWindowProcA( hwnd, message, wParam, lParam );
1451
1452 switch (message)
1453 {
1454 case WM_SETTEXT:
1455 DefWindowProcA(hwnd, message, wParam, lParam);
1456 if( ci->hwndChildMaximized == hwnd )
1457 MDI_UpdateFrameText( GetParent(client), client, TRUE, NULL );
1458 return 1; /* success. FIXME: check text length */
1459
1460 case WM_GETMINMAXINFO:
1461 case WM_MENUCHAR:
1462 case WM_CLOSE:
1463 case WM_SETFOCUS:
1464 case WM_CHILDACTIVATE:
1465 case WM_SYSCOMMAND:
1466 case WM_SHOWWINDOW:
1467 case WM_SETVISIBLE:
1468 case WM_SIZE:
1469 case WM_NEXTMENU:
1470 case WM_SYSCHAR:
1471 case WM_DESTROY:
1472 return DefMDIChildProcW( hwnd, message, wParam, lParam );
1473 }
1474 return DefWindowProcA(hwnd, message, wParam, lParam);
1475 }
1476
1477
1478 /***********************************************************************
1479 * DefMDIChildProcW (USER32.@)
1480 */
1481 LRESULT WINAPI DefMDIChildProcW( HWND hwnd, UINT message,
1482 WPARAM wParam, LPARAM lParam )
1483 {
1484 HWND client = GetParent(hwnd);
1485 MDICLIENTINFO *ci = get_client_info( client );
1486
1487 TRACE("%p %04x (%s) %08lx %08lx\n", hwnd, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1488
1489 hwnd = WIN_GetFullHandle( hwnd );
1490 if (!ci) return DefWindowProcW( hwnd, message, wParam, lParam );
1491
1492 switch (message)
1493 {
1494 case WM_SETTEXT:
1495 DefWindowProcW(hwnd, message, wParam, lParam);
1496 if( ci->hwndChildMaximized == hwnd )
1497 MDI_UpdateFrameText( GetParent(client), client, TRUE, NULL );
1498 return 1; /* success. FIXME: check text length */
1499
1500 case WM_GETMINMAXINFO:
1501 MDI_ChildGetMinMaxInfo( client, hwnd, (MINMAXINFO *)lParam );
1502 return 0;
1503
1504 case WM_MENUCHAR:
1505 return 0x00010000; /* MDI children don't have menu bars */
1506
1507 case WM_CLOSE:
1508 SendMessageW( client, WM_MDIDESTROY, (WPARAM)hwnd, 0 );
1509 return 0;
1510
1511 case WM_SETFOCUS:
1512 if (ci->hwndActiveChild != hwnd)
1513 MDI_ChildActivate( client, hwnd );
1514 break;
1515
1516 case WM_CHILDACTIVATE:
1517 MDI_ChildActivate( client, hwnd );
1518 return 0;
1519
1520 case WM_SYSCOMMAND:
1521 switch (wParam & 0xfff0)
1522 {
1523 case SC_MOVE:
1524 if( ci->hwndChildMaximized == hwnd )
1525 return 0;
1526 break;
1527 case SC_RESTORE:
1528 case SC_MINIMIZE:
1529 break;
1530 case SC_MAXIMIZE:
1531 if (ci->hwndChildMaximized == hwnd)
1532 return SendMessageW( GetParent(client), message, wParam, lParam);
1533 break;
1534 case SC_NEXTWINDOW:
1535 SendMessageW( client, WM_MDINEXT, 0, 0);
1536 return 0;
1537 case SC_PREVWINDOW:
1538 SendMessageW( client, WM_MDINEXT, 0, 1);
1539 return 0;
1540 }
1541 break;
1542
1543 case WM_SHOWWINDOW:
1544 case WM_SETVISIBLE:
1545 if (ci->hwndChildMaximized) ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1546 else MDI_PostUpdate(client, ci, SB_BOTH+1);
1547 break;
1548
1549 case WM_SIZE:
1550 /* This is the only place where we switch to/from maximized state */
1551 /* do not change */
1552 TRACE("current active %p, maximized %p\n", ci->hwndActiveChild, ci->hwndChildMaximized);
1553
1554 if( ci->hwndChildMaximized == hwnd && wParam != SIZE_MAXIMIZED )
1555 {
1556 HWND frame;
1557
1558 ci->hwndChildMaximized = 0;
1559
1560 frame = GetParent(client);
1561 MDI_RestoreFrameMenu( frame, hwnd );
1562 MDI_UpdateFrameText( frame, client, TRUE, NULL );
1563 }
1564
1565 if( wParam == SIZE_MAXIMIZED )
1566 {
1567 HWND frame, hMaxChild = ci->hwndChildMaximized;
1568
1569 if( hMaxChild == hwnd ) break;
1570
1571 if( hMaxChild)
1572 {
1573 SendMessageW( hMaxChild, WM_SETREDRAW, FALSE, 0 );
1574
1575 MDI_RestoreFrameMenu( GetParent(client), hMaxChild );
1576 ShowWindow( hMaxChild, SW_SHOWNOACTIVATE );
1577
1578 SendMessageW( hMaxChild, WM_SETREDRAW, TRUE, 0 );
1579 }
1580
1581 TRACE("maximizing child %p\n", hwnd );
1582
1583 /* keep track of the maximized window. */
1584 ci->hwndChildMaximized = hwnd; /* !!! */
1585
1586 frame = GetParent(client);
1587 MDI_AugmentFrameMenu( frame, hwnd );
1588 MDI_UpdateFrameText( frame, client, TRUE, NULL );
1589 }
1590
1591 if( wParam == SIZE_MINIMIZED )
1592 {
1593 HWND switchTo = MDI_GetWindow( ci, hwnd, TRUE, WS_MINIMIZE );
1594
1595 if (!switchTo) switchTo = hwnd;
1596 SendMessageW( switchTo, WM_CHILDACTIVATE, 0, 0 );
1597 }
1598
1599 MDI_PostUpdate(client, ci, SB_BOTH+1);
1600 break;
1601
1602 case WM_NEXTMENU:
1603 {
1604 MDINEXTMENU *next_menu = (MDINEXTMENU *)lParam;
1605 HWND parent = GetParent(client);
1606
1607 if( wParam == VK_LEFT ) /* switch to frame system menu */
1608 {
1609 WND *wndPtr = WIN_GetPtr( parent );
1610 next_menu->hmenuNext = GetSubMenu( wndPtr->hSysMenu, 0 );
1611 WIN_ReleasePtr( wndPtr );
1612 }
1613 if( wParam == VK_RIGHT ) /* to frame menu bar */
1614 {
1615 next_menu->hmenuNext = GetMenu(parent);
1616 }
1617 next_menu->hwndNext = parent;
1618 return 0;
1619 }
1620
1621 case WM_SYSCHAR:
1622 if (wParam == '-')
1623 {
1624 SendMessageW( hwnd, WM_SYSCOMMAND, (WPARAM)SC_KEYMENU, (DWORD)VK_SPACE);
1625 return 0;
1626 }
1627 break;
1628
1629 case WM_DESTROY:
1630 /* Remove itself from the Window menu */
1631 MDI_RefreshMenu(ci);
1632 break;
1633 }
1634 return DefWindowProcW(hwnd, message, wParam, lParam);
1635 }
1636
1637 /**********************************************************************
1638 * CreateMDIWindowA (USER32.@) Creates a MDI child
1639 *
1640 * RETURNS
1641 * Success: Handle to created window
1642 * Failure: NULL
1643 */
1644 HWND WINAPI CreateMDIWindowA(
1645 LPCSTR lpClassName, /* [in] Pointer to registered child class name */
1646 LPCSTR lpWindowName, /* [in] Pointer to window name */
1647 DWORD dwStyle, /* [in] Window style */
1648 INT X, /* [in] Horizontal position of window */
1649 INT Y, /* [in] Vertical position of window */
1650 INT nWidth, /* [in] Width of window */
1651 INT nHeight, /* [in] Height of window */
1652 HWND hWndParent, /* [in] Handle to parent window */
1653 HINSTANCE hInstance, /* [in] Handle to application instance */
1654 LPARAM lParam) /* [in] Application-defined value */
1655 {
1656 TRACE("(%s,%s,%08x,%d,%d,%d,%d,%p,%p,%08lx)\n",
1657 debugstr_a(lpClassName),debugstr_a(lpWindowName),dwStyle,X,Y,
1658 nWidth,nHeight,hWndParent,hInstance,lParam);
1659
1660 return CreateWindowExA(WS_EX_MDICHILD, lpClassName, lpWindowName,
1661 dwStyle, X, Y, nWidth, nHeight, hWndParent,
1662 0, hInstance, (LPVOID)lParam);
1663 }
1664
1665 /***********************************************************************
1666 * CreateMDIWindowW (USER32.@) Creates a MDI child
1667 *
1668 * RETURNS
1669 * Success: Handle to created window
1670 * Failure: NULL
1671 */
1672 HWND WINAPI CreateMDIWindowW(
1673 LPCWSTR lpClassName, /* [in] Pointer to registered child class name */
1674 LPCWSTR lpWindowName, /* [in] Pointer to window name */
1675 DWORD dwStyle, /* [in] Window style */
1676 INT X, /* [in] Horizontal position of window */
1677 INT Y, /* [in] Vertical position of window */
1678 INT nWidth, /* [in] Width of window */
1679 INT nHeight, /* [in] Height of window */
1680 HWND hWndParent, /* [in] Handle to parent window */
1681 HINSTANCE hInstance, /* [in] Handle to application instance */
1682 LPARAM lParam) /* [in] Application-defined value */
1683 {
1684 TRACE("(%s,%s,%08x,%d,%d,%d,%d,%p,%p,%08lx)\n",
1685 debugstr_w(lpClassName), debugstr_w(lpWindowName), dwStyle, X, Y,
1686 nWidth, nHeight, hWndParent, hInstance, lParam);
1687
1688 return CreateWindowExW(WS_EX_MDICHILD, lpClassName, lpWindowName,
1689 dwStyle, X, Y, nWidth, nHeight, hWndParent,
1690 0, hInstance, (LPVOID)lParam);
1691 }
1692
1693 /**********************************************************************
1694 * TranslateMDISysAccel (USER32.@)
1695 */
1696 BOOL WINAPI TranslateMDISysAccel( HWND hwndClient, LPMSG msg )
1697 {
1698 if (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
1699 {
1700 MDICLIENTINFO *ci = get_client_info( hwndClient );
1701 WPARAM wParam = 0;
1702
1703 if (!ci || !IsWindowEnabled(ci->hwndActiveChild)) return 0;
1704
1705 /* translate if the Ctrl key is down and Alt not. */
1706
1707 if( (GetKeyState(VK_CONTROL) & 0x8000) && !(GetKeyState(VK_MENU) & 0x8000))
1708 {
1709 switch( msg->wParam )
1710 {
1711 case VK_F6:
1712 case VK_TAB:
1713 wParam = ( GetKeyState(VK_SHIFT) & 0x8000 ) ? SC_NEXTWINDOW : SC_PREVWINDOW;
1714 break;
1715 case VK_F4:
1716 case VK_RBUTTON:
1717 if (is_close_enabled(ci->hwndActiveChild, 0))
1718 {
1719 wParam = SC_CLOSE;
1720 break;
1721 }
1722 /* fall through */
1723 default:
1724 return 0;
1725 }
1726 TRACE("wParam = %04lx\n", wParam);
1727 SendMessageW(ci->hwndActiveChild, WM_SYSCOMMAND, wParam, (LPARAM)msg->wParam);
1728 return 1;
1729 }
1730 }
1731 return 0; /* failure */
1732 }
1733
1734 /***********************************************************************
1735 * CalcChildScroll (USER32.@)
1736 */
1737 void WINAPI CalcChildScroll( HWND hwnd, INT scroll )
1738 {
1739 SCROLLINFO info;
1740 RECT childRect, clientRect;
1741 HWND *list;
1742
1743 GetClientRect( hwnd, &clientRect );
1744 SetRectEmpty( &childRect );
1745
1746 if ((list = WIN_ListChildren( hwnd )))
1747 {
1748 int i;
1749 for (i = 0; list[i]; i++)
1750 {
1751 DWORD style = GetWindowLongW( list[i], GWL_STYLE );
1752 if (style & WS_MAXIMIZE)
1753 {
1754 HeapFree( GetProcessHeap(), 0, list );
1755 ShowScrollBar( hwnd, SB_BOTH, FALSE );
1756 return;
1757 }
1758 if (style & WS_VISIBLE)
1759 {
1760 RECT rect;
1761 GetWindowRect( list[i], &rect );
1762 UnionRect( &childRect, &rect, &childRect );
1763 }
1764 }
1765 HeapFree( GetProcessHeap(), 0, list );
1766 }
1767 MapWindowPoints( 0, hwnd, (POINT *)&childRect, 2 );
1768 UnionRect( &childRect, &clientRect, &childRect );
1769
1770 /* set common info values */
1771 info.cbSize = sizeof(info);
1772 info.fMask = SIF_POS | SIF_RANGE;
1773
1774 /* set the specific */
1775 switch( scroll )
1776 {
1777 case SB_BOTH:
1778 case SB_HORZ:
1779 info.nMin = childRect.left;
1780 info.nMax = childRect.right - clientRect.right;
1781 info.nPos = clientRect.left - childRect.left;
1782 SetScrollInfo(hwnd, SB_HORZ, &info, TRUE);
1783 if (scroll == SB_HORZ) break;
1784 /* fall through */
1785 case SB_VERT:
1786 info.nMin = childRect.top;
1787 info.nMax = childRect.bottom - clientRect.bottom;
1788 info.nPos = clientRect.top - childRect.top;
1789 SetScrollInfo(hwnd, SB_VERT, &info, TRUE);
1790 break;
1791 }
1792 }
1793
1794
1795 /***********************************************************************
1796 * ScrollChildren (USER32.@)
1797 */
1798 void WINAPI ScrollChildren(HWND hWnd, UINT uMsg, WPARAM wParam,
1799 LPARAM lParam)
1800 {
1801 INT newPos = -1;
1802 INT curPos, length, minPos, maxPos, shift;
1803 RECT rect;
1804
1805 GetClientRect( hWnd, &rect );
1806
1807 switch(uMsg)
1808 {
1809 case WM_HSCROLL:
1810 GetScrollRange(hWnd,SB_HORZ,&minPos,&maxPos);
1811 curPos = GetScrollPos(hWnd,SB_HORZ);
1812 length = (rect.right - rect.left) / 2;
1813 shift = GetSystemMetrics(SM_CYHSCROLL);
1814 break;
1815 case WM_VSCROLL:
1816 GetScrollRange(hWnd,SB_VERT,&minPos,&maxPos);
1817 curPos = GetScrollPos(hWnd,SB_VERT);
1818 length = (rect.bottom - rect.top) / 2;
1819 shift = GetSystemMetrics(SM_CXVSCROLL);
1820 break;
1821 default:
1822 return;
1823 }
1824
1825 switch( wParam )
1826 {
1827 case SB_LINEUP:
1828 newPos = curPos - shift;
1829 break;
1830 case SB_LINEDOWN:
1831 newPos = curPos + shift;
1832 break;
1833 case SB_PAGEUP:
1834 newPos = curPos - length;
1835 break;
1836 case SB_PAGEDOWN:
1837 newPos = curPos + length;
1838 break;
1839
1840 case SB_THUMBPOSITION:
1841 newPos = LOWORD(lParam);
1842 break;
1843
1844 case SB_THUMBTRACK:
1845 return;
1846
1847 case SB_TOP:
1848 newPos = minPos;
1849 break;
1850 case SB_BOTTOM:
1851 newPos = maxPos;
1852 break;
1853 case SB_ENDSCROLL:
1854 CalcChildScroll(hWnd,(uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ);
1855 return;
1856 }
1857
1858 if( newPos > maxPos )
1859 newPos = maxPos;
1860 else
1861 if( newPos < minPos )
1862 newPos = minPos;
1863
1864 SetScrollPos(hWnd, (uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ , newPos, TRUE);
1865
1866 if( uMsg == WM_VSCROLL )
1867 ScrollWindowEx(hWnd ,0 ,curPos - newPos, NULL, NULL, 0, NULL,
1868 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
1869 else
1870 ScrollWindowEx(hWnd ,curPos - newPos, 0, NULL, NULL, 0, NULL,
1871 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
1872 }
1873
1874
1875 /******************************************************************************
1876 * CascadeWindows (USER32.@) Cascades MDI child windows
1877 *
1878 * RETURNS
1879 * Success: Number of cascaded windows.
1880 * Failure: 0
1881 */
1882 WORD WINAPI
1883 CascadeWindows (HWND hwndParent, UINT wFlags, const RECT *lpRect,
1884 UINT cKids, const HWND *lpKids)
1885 {
1886 FIXME("(%p,0x%08x,...,%u,...): stub\n", hwndParent, wFlags, cKids);
1887 return 0;
1888 }
1889
1890
1891 /***********************************************************************
1892 * CascadeChildWindows (USER32.@)
1893 */
1894 WORD WINAPI CascadeChildWindows( HWND parent, UINT flags )
1895 {
1896 return CascadeWindows( parent, flags, NULL, 0, NULL );
1897 }
1898
1899
1900 /******************************************************************************
1901 * TileWindows (USER32.@) Tiles MDI child windows
1902 *
1903 * RETURNS
1904 * Success: Number of tiled windows.
1905 * Failure: 0
1906 */
1907 WORD WINAPI
1908 TileWindows (HWND hwndParent, UINT wFlags, const RECT *lpRect,
1909 UINT cKids, const HWND *lpKids)
1910 {
1911 FIXME("(%p,0x%08x,...,%u,...): stub\n", hwndParent, wFlags, cKids);
1912 return 0;
1913 }
1914
1915
1916 /***********************************************************************
1917 * TileChildWindows (USER32.@)
1918 */
1919 WORD WINAPI TileChildWindows( HWND parent, UINT flags )
1920 {
1921 return TileWindows( parent, flags, NULL, 0, NULL );
1922 }
1923
1924
1925 /************************************************************************
1926 * "More Windows..." functionality
1927 */
1928
1929 /* MDI_MoreWindowsDlgProc
1930 *
1931 * This function will process the messages sent to the "More Windows..."
1932 * dialog.
1933 * Return values: 0 = cancel pressed
1934 * HWND = ok pressed or double-click in the list...
1935 *
1936 */
1937
1938 static INT_PTR WINAPI MDI_MoreWindowsDlgProc (HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
1939 {
1940 switch (iMsg)
1941 {
1942 case WM_INITDIALOG:
1943 {
1944 UINT widest = 0;
1945 UINT length;
1946 UINT i;
1947 MDICLIENTINFO *ci = get_client_info( (HWND)lParam );
1948 HWND hListBox = GetDlgItem(hDlg, MDI_IDC_LISTBOX);
1949
1950 for (i = 0; i < ci->nActiveChildren; i++)
1951 {
1952 WCHAR buffer[MDI_MAXTITLELENGTH];
1953
1954 if (!InternalGetWindowText( ci->child[i], buffer, sizeof(buffer)/sizeof(WCHAR) ))
1955 continue;
1956 SendMessageW(hListBox, LB_ADDSTRING, 0, (LPARAM)buffer );
1957 SendMessageW(hListBox, LB_SETITEMDATA, i, (LPARAM)ci->child[i] );
1958 length = strlenW(buffer); /* FIXME: should use GetTextExtentPoint */
1959 if (length > widest)
1960 widest = length;
1961 }
1962 /* Make sure the horizontal scrollbar scrolls ok */
1963 SendMessageW(hListBox, LB_SETHORIZONTALEXTENT, widest * 6, 0);
1964
1965 /* Set the current selection */
1966 SendMessageW(hListBox, LB_SETCURSEL, MDI_MOREWINDOWSLIMIT, 0);
1967 return TRUE;
1968 }
1969
1970 case WM_COMMAND:
1971 switch (LOWORD(wParam))
1972 {
1973 default:
1974 if (HIWORD(wParam) != LBN_DBLCLK) break;
1975 /* fall through */
1976 case IDOK:
1977 {
1978 /* windows are sorted by menu ID, so we must return the
1979 * window associated to the given id
1980 */
1981 HWND hListBox = GetDlgItem(hDlg, MDI_IDC_LISTBOX);
1982 UINT index = SendMessageW(hListBox, LB_GETCURSEL, 0, 0);
1983 LRESULT res = SendMessageW(hListBox, LB_GETITEMDATA, index, 0);
1984 EndDialog(hDlg, res);
1985 return TRUE;
1986 }
1987 case IDCANCEL:
1988 EndDialog(hDlg, 0);
1989 return TRUE;
1990 }
1991 break;
1992 }
1993 return FALSE;
1994 }
1995
1996 /*
1997 *
1998 * MDI_MoreWindowsDialog
1999 *
2000 * Prompts the user with a listbox containing the opened
2001 * documents. The user can then choose a windows and click
2002 * on OK to set the current window to the one selected, or
2003 * CANCEL to cancel. The function returns a handle to the
2004 * selected window.
2005 */
2006
2007 static HWND MDI_MoreWindowsDialog(HWND hwnd)
2008 {
2009 LPCVOID template;
2010 HRSRC hRes;
2011 HANDLE hDlgTmpl;
2012
2013 hRes = FindResourceA(user32_module, "MDI_MOREWINDOWS", (LPSTR)RT_DIALOG);
2014
2015 if (hRes == 0)
2016 return 0;
2017
2018 hDlgTmpl = LoadResource(user32_module, hRes );
2019
2020 if (hDlgTmpl == 0)
2021 return 0;
2022
2023 template = LockResource( hDlgTmpl );
2024
2025 if (template == 0)
2026 return 0;
2027
2028 return (HWND) DialogBoxIndirectParamA(user32_module, template, hwnd,
2029 MDI_MoreWindowsDlgProc, (LPARAM) hwnd);
2030 }
2031
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.