3 * Copyright 1994, Bob Amstadt
4 * 1995,1996 Alex Korobka
6 * This file contains routines to support MDI (Multiple Document
7 * Interface) features .
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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.
27 * Notes on how the "More Windows..." is implemented:
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, accesible 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:
38 * Name of the child window pWndChild->wIDmenu
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:
54 * Name of the child window pWndChild->wIDmenu
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.
94 #include "wine/unicode.h"
96 #include "nonclient.h"
100 #include "struct32.h"
101 #include "wine/debug.h"
104 WINE_DEFAULT_DEBUG_CHANNEL(mdi);
106 #define MDI_MAXTITLELENGTH 0xa1
108 #define WM_MDICALCCHILDSCROLL 0x10ac /* this is exactly what Windows uses */
110 /* "More Windows..." definitions */
111 #define MDI_MOREWINDOWSLIMIT 9 /* after this number of windows, a "More Windows..."
112 option will appear under the Windows menu */
113 #define MDI_IDC_LISTBOX 100
114 #define IDS_MDI_MOREWINDOWS 13
116 #define MDIF_NEEDUPDATE 0x0001
120 UINT nActiveChildren;
121 HWND hwndActiveChild;
122 HWND *child; /* array of tracked children */
129 UINT sbRecalc; /* SB_xxx flags for scrollbar fixup */
132 static HBITMAP hBmpClose = 0;
134 /* ----------------- declarations ----------------- */
135 static void MDI_UpdateFrameText( HWND, HWND, LPCWSTR);
136 static BOOL MDI_AugmentFrameMenu( HWND, HWND );
137 static BOOL MDI_RestoreFrameMenu( HWND, HWND );
138 static LONG MDI_ChildActivate( HWND, HWND );
139 static LRESULT MDI_RefreshMenu(MDICLIENTINFO *);
141 static HWND MDI_MoreWindowsDialog(HWND);
142 static LRESULT WINAPI MDIClientWndProcA( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );
143 static LRESULT WINAPI MDIClientWndProcW( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );
145 /* -------- Miscellaneous service functions ----------
149 static HWND MDI_GetChildByID(HWND hwnd, UINT id, MDICLIENTINFO *ci)
153 for (i = 0; ci->nActiveChildren; i++)
155 if (GetWindowLongW( ci->child[i], GWL_ID ) == id)
161 static void MDI_PostUpdate(HWND hwnd, MDICLIENTINFO* ci, WORD recalc)
163 if( !(ci->mdiFlags & MDIF_NEEDUPDATE) )
165 ci->mdiFlags |= MDIF_NEEDUPDATE;
166 PostMessageA( hwnd, WM_MDICALCCHILDSCROLL, 0, 0);
168 ci->sbRecalc = recalc;
172 /*********************************************************************
173 * MDIClient class descriptor
175 const struct builtin_class_descr MDICLIENT_builtin_class =
177 "MDIClient", /* name */
179 MDIClientWndProcA, /* procA */
180 MDIClientWndProcW, /* procW */
181 sizeof(MDICLIENTINFO), /* extra */
182 IDC_ARROW, /* cursor */
183 (HBRUSH)(COLOR_APPWORKSPACE+1) /* brush */
187 static MDICLIENTINFO *get_client_info( HWND client )
189 MDICLIENTINFO *ret = NULL;
190 WND *win = WIN_GetPtr( client );
193 if (win == WND_OTHER_PROCESS)
195 ERR( "client %p belongs to other process\n", client );
198 if (win->cbWndExtra < sizeof(MDICLIENTINFO)) WARN( "%p is not an MDI client\n", client );
199 else ret = (MDICLIENTINFO *)win->wExtra;
200 WIN_ReleasePtr( win );
205 /**********************************************************************
208 * returns "activateable" child different from the current or zero
210 static HWND MDI_GetWindow(MDICLIENTINFO *clientInfo, HWND hWnd, BOOL bNext,
217 dwStyleMask |= WS_DISABLED | WS_VISIBLE;
218 if( !hWnd ) hWnd = clientInfo->hwndActiveChild;
220 if (!(list = WIN_ListChildren( GetParent(hWnd) ))) return 0;
222 /* start from next after hWnd */
223 while (list[i] && list[i] != hWnd) i++;
226 for ( ; list[i]; i++)
228 if (GetWindow( list[i], GW_OWNER )) continue;
229 if ((GetWindowLongW( list[i], GWL_STYLE ) & dwStyleMask) != WS_VISIBLE) continue;
231 if (bNext) goto found;
233 /* now restart from the beginning */
234 for (i = 0; list[i] && list[i] != hWnd; i++)
236 if (GetWindow( list[i], GW_OWNER )) continue;
237 if ((GetWindowLongW( list[i], GWL_STYLE ) & dwStyleMask) != WS_VISIBLE) continue;
239 if (bNext) goto found;
242 HeapFree( GetProcessHeap(), 0, list );
246 /**********************************************************************
247 * MDI_CalcDefaultChildPos
249 * It seems that the default height is about 2/3 of the client rect
251 void MDI_CalcDefaultChildPos( HWND hwndClient, INT total, LPPOINT lpPos, INT delta )
255 INT spacing = GetSystemMetrics(SM_CYCAPTION) +
256 GetSystemMetrics(SM_CYFRAME) - 1;
260 MDICLIENTINFO *ci = get_client_info(hwndClient);
261 total = ci ? ci->nTotalCreated : 0;
264 GetClientRect( hwndClient, &rect );
265 if( rect.bottom - rect.top - delta >= spacing )
266 rect.bottom -= delta;
268 nstagger = (rect.bottom - rect.top)/(3 * spacing);
269 lpPos[1].x = (rect.right - rect.left - nstagger * spacing);
270 lpPos[1].y = (rect.bottom - rect.top - nstagger * spacing);
271 lpPos[0].x = lpPos[0].y = spacing * (total%(nstagger+1));
274 /**********************************************************************
277 static LRESULT MDISetMenu( HWND hwnd, HMENU hmenuFrame,
281 HWND hwndFrame = GetParent(hwnd);
283 TRACE("%p %p %p\n", hwnd, hmenuFrame, hmenuWindow);
285 if (hmenuFrame && !IsMenu(hmenuFrame))
287 WARN("hmenuFrame is not a menu handle\n");
291 if (hmenuWindow && !IsMenu(hmenuWindow))
293 WARN("hmenuWindow is not a menu handle\n");
297 if (!(ci = get_client_info( hwnd ))) return 0;
299 if (hmenuFrame == ci->hFrameMenu) return (LRESULT)hmenuFrame;
301 if( IsZoomed(ci->hwndActiveChild) && hmenuFrame && hmenuFrame!= ci->hFrameMenu )
302 MDI_RestoreFrameMenu( hwndFrame, ci->hwndActiveChild );
304 if( hmenuWindow && hmenuWindow != ci->hWindowMenu )
306 /* delete menu items from ci->hWindowMenu
307 * and add them to hmenuWindow */
308 /* Agent newsreader calls this function with ci->hWindowMenu == NULL */
309 if( ci->hWindowMenu && ci->nActiveChildren )
311 UINT nActiveChildren_old = ci->nActiveChildren;
313 /* Remove all items from old Window menu */
314 ci->nActiveChildren = 0;
317 ci->hWindowMenu = hmenuWindow;
319 /* Add items to the new Window menu */
320 ci->nActiveChildren = nActiveChildren_old;
324 ci->hWindowMenu = hmenuWindow;
329 SetMenu(hwndFrame, hmenuFrame);
330 if( hmenuFrame != ci->hFrameMenu )
332 HMENU oldFrameMenu = ci->hFrameMenu;
334 ci->hFrameMenu = hmenuFrame;
335 if( IsZoomed(ci->hwndActiveChild) )
336 MDI_AugmentFrameMenu( hwndFrame, ci->hwndActiveChild );
338 return (LRESULT)oldFrameMenu;
343 /* SetMenu() may already have been called, meaning that this window
344 * already has its menu. But they may have done a SetMenu() on
345 * an MDI window, and called MDISetMenu() after the fact, meaning
346 * that the "if" to this "else" wouldn't catch the need to
347 * augment the frame menu.
349 if( IsZoomed(ci->hwndActiveChild) )
350 MDI_AugmentFrameMenu( hwndFrame, ci->hwndActiveChild );
356 /**********************************************************************
359 static LRESULT MDI_RefreshMenu(MDICLIENTINFO *ci)
361 UINT i, count, visible, separator_pos, id;
362 WCHAR buf[MDI_MAXTITLELENGTH];
364 TRACE("children %u, window menu %p\n", ci->nActiveChildren, ci->hWindowMenu);
366 if (!ci->hWindowMenu)
369 if (!IsMenu(ci->hWindowMenu))
371 WARN("Window menu handle %p is no more valid\n", ci->hWindowMenu);
375 /* Windows finds the last separator in the menu, and if after it
376 * there is a menu item with MDI magic ID removes all existing
377 * menu items after it, and then adds visible MDI children.
381 count = GetMenuItemCount(ci->hWindowMenu);
382 for (i = 0; i < count; i++)
386 memset(&mii, 0, sizeof(mii));
387 mii.cbSize = sizeof(mii);
388 mii.fMask = MIIM_TYPE;
389 if (GetMenuItemInfoW(ci->hWindowMenu, i, TRUE, &mii))
391 if (mii.fType & MF_SEPARATOR)
395 /* Windows checks only ID of the menu item */
396 memset(&mii, 0, sizeof(mii));
397 mii.cbSize = sizeof(mii);
399 if (GetMenuItemInfoW(ci->hWindowMenu, i + 1, TRUE, &mii))
405 if (separator_pos && id == ci->idFirstChild)
407 for (i = separator_pos; i < count; i++)
408 RemoveMenu(ci->hWindowMenu, separator_pos, MF_BYPOSITION);
412 for (i = 0; i < ci->nActiveChildren; i++)
414 if (GetWindowLongW(ci->child[i], GWL_STYLE) & WS_VISIBLE)
416 id = ci->idFirstChild + visible;
418 if (visible == MDI_MOREWINDOWSLIMIT)
420 LoadStringW(user32_module, IDS_MDI_MOREWINDOWS, buf, sizeof(buf)/sizeof(WCHAR));
421 AppendMenuW(ci->hWindowMenu, MF_STRING, id, buf);
426 /* Visio expects that separator has id 0 */
427 AppendMenuW(ci->hWindowMenu, MF_SEPARATOR, 0, NULL);
431 SetWindowLongW(ci->child[i], GWL_ID, id);
434 buf[1] = '0' + visible;
436 InternalGetWindowText(ci->child[i], buf + 3, sizeof(buf)/sizeof(WCHAR) - 3);
437 TRACE("Adding %p, id %u %s\n", ci->child[i], id, debugstr_w(buf));
438 AppendMenuW(ci->hWindowMenu, MF_STRING, id, buf);
440 if (ci->child[i] == ci->hwndActiveChild)
441 CheckMenuItem(ci->hWindowMenu, id, MF_CHECKED);
444 TRACE("MDI child %p is not visible, skipping\n", ci->child[i]);
447 return (LRESULT)ci->hFrameMenu;
451 /* ------------------ MDI child window functions ---------------------- */
453 /**********************************************************************
454 * MDI_ChildGetMinMaxInfo
456 * Note: The rule here is that client rect of the maximized MDI child
457 * is equal to the client rect of the MDI client window.
459 static void MDI_ChildGetMinMaxInfo( HWND client, HWND hwnd, MINMAXINFO* lpMinMax )
463 GetClientRect( client, &rect );
464 AdjustWindowRectEx( &rect, GetWindowLongW( hwnd, GWL_STYLE ),
465 0, GetWindowLongW( hwnd, GWL_EXSTYLE ));
467 lpMinMax->ptMaxSize.x = rect.right -= rect.left;
468 lpMinMax->ptMaxSize.y = rect.bottom -= rect.top;
470 lpMinMax->ptMaxPosition.x = rect.left;
471 lpMinMax->ptMaxPosition.y = rect.top;
473 TRACE("max rect (%ld,%ld - %ld, %ld)\n",
474 rect.left,rect.top,rect.right,rect.bottom);
477 /**********************************************************************
478 * MDI_SwitchActiveChild
480 * Note: SetWindowPos sends WM_CHILDACTIVATE to the child window that is
483 static void MDI_SwitchActiveChild( HWND clientHwnd, HWND childHwnd,
488 MDICLIENTINFO *ci = get_client_info( clientHwnd );
490 hwndTo = MDI_GetWindow(ci, childHwnd, bNextWindow, 0);
491 hwndPrev = ci->hwndActiveChild;
493 TRACE("from %p, to %p\n",childHwnd,hwndTo);
496 MDI_ChildActivate( clientHwnd, 0 );
497 else if ( hwndTo != hwndPrev )
498 SetWindowPos( hwndTo, HWND_TOP, 0, 0, 0, 0,
499 SWP_NOMOVE | SWP_NOSIZE );
503 /**********************************************************************
506 static LRESULT MDIDestroyChild( HWND parent, MDICLIENTINFO *ci,
507 HWND child, BOOL flagDestroy )
511 TRACE("# of managed children %u\n", ci->nActiveChildren);
513 if( child == ci->hwndActiveChild )
515 MDI_SwitchActiveChild(parent, child, TRUE);
516 ShowWindow(child, SW_HIDE);
519 for (i = 0; i < ci->nActiveChildren; i++)
521 if (ci->child[i] == child)
523 HWND *new_child = HeapAlloc(GetProcessHeap(), 0, (ci->nActiveChildren - 1) * sizeof(HWND));
524 memcpy(new_child, ci->child, i * sizeof(HWND));
525 if (i + 1 < ci->nActiveChildren)
526 memcpy(new_child + i, ci->child + i + 1, (ci->nActiveChildren - i - 1) * sizeof(HWND));
527 HeapFree(GetProcessHeap(), 0, ci->child);
528 ci->child = new_child;
530 ci->nActiveChildren--;
537 MDI_PostUpdate(GetParent(child), ci, SB_BOTH+1);
538 DestroyWindow(child);
541 TRACE("child destroyed - %p\n", child);
546 /**********************************************************************
549 * Note: hWndChild is NULL when last child is being destroyed
551 static LONG MDI_ChildActivate( HWND client, HWND child )
553 MDICLIENTINFO *clientInfo;
554 HWND prevActiveWnd, frame;
555 BOOL isActiveFrameWnd;
557 if (child && (!IsWindowEnabled( child ))) return 0;
559 clientInfo = get_client_info( client );
561 TRACE("%p\n", child);
563 frame = GetParent(client);
564 isActiveFrameWnd = (GetActiveWindow() == frame);
565 prevActiveWnd = clientInfo->hwndActiveChild;
567 if (prevActiveWnd == child) return 0;
569 /* deactivate prev. active child */
572 SendMessageW( prevActiveWnd, WM_NCACTIVATE, FALSE, 0L );
573 SendMessageW( prevActiveWnd, WM_MDIACTIVATE, (WPARAM)prevActiveWnd, (LPARAM)child);
576 clientInfo->hwndActiveChild = child;
579 if (IsZoomed(prevActiveWnd) && prevActiveWnd != child)
583 INT cmd = SW_SHOWNORMAL;
584 HMENU hSysMenu = GetSystemMenu(child, FALSE);
587 state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
588 if (state != 0xFFFFFFFF && !(state & (MF_DISABLED | MF_GRAYED)))
589 cmd = SW_SHOWMAXIMIZED;
591 ShowWindow( child, cmd );
594 MDI_RestoreFrameMenu(frame, child);
597 MDI_UpdateFrameText(frame, client, NULL);
599 /* check if we have any children left */
602 if( isActiveFrameWnd )
607 MDI_RefreshMenu(clientInfo);
609 if( isActiveFrameWnd )
610 SendMessageW( child, WM_NCACTIVATE, TRUE, 0L);
612 SendMessageW( child, WM_MDIACTIVATE, (WPARAM)prevActiveWnd, (LPARAM)child );
616 /* -------------------- MDI client window functions ------------------- */
618 /**********************************************************************
619 * CreateMDIMenuBitmap
621 static HBITMAP CreateMDIMenuBitmap(void)
623 HDC hDCSrc = CreateCompatibleDC(0);
624 HDC hDCDest = CreateCompatibleDC(hDCSrc);
625 HBITMAP hbClose = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_OLD_CLOSE) );
627 HBITMAP hobjSrc, hobjDest;
629 hobjSrc = SelectObject(hDCSrc, hbClose);
630 hbCopy = CreateCompatibleBitmap(hDCSrc,GetSystemMetrics(SM_CXSIZE),GetSystemMetrics(SM_CYSIZE));
631 hobjDest = SelectObject(hDCDest, hbCopy);
633 BitBlt(hDCDest, 0, 0, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
634 hDCSrc, GetSystemMetrics(SM_CXSIZE), 0, SRCCOPY);
636 SelectObject(hDCSrc, hobjSrc);
637 DeleteObject(hbClose);
640 hobjSrc = SelectObject( hDCDest, GetStockObject(BLACK_PEN) );
642 MoveToEx( hDCDest, GetSystemMetrics(SM_CXSIZE) - 1, 0, NULL );
643 LineTo( hDCDest, GetSystemMetrics(SM_CXSIZE) - 1, GetSystemMetrics(SM_CYSIZE) - 1);
645 SelectObject(hDCDest, hobjSrc );
646 SelectObject(hDCDest, hobjDest);
652 /**********************************************************************
655 static LONG MDICascade( HWND client, MDICLIENTINFO *ci )
658 BOOL has_icons = FALSE;
661 if (IsZoomed(ci->hwndActiveChild))
662 SendMessageA(client, WM_MDIRESTORE, (WPARAM)ci->hwndActiveChild, 0);
664 if (ci->nActiveChildren == 0) return 0;
666 if (!(win_array = WIN_ListChildren( client ))) return 0;
668 /* remove all the windows we don't want */
669 for (i = total = 0; win_array[i]; i++)
671 if (!IsWindowVisible( win_array[i] )) continue;
672 if (GetWindow( win_array[i], GW_OWNER )) continue; /* skip owned windows */
673 if (IsIconic( win_array[i] ))
678 win_array[total++] = win_array[i];
680 win_array[total] = 0;
684 INT delta = 0, n = 0, i;
686 if (has_icons) delta = GetSystemMetrics(SM_CYICONSPACING) + GetSystemMetrics(SM_CYICON);
688 /* walk the list (backwards) and move windows */
689 for (i = total - 1; i >= 0; i--)
691 TRACE("move %p to (%ld,%ld) size [%ld,%ld]\n",
692 win_array[i], pos[0].x, pos[0].y, pos[1].x, pos[1].y);
694 MDI_CalcDefaultChildPos(client, n++, pos, delta);
695 SetWindowPos( win_array[i], 0, pos[0].x, pos[0].y, pos[1].x, pos[1].y,
696 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
699 HeapFree( GetProcessHeap(), 0, win_array );
701 if (has_icons) ArrangeIconicWindows( client );
705 /**********************************************************************
708 static void MDITile( HWND client, MDICLIENTINFO *ci, WPARAM wParam )
712 BOOL has_icons = FALSE;
714 if (IsZoomed(ci->hwndActiveChild))
715 SendMessageA(client, WM_MDIRESTORE, (WPARAM)ci->hwndActiveChild, 0);
717 if (ci->nActiveChildren == 0) return;
719 if (!(win_array = WIN_ListChildren( client ))) return;
721 /* remove all the windows we don't want */
722 for (i = total = 0; win_array[i]; i++)
724 if (!IsWindowVisible( win_array[i] )) continue;
725 if (GetWindow( win_array[i], GW_OWNER )) continue; /* skip owned windows (icon titles) */
726 if (IsIconic( win_array[i] ))
731 if ((wParam & MDITILE_SKIPDISABLED) && !IsWindowEnabled( win_array[i] )) continue;
732 win_array[total++] = win_array[i];
734 win_array[total] = 0;
736 TRACE("%u windows to tile\n", total);
740 HWND *pWnd = win_array;
742 int x, y, xsize, ysize;
743 int rows, columns, r, c, i;
745 GetClientRect(client,&rect);
746 rows = (int) sqrt((double)total);
747 columns = total / rows;
749 if( wParam & MDITILE_HORIZONTAL ) /* version >= 3.1 */
752 rows = columns; /* exchange r and c */
758 y = rect.bottom - 2 * GetSystemMetrics(SM_CYICONSPACING) - GetSystemMetrics(SM_CYICON);
759 rect.bottom = ( y - GetSystemMetrics(SM_CYICON) < rect.top )? rect.bottom: y;
762 ysize = rect.bottom / rows;
763 xsize = rect.right / columns;
765 for (x = i = 0, c = 1; c <= columns && *pWnd; c++)
770 ysize = rect.bottom / rows;
774 for (r = 1; r <= rows && *pWnd; r++, i++)
776 SetWindowPos(*pWnd, 0, x, y, xsize, ysize,
777 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
784 HeapFree( GetProcessHeap(), 0, win_array );
785 if (has_icons) ArrangeIconicWindows( client );
788 /* ----------------------- Frame window ---------------------------- */
791 /**********************************************************************
792 * MDI_AugmentFrameMenu
794 static BOOL MDI_AugmentFrameMenu( HWND frame, HWND hChild )
796 HMENU menu = GetMenu( frame );
798 HBITMAP hSysMenuBitmap = 0;
803 TRACE("frame %p,child %p\n",frame,hChild);
805 if( !menu ) return 0;
807 /* if the system buttons already exist do not add them again */
808 nItems = GetMenuItemCount(menu) - 1;
809 iId = GetMenuItemID(menu,nItems) ;
810 if (iId == SC_RESTORE || iId == SC_CLOSE)
813 /* create a copy of sysmenu popup and insert it into frame menu bar */
814 if (!(hSysPopup = GetSystemMenu(hChild, FALSE)))
817 AppendMenuA(menu,MF_HELP | MF_BITMAP,
818 SC_MINIMIZE, (LPSTR)(DWORD)HBMMENU_MBAR_MINIMIZE ) ;
819 AppendMenuA(menu,MF_HELP | MF_BITMAP,
820 SC_RESTORE, (LPSTR)(DWORD)HBMMENU_MBAR_RESTORE );
822 AppendMenuA(menu,MF_HELP | MF_BITMAP,
823 SC_CLOSE, (LPSTR)(DWORD)HBMMENU_MBAR_CLOSE );
825 /* The system menu is replaced by the child icon */
826 hIcon = (HICON)GetClassLongW(hChild, GCL_HICONSM);
828 hIcon = (HICON)GetClassLongW(hChild, GCL_HICON);
830 hIcon = LoadImageW(0, MAKEINTRESOURCEW(IDI_WINLOGO), IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
834 HBITMAP hBitmap, hOldBitmap;
836 HDC hdc = GetDC(hChild);
841 cx = GetSystemMetrics(SM_CXSMICON);
842 cy = GetSystemMetrics(SM_CYSMICON);
843 hMemDC = CreateCompatibleDC(hdc);
844 hBitmap = CreateCompatibleBitmap(hdc, cx, cy);
845 hOldBitmap = SelectObject(hMemDC, hBitmap);
846 SetMapMode(hMemDC, MM_TEXT);
847 hBrush = CreateSolidBrush(GetSysColor(COLOR_MENU));
848 DrawIconEx(hMemDC, 0, 0, hIcon, cx, cy, 0, hBrush, DI_NORMAL);
849 SelectObject (hMemDC, hOldBitmap);
850 DeleteObject(hBrush);
852 ReleaseDC(hChild, hdc);
853 hSysMenuBitmap = hBitmap;
857 if( !InsertMenuA(menu,0,MF_BYPOSITION | MF_BITMAP | MF_POPUP,
858 (UINT_PTR)hSysPopup, (LPSTR)hSysMenuBitmap))
860 TRACE("not inserted\n");
861 DestroyMenu(hSysPopup);
865 EnableMenuItem(hSysPopup, SC_SIZE, MF_BYCOMMAND | MF_GRAYED);
866 EnableMenuItem(hSysPopup, SC_MOVE, MF_BYCOMMAND | MF_GRAYED);
867 EnableMenuItem(hSysPopup, SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED);
868 SetMenuDefaultItem(hSysPopup, SC_CLOSE, FALSE);
876 /**********************************************************************
877 * MDI_RestoreFrameMenu
879 static BOOL MDI_RestoreFrameMenu( HWND frame, HWND hChild )
881 MENUITEMINFOW menuInfo;
882 HMENU menu = GetMenu( frame );
883 INT nItems = GetMenuItemCount(menu) - 1;
884 UINT iId = GetMenuItemID(menu,nItems) ;
886 TRACE("frame %p,child %p,nIt=%d,iId=%d\n",frame,hChild,nItems,iId);
888 /* if there is no system buttons then nothing to do */
889 if(!(iId == SC_RESTORE || iId == SC_CLOSE) )
893 * Remove the system menu, If that menu is the icon of the window
894 * as it is in win95, we have to delete the bitmap.
896 memset(&menuInfo, 0, sizeof(menuInfo));
897 menuInfo.cbSize = sizeof(menuInfo);
898 menuInfo.fMask = MIIM_DATA | MIIM_TYPE;
900 GetMenuItemInfoW(menu,
905 RemoveMenu(menu,0,MF_BYPOSITION);
907 if ( (menuInfo.fType & MFT_BITMAP) &&
908 (LOWORD(menuInfo.dwTypeData)!=0) &&
909 (LOWORD(menuInfo.dwTypeData)!=HBITMAP_16(hBmpClose)) )
911 DeleteObject(HBITMAP_32(LOWORD(menuInfo.dwTypeData)));
915 DeleteMenu(menu, SC_CLOSE, MF_BYCOMMAND);
917 DeleteMenu(menu, SC_RESTORE, MF_BYCOMMAND);
919 DeleteMenu(menu, SC_MINIMIZE, MF_BYCOMMAND);
927 /**********************************************************************
928 * MDI_UpdateFrameText
930 * used when child window is maximized/restored
932 * Note: lpTitle can be NULL
934 static void MDI_UpdateFrameText( HWND frame, HWND hClient, LPCWSTR lpTitle )
936 WCHAR lpBuffer[MDI_MAXTITLELENGTH+1];
937 MDICLIENTINFO *ci = get_client_info( hClient );
939 TRACE("frameText %s\n", debugstr_w(lpTitle));
943 if (!lpTitle && !ci->frameTitle) /* first time around, get title from the frame window */
945 GetWindowTextW( frame, lpBuffer, sizeof(lpBuffer)/sizeof(WCHAR) );
949 /* store new "default" title if lpTitle is not NULL */
952 if (ci->frameTitle) HeapFree( GetProcessHeap(), 0, ci->frameTitle );
953 if ((ci->frameTitle = HeapAlloc( GetProcessHeap(), 0, (strlenW(lpTitle)+1)*sizeof(WCHAR))))
954 strcpyW( ci->frameTitle, lpTitle );
959 if (IsZoomed(ci->hwndActiveChild) && IsWindowVisible(ci->hwndActiveChild))
961 /* combine frame title and child title if possible */
963 static const WCHAR lpBracket[] = {' ','-',' ','[',0};
964 static const WCHAR lpBracket2[] = {']',0};
965 int i_frame_text_length = strlenW(ci->frameTitle);
967 lstrcpynW( lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH);
969 if( i_frame_text_length + 6 < MDI_MAXTITLELENGTH )
971 strcatW( lpBuffer, lpBracket );
972 if (GetWindowTextW( ci->hwndActiveChild, lpBuffer + i_frame_text_length + 4,
973 MDI_MAXTITLELENGTH - i_frame_text_length - 5 ))
974 strcatW( lpBuffer, lpBracket2 );
976 lpBuffer[i_frame_text_length] = 0; /* remove bracket */
981 lstrcpynW(lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH+1 );
987 DefWindowProcW( frame, WM_SETTEXT, 0, (LPARAM)lpBuffer );
991 /* ----------------------------- Interface ---------------------------- */
994 /**********************************************************************
995 * MDIClientWndProc_common
997 static LRESULT MDIClientWndProc_common( HWND hwnd, UINT message,
998 WPARAM wParam, LPARAM lParam, BOOL unicode )
1002 TRACE("%p %04x (%s) %08x %08lx\n", hwnd, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1004 if (!(ci = get_client_info( hwnd ))) return 0;
1010 /* Since we are using only cs->lpCreateParams, we can safely
1011 * cast to LPCREATESTRUCTA here */
1012 LPCREATESTRUCTA cs = (LPCREATESTRUCTA)lParam;
1013 WND *wndPtr = WIN_GetPtr( hwnd );
1015 wndPtr->flags |= WIN_ISMDICLIENT;
1017 /* Translation layer doesn't know what's in the cs->lpCreateParams
1018 * so we have to keep track of what environment we're in. */
1020 if( wndPtr->flags & WIN_ISWIN32 )
1022 LPCLIENTCREATESTRUCT ccs = cs->lpCreateParams;
1023 ci->hWindowMenu = ccs->hWindowMenu;
1024 ci->idFirstChild = ccs->idFirstChild;
1028 LPCLIENTCREATESTRUCT16 ccs = MapSL((SEGPTR)cs->lpCreateParams);
1029 ci->hWindowMenu = HMENU_32(ccs->hWindowMenu);
1030 ci->idFirstChild = ccs->idFirstChild;
1032 WIN_ReleasePtr( wndPtr );
1035 ci->nActiveChildren = 0;
1036 ci->nTotalCreated = 0;
1037 ci->frameTitle = NULL;
1039 ci->hFrameMenu = GetMenu(cs->hwndParent);
1041 if (!hBmpClose) hBmpClose = CreateMDIMenuBitmap();
1043 TRACE("Client created - hwnd = %p, idFirst = %u\n", hwnd, ci->idFirstChild );
1049 if( IsZoomed(ci->hwndActiveChild) )
1050 MDI_RestoreFrameMenu(GetParent(hwnd), ci->hwndActiveChild);
1052 ci->nActiveChildren = 0;
1053 MDI_RefreshMenu(ci);
1055 if (ci->child) HeapFree( GetProcessHeap(), 0, ci->child );
1056 if (ci->frameTitle) HeapFree( GetProcessHeap(), 0, ci->frameTitle );
1061 case WM_MDIACTIVATE:
1063 if( ci->hwndActiveChild != (HWND)wParam )
1064 SetWindowPos((HWND)wParam, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE);
1069 return MDICascade(hwnd, ci);
1076 MDICREATESTRUCTW *csW = (MDICREATESTRUCTW *)lParam;
1077 return (LRESULT)CreateWindowExW(WS_EX_MDICHILD, csW->szClass,
1078 csW->szTitle, csW->style,
1079 csW->x, csW->y, csW->cx, csW->cy,
1080 hwnd, 0, csW->hOwner,
1081 (LPVOID)csW->lParam);
1085 MDICREATESTRUCTA *csA = (MDICREATESTRUCTA *)lParam;
1086 return (LRESULT)CreateWindowExA(WS_EX_MDICHILD, csA->szClass,
1087 csA->szTitle, csA->style,
1088 csA->x, csA->y, csA->cx, csA->cy,
1089 hwnd, 0, csA->hOwner,
1090 (LPVOID)csA->lParam);
1096 return MDIDestroyChild( hwnd, ci, WIN_GetFullHandle( (HWND)wParam ), TRUE );
1098 case WM_MDIGETACTIVE:
1099 if (lParam) *(BOOL *)lParam = IsZoomed(ci->hwndActiveChild);
1100 return (LRESULT)ci->hwndActiveChild;
1102 case WM_MDIICONARRANGE:
1103 ci->mdiFlags |= MDIF_NEEDUPDATE;
1104 ArrangeIconicWindows( hwnd );
1105 ci->sbRecalc = SB_BOTH+1;
1106 SendMessageW( hwnd, WM_MDICALCCHILDSCROLL, 0, 0 );
1109 case WM_MDIMAXIMIZE:
1110 ShowWindow( (HWND)wParam, SW_MAXIMIZE );
1113 case WM_MDINEXT: /* lParam != 0 means previous window */
1114 MDI_SwitchActiveChild( hwnd, WIN_GetFullHandle( (HWND)wParam ), !lParam );
1118 SendMessageW( (HWND)wParam, WM_SYSCOMMAND, SC_RESTORE, 0);
1122 return MDISetMenu( hwnd, (HMENU)wParam, (HMENU)lParam );
1124 case WM_MDIREFRESHMENU:
1125 return MDI_RefreshMenu( ci );
1128 ci->mdiFlags |= MDIF_NEEDUPDATE;
1129 ShowScrollBar( hwnd, SB_BOTH, FALSE );
1130 MDITile( hwnd, ci, wParam );
1131 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1136 ci->mdiFlags |= MDIF_NEEDUPDATE;
1137 ScrollChildren( hwnd, message, wParam, lParam );
1138 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1142 if (ci->hwndActiveChild && !IsIconic( ci->hwndActiveChild ))
1143 SetFocus( ci->hwndActiveChild );
1147 if( ci->hwndActiveChild )
1148 SendMessageW(ci->hwndActiveChild, message, wParam, lParam);
1151 case WM_PARENTNOTIFY:
1152 switch (LOWORD(wParam))
1155 if (GetWindowLongW((HWND)lParam, GWL_EXSTYLE) & WS_EX_MDICHILD)
1157 ci->nTotalCreated++;
1158 ci->nActiveChildren++;
1161 ci->child = HeapAlloc(GetProcessHeap(), 0, sizeof(HWND));
1163 ci->child = HeapReAlloc(GetProcessHeap(), 0, ci->child, sizeof(HWND) * ci->nActiveChildren);
1165 TRACE("Adding MDI child %p, # of children %d\n",
1166 (HWND)lParam, ci->nActiveChildren);
1168 ci->child[ci->nActiveChildren - 1] = (HWND)lParam;
1172 case WM_LBUTTONDOWN:
1176 pt.x = (short)LOWORD(lParam);
1177 pt.y = (short)HIWORD(lParam);
1178 child = ChildWindowFromPoint(hwnd, pt);
1180 TRACE("notification from %p (%li,%li)\n",child,pt.x,pt.y);
1182 if( child && child != hwnd && child != ci->hwndActiveChild )
1183 SetWindowPos(child, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
1190 if( IsWindow(ci->hwndActiveChild) && IsZoomed(ci->hwndActiveChild) &&
1191 IsWindowVisible(ci->hwndActiveChild) )
1197 rect.right = LOWORD(lParam);
1198 rect.bottom = HIWORD(lParam);
1200 AdjustWindowRectEx(&rect, GetWindowLongA(ci->hwndActiveChild, GWL_STYLE),
1201 0, GetWindowLongA(ci->hwndActiveChild, GWL_EXSTYLE) );
1202 MoveWindow(ci->hwndActiveChild, rect.left, rect.top,
1203 rect.right - rect.left, rect.bottom - rect.top, 1);
1206 MDI_PostUpdate(hwnd, ci, SB_BOTH+1);
1210 case WM_MDICALCCHILDSCROLL:
1211 if( (ci->mdiFlags & MDIF_NEEDUPDATE) && ci->sbRecalc )
1213 CalcChildScroll(hwnd, ci->sbRecalc-1);
1215 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1219 return unicode ? DefWindowProcW( hwnd, message, wParam, lParam ) :
1220 DefWindowProcA( hwnd, message, wParam, lParam );
1223 /***********************************************************************
1226 static LRESULT WINAPI MDIClientWndProcA( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
1228 if (!IsWindow(hwnd)) return 0;
1229 return MDIClientWndProc_common( hwnd, message, wParam, lParam, FALSE );
1232 /***********************************************************************
1235 static LRESULT WINAPI MDIClientWndProcW( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
1237 if (!IsWindow(hwnd)) return 0;
1238 return MDIClientWndProc_common( hwnd, message, wParam, lParam, TRUE );
1241 /***********************************************************************
1242 * DefFrameProcA (USER32.@)
1244 LRESULT WINAPI DefFrameProcA( HWND hwnd, HWND hwndMDIClient,
1245 UINT message, WPARAM wParam, LPARAM lParam)
1253 DWORD len = MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, NULL, 0 );
1254 LPWSTR text = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1255 MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, text, len );
1256 MDI_UpdateFrameText( hwnd, hwndMDIClient, text );
1257 HeapFree( GetProcessHeap(), 0, text );
1259 return 1; /* success. FIXME: check text length */
1266 return DefFrameProcW( hwnd, hwndMDIClient, message, wParam, lParam );
1269 return DefWindowProcA(hwnd, message, wParam, lParam);
1273 /***********************************************************************
1274 * DefFrameProcW (USER32.@)
1276 LRESULT WINAPI DefFrameProcW( HWND hwnd, HWND hwndMDIClient,
1277 UINT message, WPARAM wParam, LPARAM lParam)
1279 MDICLIENTINFO *ci = get_client_info( hwndMDIClient );
1281 TRACE("%p %p %04x (%s) %08x %08lx\n", hwnd, hwndMDIClient, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1289 WORD id = LOWORD(wParam);
1290 /* check for possible syscommands for maximized MDI child */
1291 if (id < ci->idFirstChild || id >= ci->idFirstChild + ci->nActiveChildren)
1293 if( (id - 0xf000) & 0xf00f ) break;
1294 if( !IsZoomed(ci->hwndActiveChild) ) break;
1305 return SendMessageW( ci->hwndActiveChild, WM_SYSCOMMAND,
1312 if (id - ci->idFirstChild == MDI_MOREWINDOWSLIMIT)
1313 /* User chose "More Windows..." */
1314 childHwnd = MDI_MoreWindowsDialog(hwndMDIClient);
1316 /* User chose one of the windows listed in the "Windows" menu */
1317 childHwnd = MDI_GetChildByID(hwndMDIClient, id, ci);
1320 SendMessageW( hwndMDIClient, WM_MDIACTIVATE, (WPARAM)childHwnd, 0 );
1326 SendMessageW(hwndMDIClient, message, wParam, lParam);
1330 MDI_UpdateFrameText( hwnd, hwndMDIClient, (LPWSTR)lParam );
1331 return 1; /* success. FIXME: check text length */
1334 SetFocus(hwndMDIClient);
1338 MoveWindow(hwndMDIClient, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
1343 MDINEXTMENU *next_menu = (MDINEXTMENU *)lParam;
1345 if (!IsIconic(hwnd) && ci->hwndActiveChild && !IsZoomed(ci->hwndActiveChild))
1347 /* control menu is between the frame system menu and
1348 * the first entry of menu bar */
1349 WND *wndPtr = WIN_GetPtr(hwnd);
1351 if( (wParam == VK_LEFT && GetMenu(hwnd) == next_menu->hmenuIn) ||
1352 (wParam == VK_RIGHT && GetSubMenu(wndPtr->hSysMenu, 0) == next_menu->hmenuIn) )
1354 WIN_ReleasePtr(wndPtr);
1355 wndPtr = WIN_GetPtr(ci->hwndActiveChild);
1356 next_menu->hmenuNext = GetSubMenu(wndPtr->hSysMenu, 0);
1357 next_menu->hwndNext = ci->hwndActiveChild;
1359 WIN_ReleasePtr(wndPtr);
1366 return DefWindowProcW( hwnd, message, wParam, lParam );
1369 /***********************************************************************
1370 * DefMDIChildProcA (USER32.@)
1372 LRESULT WINAPI DefMDIChildProcA( HWND hwnd, UINT message,
1373 WPARAM wParam, LPARAM lParam )
1375 HWND client = GetParent(hwnd);
1376 MDICLIENTINFO *ci = get_client_info( client );
1378 TRACE("%p %04x (%s) %08x %08lx\n", hwnd, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1380 hwnd = WIN_GetFullHandle( hwnd );
1381 if (!ci) return DefWindowProcA( hwnd, message, wParam, lParam );
1386 DefWindowProcA(hwnd, message, wParam, lParam);
1387 if( ci->hwndActiveChild == hwnd && IsZoomed(ci->hwndActiveChild) )
1388 MDI_UpdateFrameText( GetParent(client), client, NULL );
1389 return 1; /* success. FIXME: check text length */
1391 case WM_GETMINMAXINFO:
1395 case WM_CHILDACTIVATE:
1402 return DefMDIChildProcW( hwnd, message, wParam, lParam );
1404 return DefWindowProcA(hwnd, message, wParam, lParam);
1408 /***********************************************************************
1409 * DefMDIChildProcW (USER32.@)
1411 LRESULT WINAPI DefMDIChildProcW( HWND hwnd, UINT message,
1412 WPARAM wParam, LPARAM lParam )
1414 HWND client = GetParent(hwnd);
1415 MDICLIENTINFO *ci = get_client_info( client );
1417 TRACE("%p %04x (%s) %08x %08lx\n", hwnd, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1419 hwnd = WIN_GetFullHandle( hwnd );
1420 if (!ci) return DefWindowProcW( hwnd, message, wParam, lParam );
1425 DefWindowProcW(hwnd, message, wParam, lParam);
1426 if( ci->hwndActiveChild == hwnd && IsZoomed(ci->hwndActiveChild) )
1427 MDI_UpdateFrameText( GetParent(client), client, NULL );
1428 return 1; /* success. FIXME: check text length */
1430 case WM_GETMINMAXINFO:
1431 MDI_ChildGetMinMaxInfo( client, hwnd, (MINMAXINFO *)lParam );
1435 return 0x00010000; /* MDI children don't have menu bars */
1438 SendMessageW( client, WM_MDIDESTROY, (WPARAM)hwnd, 0 );
1441 case WM_CHILDACTIVATE:
1442 MDI_ChildActivate( client, hwnd );
1449 if( ci->hwndActiveChild == hwnd && IsZoomed(ci->hwndActiveChild))
1456 if (ci->hwndActiveChild == hwnd && IsZoomed(ci->hwndActiveChild))
1457 return SendMessageW( GetParent(client), message, wParam, lParam);
1460 SendMessageW( client, WM_MDINEXT, 0, 0);
1463 SendMessageW( client, WM_MDINEXT, 0, 1);
1470 if (IsZoomed(ci->hwndActiveChild)) ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1471 else MDI_PostUpdate(client, ci, SB_BOTH+1);
1475 if (wParam == SIZE_MAXIMIZED && !IsWindowVisible(hwnd))
1476 wParam = SIZE_RESTORED;
1478 if( hwnd == ci->hwndActiveChild && wParam != SIZE_MAXIMIZED )
1480 MDI_RestoreFrameMenu( GetParent(client), hwnd );
1481 MDI_UpdateFrameText( GetParent(client), client, NULL );
1484 if( wParam == SIZE_MAXIMIZED )
1486 TRACE("maximizing child %p\n", hwnd );
1488 MDI_AugmentFrameMenu( GetParent(client), hwnd );
1489 MDI_UpdateFrameText( GetParent(client), client, NULL );
1492 if( wParam == SIZE_MINIMIZED )
1494 HWND switchTo = MDI_GetWindow(ci, hwnd, TRUE, WS_MINIMIZE);
1496 if (switchTo) SendMessageW( switchTo, WM_CHILDACTIVATE, 0, 0);
1498 MDI_PostUpdate(client, ci, SB_BOTH+1);
1503 MDINEXTMENU *next_menu = (MDINEXTMENU *)lParam;
1504 HWND parent = GetParent(client);
1506 if( wParam == VK_LEFT ) /* switch to frame system menu */
1508 WND *wndPtr = WIN_GetPtr( parent );
1509 next_menu->hmenuNext = GetSubMenu( wndPtr->hSysMenu, 0 );
1510 WIN_ReleasePtr( wndPtr );
1512 if( wParam == VK_RIGHT ) /* to frame menu bar */
1514 next_menu->hmenuNext = GetMenu(parent);
1516 next_menu->hwndNext = parent;
1523 SendMessageW( hwnd, WM_SYSCOMMAND, (WPARAM)SC_KEYMENU, (DWORD)VK_SPACE);
1528 return DefWindowProcW(hwnd, message, wParam, lParam);
1531 /**********************************************************************
1532 * CreateMDIWindowA (USER32.@) Creates a MDI child
1535 * Success: Handle to created window
1538 HWND WINAPI CreateMDIWindowA(
1539 LPCSTR lpClassName, /* [in] Pointer to registered child class name */
1540 LPCSTR lpWindowName, /* [in] Pointer to window name */
1541 DWORD dwStyle, /* [in] Window style */
1542 INT X, /* [in] Horizontal position of window */
1543 INT Y, /* [in] Vertical position of window */
1544 INT nWidth, /* [in] Width of window */
1545 INT nHeight, /* [in] Height of window */
1546 HWND hWndParent, /* [in] Handle to parent window */
1547 HINSTANCE hInstance, /* [in] Handle to application instance */
1548 LPARAM lParam) /* [in] Application-defined value */
1550 TRACE("(%s,%s,%08lx,%d,%d,%d,%d,%p,%p,%08lx)\n",
1551 debugstr_a(lpClassName),debugstr_a(lpWindowName),dwStyle,X,Y,
1552 nWidth,nHeight,hWndParent,hInstance,lParam);
1554 return CreateWindowExA(WS_EX_MDICHILD, lpClassName, lpWindowName,
1555 dwStyle, X, Y, nWidth, nHeight, hWndParent,
1556 0, hInstance, (LPVOID)lParam);
1559 /***********************************************************************
1560 * CreateMDIWindowW (USER32.@) Creates a MDI child
1563 * Success: Handle to created window
1566 HWND WINAPI CreateMDIWindowW(
1567 LPCWSTR lpClassName, /* [in] Pointer to registered child class name */
1568 LPCWSTR lpWindowName, /* [in] Pointer to window name */
1569 DWORD dwStyle, /* [in] Window style */
1570 INT X, /* [in] Horizontal position of window */
1571 INT Y, /* [in] Vertical position of window */
1572 INT nWidth, /* [in] Width of window */
1573 INT nHeight, /* [in] Height of window */
1574 HWND hWndParent, /* [in] Handle to parent window */
1575 HINSTANCE hInstance, /* [in] Handle to application instance */
1576 LPARAM lParam) /* [in] Application-defined value */
1578 TRACE("(%s,%s,%08lx,%d,%d,%d,%d,%p,%p,%08lx)\n",
1579 debugstr_w(lpClassName), debugstr_w(lpWindowName), dwStyle, X, Y,
1580 nWidth, nHeight, hWndParent, hInstance, lParam);
1582 return CreateWindowExW(WS_EX_MDICHILD, lpClassName, lpWindowName,
1583 dwStyle, X, Y, nWidth, nHeight, hWndParent,
1584 0, hInstance, (LPVOID)lParam);
1587 /**********************************************************************
1588 * TranslateMDISysAccel (USER32.@)
1590 BOOL WINAPI TranslateMDISysAccel( HWND hwndClient, LPMSG msg )
1592 if (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
1594 MDICLIENTINFO *ci = get_client_info( hwndClient );
1597 if (!ci || !IsWindowEnabled(ci->hwndActiveChild)) return 0;
1599 /* translate if the Ctrl key is down and Alt not. */
1601 if( (GetKeyState(VK_CONTROL) & 0x8000) && !(GetKeyState(VK_MENU) & 0x8000))
1603 switch( msg->wParam )
1607 wParam = ( GetKeyState(VK_SHIFT) & 0x8000 ) ? SC_NEXTWINDOW : SC_PREVWINDOW;
1616 TRACE("wParam = %04x\n", wParam);
1617 SendMessageW(ci->hwndActiveChild, WM_SYSCOMMAND, wParam, (LPARAM)msg->wParam);
1621 return 0; /* failure */
1624 /***********************************************************************
1625 * CalcChildScroll (USER32.@)
1627 void WINAPI CalcChildScroll( HWND hwnd, INT scroll )
1630 RECT childRect, clientRect;
1633 GetClientRect( hwnd, &clientRect );
1634 SetRectEmpty( &childRect );
1636 if ((list = WIN_ListChildren( hwnd )))
1639 for (i = 0; list[i]; i++)
1641 DWORD style = GetWindowLongW( list[i], GWL_STYLE );
1642 if (style & WS_MAXIMIZE)
1644 HeapFree( GetProcessHeap(), 0, list );
1645 ShowScrollBar( hwnd, SB_BOTH, FALSE );
1648 if (style & WS_VISIBLE)
1650 WND *pWnd = WIN_FindWndPtr( list[i] );
1651 UnionRect( &childRect, &pWnd->rectWindow, &childRect );
1652 WIN_ReleaseWndPtr( pWnd );
1655 HeapFree( GetProcessHeap(), 0, list );
1657 UnionRect( &childRect, &clientRect, &childRect );
1659 /* set common info values */
1660 info.cbSize = sizeof(info);
1661 info.fMask = SIF_POS | SIF_RANGE;
1663 /* set the specific */
1668 info.nMin = childRect.left;
1669 info.nMax = childRect.right - clientRect.right;
1670 info.nPos = clientRect.left - childRect.left;
1671 SetScrollInfo(hwnd, scroll, &info, TRUE);
1672 if (scroll == SB_HORZ) break;
1675 info.nMin = childRect.top;
1676 info.nMax = childRect.bottom - clientRect.bottom;
1677 info.nPos = clientRect.top - childRect.top;
1678 SetScrollInfo(hwnd, scroll, &info, TRUE);
1684 /***********************************************************************
1685 * ScrollChildren (USER32.@)
1687 void WINAPI ScrollChildren(HWND hWnd, UINT uMsg, WPARAM wParam,
1691 INT curPos, length, minPos, maxPos, shift;
1694 GetClientRect( hWnd, &rect );
1699 GetScrollRange(hWnd,SB_HORZ,&minPos,&maxPos);
1700 curPos = GetScrollPos(hWnd,SB_HORZ);
1701 length = (rect.right - rect.left) / 2;
1702 shift = GetSystemMetrics(SM_CYHSCROLL);
1705 GetScrollRange(hWnd,SB_VERT,&minPos,&maxPos);
1706 curPos = GetScrollPos(hWnd,SB_VERT);
1707 length = (rect.bottom - rect.top) / 2;
1708 shift = GetSystemMetrics(SM_CXVSCROLL);
1717 newPos = curPos - shift;
1720 newPos = curPos + shift;
1723 newPos = curPos - length;
1726 newPos = curPos + length;
1729 case SB_THUMBPOSITION:
1730 newPos = LOWORD(lParam);
1743 CalcChildScroll(hWnd,(uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ);
1747 if( newPos > maxPos )
1750 if( newPos < minPos )
1753 SetScrollPos(hWnd, (uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ , newPos, TRUE);
1755 if( uMsg == WM_VSCROLL )
1756 ScrollWindowEx(hWnd ,0 ,curPos - newPos, NULL, NULL, 0, NULL,
1757 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
1759 ScrollWindowEx(hWnd ,curPos - newPos, 0, NULL, NULL, 0, NULL,
1760 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
1764 /******************************************************************************
1765 * CascadeWindows (USER32.@) Cascades MDI child windows
1768 * Success: Number of cascaded windows.
1772 CascadeWindows (HWND hwndParent, UINT wFlags, const LPRECT lpRect,
1773 UINT cKids, const HWND *lpKids)
1775 FIXME("(%p,0x%08x,...,%u,...): stub\n", hwndParent, wFlags, cKids);
1780 /******************************************************************************
1781 * TileWindows (USER32.@) Tiles MDI child windows
1784 * Success: Number of tiled windows.
1788 TileWindows (HWND hwndParent, UINT wFlags, const LPRECT lpRect,
1789 UINT cKids, const HWND *lpKids)
1791 FIXME("(%p,0x%08x,...,%u,...): stub\n", hwndParent, wFlags, cKids);
1795 /************************************************************************
1796 * "More Windows..." functionality
1799 /* MDI_MoreWindowsDlgProc
1801 * This function will process the messages sent to the "More Windows..."
1803 * Return values: 0 = cancel pressed
1804 * HWND = ok pressed or double-click in the list...
1808 static INT_PTR WINAPI MDI_MoreWindowsDlgProc (HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
1817 MDICLIENTINFO *ci = get_client_info( (HWND)lParam );
1818 HWND hListBox = GetDlgItem(hDlg, MDI_IDC_LISTBOX);
1820 for (i = 0; i < ci->nActiveChildren; i++)
1822 WCHAR buffer[MDI_MAXTITLELENGTH];
1824 if (!InternalGetWindowText( ci->child[i], buffer, sizeof(buffer)/sizeof(WCHAR) ))
1826 SendMessageW(hListBox, LB_ADDSTRING, 0, (LPARAM)buffer );
1827 SendMessageW(hListBox, LB_SETITEMDATA, i, (LPARAM)ci->child[i] );
1828 length = strlenW(buffer); /* FIXME: should use GetTextExtentPoint */
1829 if (length > widest)
1832 /* Make sure the horizontal scrollbar scrolls ok */
1833 SendMessageW(hListBox, LB_SETHORIZONTALEXTENT, widest * 6, 0);
1835 /* Set the current selection */
1836 SendMessageW(hListBox, LB_SETCURSEL, MDI_MOREWINDOWSLIMIT, 0);
1841 switch (LOWORD(wParam))
1844 if (HIWORD(wParam) != LBN_DBLCLK) break;
1848 /* windows are sorted by menu ID, so we must return the
1849 * window associated to the given id
1851 HWND hListBox = GetDlgItem(hDlg, MDI_IDC_LISTBOX);
1852 UINT index = SendMessageW(hListBox, LB_GETCURSEL, 0, 0);
1853 LRESULT res = SendMessageW(hListBox, LB_GETITEMDATA, index, 0);
1854 EndDialog(hDlg, res);
1868 * MDI_MoreWindowsDialog
1870 * Prompts the user with a listbox containing the opened
1871 * documents. The user can then choose a windows and click
1872 * on OK to set the current window to the one selected, or
1873 * CANCEL to cancel. The function returns a handle to the
1877 static HWND MDI_MoreWindowsDialog(HWND hwnd)
1883 hRes = FindResourceA(user32_module, "MDI_MOREWINDOWS", (LPSTR)RT_DIALOG);
1888 hDlgTmpl = LoadResource(user32_module, hRes );
1893 template = LockResource( hDlgTmpl );
1898 return (HWND) DialogBoxIndirectParamA(user32_module,
1899 (LPDLGTEMPLATEA) template,
1900 hwnd, MDI_MoreWindowsDlgProc, (LPARAM) hwnd);