mdimenu.c File Reference

#include "precomp.h"

Go to the source code of this file.

Functions
PWND	FindPwndChild (PWND pwndMDI, UINT wChildID)
int	MakeMenuItem (LPWSTR lpOut, PWND pwnd)
void	ModifyMenuItem (PWND pwnd)
BOOL	MDIAddSysMenu (HMENU hMenuFrame, HWND hwndChild)
BOOL	MDIRemoveSysMenu (HMENU hMenuFrame, HWND hwndChild)
BOOL FAR PASCAL	AppendToWindowsMenu (PWND pwndMDI, PWND pwndChild)
BOOL	SwitchWindowsMenus (HMENU hmenu, HMENU hOldWindow, HMENU hNewWindow)
void	ShiftMenuIDs (PWND pwnd, PWND pwndVictim)
HMENU	MDISetMenu (PWND pwndMDI, BOOL fRefresh, HMENU hNewSys, HMENU hNewWindow)
void	xxxInitActivateDlg (HWND hwnd, PWND pwndMDI)
VOID	MDIActivateDlgSize (HWND hwnd, int width, int height)
VOID	MDIActivateDlgInit (HWND hwnd, LPARAM lParam)
INT_PTR	MDIActivateDlgProcWorker (HWND hwnd, UINT wMsg, WPARAM wParam, LPARAM lParam)
INT_PTR WINAPI	MDIActivateDlgProcA (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
INT_PTR WINAPI	MDIActivateDlgProcW (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

---

Function Documentation

BOOL FAR PASCAL AppendToWindowsMenu (  PWND  pwndMDI, PWND  pwndChild )

Definition at line 362 of file mdimenu.c. References BOOL, FALSE, FAR, FIRST, hmodUser, InternalInsertMenuItem(), MakeMenuItem(), MAXITEMS, MFMWFP_NOITEM, tagWND::spmenu, STR_MOREWINDOWS, TRUE, UINT, and WINDOW. Referenced by MDISetMenu(). { PMDI pmdi; WCHAR szMenuItem[165]; int item; MENUITEMINFO mii; /* * Get a pointer to the MDI structure */ pmdi = ((PMDIWND)pwndMDI)->pmdi; item = PtrToUlong(pwndChild->spmenu) - FIRST(pmdi); if (WINDOW(pmdi) && (item < MAXITEMS)) { mii.cbSize = sizeof(MENUITEMINFO); if (!item) { /* * Add separator before first item */ mii.fMask = MIIM_FTYPE; mii.fType = MFT_SEPARATOR; if (!InternalInsertMenuItem(WINDOW(pmdi), MFMWFP_NOITEM, TRUE, &mii)) return FALSE; } if (item == (MAXITEMS - 1)) LoadString(hmodUser, STR_MOREWINDOWS, szMenuItem, sizeof(szMenuItem) / sizeof(WCHAR)); else MakeMenuItem(szMenuItem, pwndChild); mii.fMask = MIIM_ID | MIIM_STRING; mii.wID = PtrToUlong(pwndChild->spmenu); mii.dwTypeData = szMenuItem; mii.cch = (UINT)-1; if (!InternalInsertMenuItem(WINDOW(pmdi), MFMWFP_NOITEM, TRUE, &mii)) return FALSE; } return TRUE; }

PWND FindPwndChild (  PWND  pwndMDI, UINT  wChildID )

Definition at line 24 of file mdimenu.c. References REBASEPWND, tagWND::spmenu, and tagWND::spwndOwner. Referenced by DefFrameProcWorker(), MDISetMenu(), xxxInitActivateDlg(), and xxxMDIActivate(). { PWND pwndT; for (pwndT = REBASEPWND(pwndMDI, spwndChild); pwndT && (pwndT->spwndOwner || PtrToUlong(pwndT->spmenu) != wChildID); pwndT = REBASEPWND(pwndT, spwndNext)) ; return pwndT; }

int MakeMenuItem (  LPWSTR  lpOut, PWND  pwnd )

Definition at line 47 of file mdimenu.c. References DWORD, FIRST, L, _LARGE_UNICODE_STRING::Length, PMDI, PMDIWND, REBASEALWAYS, REBASEPWND, tagWND::spmenu, tagWND::strName, and wsprintfW(). Referenced by AppendToWindowsMenu(), and ModifyMenuItem(). { PMDI pmdi; DWORD rgParm; int cch = 0; WCHAR string[160]; LPWSTR lpstr; int i = 0; /* * Get a pointer to the MDI structure */ pmdi = ((PMDIWND)(REBASEPWND(pwnd, spwndParent)))->pmdi; *lpOut = 0; rgParm = PtrToUlong(pwnd->spmenu) - (DWORD)FIRST(pmdi) + 1; if (pwnd->strName.Length) { lpstr = REBASEALWAYS(pwnd, strName.Buffer); /* * Search for an & in the title string and duplicate it so that we don't * get bogus accelerators. */ while (*lpstr && i < ((sizeof(string) / sizeof(WCHAR)) - 1)) { string[i] = *lpstr; i++; if (*lpstr == TEXT('&')) string[i++] = TEXT('&'); lpstr++; } string[i] = 0; cch = wsprintfW(lpOut, L"&%d %ws", rgParm, string); } else { /* * Handle the case of MDI children without any window title text. */ cch = wsprintfW(lpOut, L"&%d ", rgParm); } return cch; }

VOID MDIActivateDlgInit (  HWND  hwnd, LPARAM  lParam )

Definition at line 775 of file mdimenu.c. References atomMDIActivateProp, tagMDIACTIVATEPOS::cx, tagMDIACTIVATEPOS::cxMin, tagMDIACTIVATEPOS::cy, cy, tagMDIACTIVATEPOS::cyMin, GetClientRect(), GetParent(), GetProp(), GetWindowRect(), MAKEINTATOM, MDIACTIVATE_PROP_NAME, MDIActivateDlgSize(), MDIACTIVATEPOS, NtUserSetWindowPos(), NULL, SetProp(), UserLocalAlloc, VOID(), and xxxInitActivateDlg(). Referenced by MDIActivateDlgProcWorker(). { PMDIACTIVATEPOS pPos; HWND hwndParent; RECT rc; xxxInitActivateDlg(hwnd, (PWND)lParam); hwndParent = GetParent(hwnd); /* * Preserve the previous size of the dialog, if any */ if (atomMDIActivateProp == 0) { atomMDIActivateProp = AddAtomW(MDIACTIVATE_PROP_NAME); UserAssert(atomMDIActivateProp); } GetWindowRect(hwnd, &rc); pPos = (PMDIACTIVATEPOS)GetProp(hwndParent, MAKEINTATOM(atomMDIActivateProp)); /* * If the dialog was used before, retrieve it's size */ if (pPos != NULL) { int cxBorder, cyBorder, cx, cy; /* * The stored size and the ones in WM_SIZE are client window coordinates * Need to adjust them for NtUserSetWindowPos and WM_INITDIALOG */ cxBorder = rc.right - rc.left; cyBorder = rc.bottom - rc.top; GetClientRect(hwnd, &rc); cxBorder -= rc.right - rc.left; cyBorder -= rc.bottom - rc.top; NtUserSetWindowPos(hwnd, NULL, 0, 0, pPos->cx + cxBorder, pPos->cy + cyBorder, SWP_NOMOVE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING | SWP_NOREDRAW); cx = pPos->cx; cy = pPos->cy; pPos->cx = pPos->cxMin - cxBorder; pPos->cy = pPos->cyMin - cyBorder; MDIActivateDlgSize(hwnd, cx, cy); } else { /* * */ pPos = UserLocalAlloc(0, sizeof(MDIACTIVATEPOS)); if (pPos == NULL) { return; } pPos->cxMin = rc.right - rc.left; pPos->cyMin = rc.bottom - rc.top; GetClientRect(hwnd, &rc); pPos->cx = rc.right - rc.left; pPos->cy = rc.bottom - rc.top; SetProp(hwndParent, MAKEINTATOM(atomMDIActivateProp), (HANDLE)pPos); } }

INT_PTR WINAPI MDIActivateDlgProcA (  HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam )

Definition at line 917 of file mdimenu.c. References MDIActivateDlgProcWorker(). Referenced by ClientThreadSetup(), and DefFrameProcWorker(). { return MDIActivateDlgProcWorker(hwnd, message, wParam, lParam); }

INT_PTR WINAPI MDIActivateDlgProcW (  HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam )

Definition at line 926 of file mdimenu.c. References MDIActivateDlgProcWorker(). Referenced by ClientThreadSetup(), and DefFrameProcWorker(). { return MDIActivateDlgProcWorker(hwnd, message, wParam, lParam); }

INT_PTR MDIActivateDlgProcWorker (  HWND  hwnd, UINT  wMsg, WPARAM  wParam, LPARAM  lParam )

Definition at line 849 of file mdimenu.c. References atomMDIActivateProp, tagMDIACTIVATEPOS::cxMin, tagMDIACTIVATEPOS::cyMin, EndDialog(), FALSE, GetParent(), GetProp(), L, MAKEINTATOM, MDIActivateDlgInit(), MDIActivateDlgSize(), SendDlgItemMessage(), TRUE, and UINT. Referenced by MDIActivateDlgProcA(), and MDIActivateDlgProcW(). { int i; switch (wMsg) { case WM_INITDIALOG: /* * NOTE: Code above uses DialogBoxParam, passing pwndMDI in the low * word of the parameter... */ MDIActivateDlgInit(hwnd, lParam); return FALSE; case WM_COMMAND: i = -2; switch (LOWORD(wParam)) { /* * Listbox doubleclicks act like OK... */ case 100: if (HIWORD(wParam) != LBN_DBLCLK) break; /* ** FALL THRU ** */ case IDOK: i = (UINT)SendDlgItemMessage(hwnd, 100, LB_GETCURSEL, 0, 0L); /* ** FALL THRU ** */ case IDCANCEL: EndDialog(hwnd, i); break; default: return FALSE; } break; case WM_SIZE: MDIActivateDlgSize(hwnd, LOWORD(lParam), HIWORD(lParam)); return FALSE; case WM_GETMINMAXINFO: { PMDIACTIVATEPOS pPos; if (pPos = (PMDIACTIVATEPOS)GetProp(GetParent(hwnd), MAKEINTATOM(atomMDIActivateProp))) { ((LPMINMAXINFO)lParam)->ptMinTrackSize.x = pPos->cxMin; ((LPMINMAXINFO)lParam)->ptMinTrackSize.y = pPos->cyMin; } return FALSE; } default: return FALSE; } return TRUE; }

VOID MDIActivateDlgSize (  HWND  hwnd, int  width, int  height )

Definition at line 685 of file mdimenu.c. References atomMDIActivateProp, tagMDIACTIVATEPOS::cx, tagMDIACTIVATEPOS::cy, FALSE, FNID_BUTTON, FNID_LISTBOX, GETFNID, GetParent(), GetProp(), MAKEINTATOM, NtUserBeginDeferWindowPos, NtUserDeferWindowPos(), NtUserEndDeferWindowPosEx(), NULL, PMDIACTIVATEPOS, PtoH, tagWND::rcClient, tagWND::rcWindow, REBASEPWND, ValidateHwnd, and VOID(). Referenced by MDIActivateDlgInit(), and MDIActivateDlgProcWorker(). { PMDIACTIVATEPOS pPos; PWND pwnd, pwndList, pwndButtonLeft, pwndButtonRight; HDWP hdwp; int deltaX, deltaY; pPos = (PMDIACTIVATEPOS)GetProp(GetParent(hwnd), MAKEINTATOM(atomMDIActivateProp)); if (pPos == NULL) { return; } /* * Retrieve the children */ if ((pwnd = ValidateHwnd(hwnd)) == NULL) { return; } pwndList = REBASEPWND(pwnd, spwndChild); pwndButtonLeft = REBASEPWND(pwndList, spwndNext); pwndButtonRight = REBASEPWND(pwndButtonLeft, spwndNext); UserAssert(GETFNID(pwndList) == FNID_LISTBOX); UserAssert(GETFNID(pwndButtonLeft) == FNID_BUTTON); UserAssert(GETFNID(pwndButtonRight) == FNID_BUTTON); UserAssert(pwndButtonRight->rcWindow.left > pwndButtonLeft->rcWindow.left); deltaX = width - pPos->cx; deltaY = height - pPos->cy; pPos->cx = width; pPos->cy = height; /* * Move/resize the child windows accordingly */ hdwp = NtUserBeginDeferWindowPos(3); if (hdwp) { hdwp = NtUserDeferWindowPos( hdwp, PtoH(pwndList), NULL, 0, 0, deltaX + pwndList->rcWindow.right - pwndList->rcWindow.left, deltaY + pwndList->rcWindow.bottom - pwndList->rcWindow.top, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE ); if (hdwp) { hdwp = NtUserDeferWindowPos(hdwp, PtoH(pwndButtonLeft), NULL, pwndButtonLeft->rcWindow.left - pwnd->rcClient.left, deltaY + pwndButtonLeft->rcWindow.top - pwnd->rcClient.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE ); if (hdwp) { hdwp = NtUserDeferWindowPos( hdwp, PtoH(pwndButtonRight), NULL, pwndButtonRight->rcWindow.left - pwnd->rcClient.left, deltaY + pwndButtonRight->rcWindow.top - pwnd->rcClient.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE ); } } if (hdwp) { NtUserEndDeferWindowPosEx(hdwp, FALSE); } } }

BOOL MDIAddSysMenu (  HMENU  hMenuFrame, HWND  hwndChild )

Definition at line 165 of file mdimenu.c. References _GetSubMenu(), BOOL, ClearWindowState(), FALSE, InternalInsertMenuItem(), IsWindow(), MFMWFP_NOITEM, NtUserRedrawFrame, NtUserRemoveMenu(), NtUserSetSysMenu, PtoH, REBASEALWAYS, tagWND::spmenuSys, TestWF, TRUE, ValidateHwnd, WFMINBOX, WFOLDUI, WFSYSMENU, and xxxMNCanClose(). Referenced by MDICompleteChildCreation(), MDISetMenu(), and xxxChildResize(). { PWND pwndChild; MENUITEMINFO mii; PMENU pMenuChild; // LATER -- look at passing pwndChild in -- FritzS UserAssert(IsWindow(hwndChild)); pwndChild = ValidateHwnd(hwndChild); if (!hMenuFrame || !pwndChild || !pwndChild->spmenuSys) { return FALSE; } /* * We don't need the pMenuChild pointer but the handle. However, if you * do PtoH(_GetSubMenu()), you end up calling the function twice */ pMenuChild = _GetSubMenu (REBASEALWAYS(pwndChild, spmenuSys), 0); if (!pMenuChild) { return FALSE; } // Add MDI system button as first menu item mii.cbSize = sizeof(MENUITEMINFO); mii.fMask = MIIM_SUBMENU | MIIM_DATA | MIIM_BITMAP; // Add MIIM_DATA because of hack described below mii.hSubMenu = PtoH(pMenuChild); // Fritzs -- this won't work. // mii.dwTypeData = (LPSTR) MAKELONG(MENUHBM_SYSTEM, GetWindowSmIcon(hwndChild)); mii.hbmpItem = HBMMENU_SYSTEM; // FritzS -- so, we sneak the icon into ItemData mii.dwItemData = (ULONG_PTR)hwndChild; if (!InternalInsertMenuItem(hMenuFrame, 0, TRUE, &mii)) return FALSE; // TimeLine 6.1 gets confused by the extra Min/Close buttons, // don't add them if WFOLDUI mii.fMask = MIIM_ID | MIIM_FTYPE | MIIM_BITMAP; mii.fType = MFT_RIGHTJUSTIFY; pwndChild = ValidateHwnd(hwndChild); if (!pwndChild) { NtUserRemoveMenu(hMenuFrame, 0, MF_BYPOSITION); return FALSE; } if (!TestWF(pwndChild, WFOLDUI)) { // Add Minimize button as last menu item mii.hbmpItem = (TestWF(pwndChild, WFMINBOX) ? HBMMENU_MBAR_MINIMIZE : HBMMENU_MBAR_MINIMIZE_D); mii.wID = SC_MINIMIZE; if (!InternalInsertMenuItem(hMenuFrame, MFMWFP_NOITEM, TRUE, &mii)) { NtUserRemoveMenu(hMenuFrame, 0, MF_BYPOSITION); return FALSE; } mii.fType &= ~MFT_RIGHTJUSTIFY; } // Add Restore button as last menu item mii.hbmpItem = HBMMENU_MBAR_RESTORE; mii.wID = SC_RESTORE; if (!InternalInsertMenuItem(hMenuFrame, MFMWFP_NOITEM, TRUE, &mii)) { // BOGUS -- we gotta remove the MINIMIZE button too NtUserRemoveMenu(hMenuFrame, 0, MF_BYPOSITION); return FALSE; } pwndChild = ValidateHwnd(hwndChild); if (!pwndChild) { NtUserRemoveMenu(hMenuFrame, 0, MF_BYPOSITION); return FALSE; } if (!TestWF(pwndChild, WFOLDUI)) { // Add Close button as last menu item mii.hbmpItem = (xxxMNCanClose(pwndChild) ? HBMMENU_MBAR_CLOSE : HBMMENU_MBAR_CLOSE_D); mii.wID = SC_CLOSE; if (!InternalInsertMenuItem(hMenuFrame, MFMWFP_NOITEM, TRUE, &mii)) { // BOGUS -- we gotta remove the MINIMIZE and RESTORE buttons too NtUserRemoveMenu(hMenuFrame, 0, MF_BYPOSITION); return FALSE; } } /* * Set the menu items to proper state since we just maximized it. Note * setsysmenu doesn't work if we've cleared the sysmenu bit so do it now... */ NtUserSetSysMenu(hwndChild); /* * This is so that if the user brings up the child sysmenu, it's sure * to be that in the frame menu bar... */ ClearWindowState(pwndChild, WFSYSMENU); /* * Make sure that the child's frame is redrawn to reflect the removed * system menu. */ NtUserRedrawFrame(hwndChild); return TRUE; }

BOOL MDIRemoveSysMenu (  HMENU  hMenuFrame, HWND  hwndChild )

Definition at line 289 of file mdimenu.c. References BOOL, FALSE, GetMenuItemCount(), GetMenuItemID(), NtUserDeleteMenu(), NtUserRedrawFrame, NtUserRemoveMenu(), NULL, SetWindowState(), TestWF, TRUE, UINT, ValidateHwnd, WFOLDUI, and WFSYSMENU. Referenced by MDIClientWndProcWorker(), MDISetMenu(), xxxChildResize(), and xxxMDIDestroy(). { int iLastItem; UINT iLastCmd; PWND pwndChild; // LATER -- look at passing pwndChild in -- FritzS if (hMenuFrame == NULL) return FALSE; pwndChild = ValidateHwnd(hwndChild); if (pwndChild == NULL) return FALSE; iLastItem = GetMenuItemCount(hMenuFrame) - 1; iLastCmd = TestWF(pwndChild, WFOLDUI) ? SC_RESTORE : SC_CLOSE; if ((UINT) GetMenuItemID(hMenuFrame, iLastItem) != iLastCmd) return FALSE; /* * Enable the sysmenu in the child window. */ SetWindowState(pwndChild, WFSYSMENU); /* * Take the child sysmenu popup out of the frame menu. */ NtUserRemoveMenu(hMenuFrame, 0, MF_BYPOSITION); /* * Delete the restore button from the menu bar. */ NtUserDeleteMenu(hMenuFrame, iLastItem - 1, MF_BYPOSITION); pwndChild = ValidateHwnd(hwndChild); if (pwndChild == NULL) return FALSE; if (!TestWF(pwndChild, WFOLDUI)) { NtUserDeleteMenu(hMenuFrame, iLastItem - 2, MF_BYPOSITION); NtUserDeleteMenu(hMenuFrame, iLastItem - 3, MF_BYPOSITION); } /* * Make sure that the child's frame is redrawn to reflect the added * system menu. */ NtUserRedrawFrame(hwndChild); return TRUE; }

HMENU MDISetMenu (  PWND  pwndMDI, BOOL  fRefresh, HMENU  hNewSys, HMENU  hNewWindow )

Definition at line 499 of file mdimenu.c. References ACTIVE, AppendToWindowsMenu(), CheckMenuItem(), CKIDS, FALSE, FindPwndChild(), FIRST, GetMenu(), GetMenuItemCount(), GetMenuItemID(), GetMenuState(), HW, Lock, MAXED, MAXITEMS, MDIAddSysMenu(), MDIRemoveSysMenu(), NtUserDeleteMenu(), NtUserSetMenu(), NULL, REBASEPWND, ShiftMenuIDs(), SwitchWindowsMenus(), TestWF, UINT, WFDISABLED, WFVISIBLE, and WINDOW. Referenced by MDIClientWndProcWorker(). { int i; int iFirst; int item; PMDI pmdi; PWND pwndParent; HMENU hOldSys; HMENU hOldWindow; PWND pwndChild; /* * Get a pointer to the MDI structure */ pmdi = ((PMDIWND)pwndMDI)->pmdi; /* * Save the old values */ pwndParent = REBASEPWND(pwndMDI, spwndParent); hOldSys = GetMenu(HW(pwndParent)); hOldWindow = WINDOW(pmdi); if (fRefresh) { hNewSys = hOldSys; hNewWindow = hOldWindow; } /* * Change the Frame Menu. */ if (hNewSys && (hNewSys != hOldSys)) { if (MAXED(pmdi)) MDIRemoveSysMenu(hOldSys, MAXED(pmdi)); NtUserSetMenu(HW(pwndParent), hNewSys, FALSE); if (MAXED(pmdi)) MDIAddSysMenu(hNewSys, MAXED(pmdi)); } else hNewSys = hOldSys; /* * Now update the Window menu. */ if (fRefresh || (hOldWindow != hNewWindow)) { iFirst = FIRST(pmdi); if (hOldWindow) { int cItems = GetMenuItemCount(hOldWindow); for (i = cItems - 1; i >= 0; i--) { if (GetMenuState(hOldWindow, i, MF_BYPOSITION) & MF_SEPARATOR) break; } if ((i >= 0) && (GetMenuItemID(hOldWindow, i + 1) == (UINT)iFirst)) { int idTrim = i; for (i = idTrim; i < cItems; i++) NtUserDeleteMenu(hOldWindow, idTrim, MF_BYPOSITION); } } Lock(&WINDOW(pmdi), hNewWindow); if (hNewWindow != NULL) { /* * Add the list of child windows to the new window */ for (i = 0, item = 0; ((UINT)i < CKIDS(pmdi)) && (item < MAXITEMS); i++) { pwndChild = FindPwndChild(pwndMDI, iFirst + item); if (pwndChild != NULL) { if ((!TestWF(pwndChild, WFVISIBLE) && (LOWORD(pwndMDI->style) & 0x0001)) || TestWF(pwndChild, WFDISABLED)) { ShiftMenuIDs(pwndMDI, pwndChild); } else { AppendToWindowsMenu(pwndMDI, pwndChild); item++; } } } /* * Add checkmark by the active child's menu item */ if (ACTIVE(pmdi)) CheckMenuItem(hNewWindow, (WORD)GetWindowID(ACTIVE(pmdi)), MF_BYCOMMAND | MF_CHECKED); } /* * Out with the old, in with the new */ SwitchWindowsMenus(hNewSys, hOldWindow, hNewWindow); } return hOldSys; }

void ModifyMenuItem (  PWND  pwnd  )

Definition at line 104 of file mdimenu.c. References ACTIVE, FALSE, FIRST, HWq, MakeMenuItem(), PtoH, REBASEALWAYS, REBASEPWND, tagWND::spmenu, ThunkedMenuItemInfo(), and UINT. Referenced by DefMDIChildProcWorker(), and xxxMDIActivate(). { PMDI pmdi; WCHAR sz[200]; MENUITEMINFO mii; PWND pwndParent; PMENU pmenu; /* * Get a pointer to the MDI structure */ pwndParent = REBASEPWND(pwnd, spwndParent); pmdi = ((PMDIWND)pwndParent)->pmdi; if (PtrToUlong(pwnd->spmenu) > FIRST(pmdi) + (UINT)8) return; mii.cbSize = sizeof(MENUITEMINFO); mii.fMask = MIIM_STRING; mii.dwTypeData = sz; /* * Parent is MDI Client. */ MakeMenuItem(sz, pwnd); /* * Changing the active child? Check it. */ if (HWq(pwnd) == ACTIVE(pmdi)) { mii.fMask |= MIIM_STATE; mii.fState = MFS_CHECKED; } pwndParent = REBASEPWND(pwndParent, spwndParent); if (pwndParent->spmenu) { /* * Bug# 21566. If spmenu is NULL we used to fail * because REBASEALWAYS is trying to get the kernel * address of NULL based on pwndParent */ pmenu = REBASEALWAYS(pwndParent, spmenu); /* * Internal call to SetMenuItemInfo */ ThunkedMenuItemInfo(PtoH(pmenu), PtrToUlong(pwnd->spmenu), FALSE, FALSE, &mii, FALSE); } }

void ShiftMenuIDs (  PWND  pwnd, PWND  pwndVictim )

Definition at line 467 of file mdimenu.c. References CKIDS, FIRST, HWq, REBASEPWND, SetWindowLongPtr(), tagWND::spmenu, and tagWND::spwndOwner. Referenced by MDISetMenu(), and xxxMDIDestroy(). { PMDI pmdi; PWND pwndChild; PWND pwndParent; /* * Get a pointer to the MDI structure */ pmdi = ((PMDIWND)pwnd)->pmdi; pwndParent = REBASEPWND(pwndVictim, spwndParent); pwndChild = REBASEPWND(pwndParent, spwndChild); while (pwndChild) { if (!pwndChild->spwndOwner && (pwndChild->spmenu > pwndVictim->spmenu)) { SetWindowLongPtr(HWq(pwndChild), GWLP_ID, PtrToUlong(pwndChild->spmenu) - 1); } pwndChild = REBASEPWND(pwndChild, spwndNext); } SetWindowLongPtr(HWq(pwndVictim), GWLP_ID, FIRST(pmdi) + CKIDS(pmdi) - 1); }

BOOL SwitchWindowsMenus (  HMENU  hmenu, HMENU  hOldWindow, HMENU  hNewWindow )

Definition at line 417 of file mdimenu.c. References BOOL, FALSE, GetMenuItemInfoInternalW(), GetSubMenu(), InternalInsertMenuItem(), NtUserRemoveMenu(), and TRUE. Referenced by MDISetMenu(). { int i; HMENU hsubMenu; WCHAR szMenuName[128]; MENUITEMINFO mii; if (hOldWindow == hNewWindow) return TRUE; mii.cbSize = sizeof(MENUITEMINFO); /* * Determine position of old "Window" menu */ for (i = 0; hsubMenu = GetSubMenu(hmenu, i); i++) { if (hsubMenu == hOldWindow) { // Extract the name of the old menu to use it for the new menu mii.fMask = MIIM_STRING; mii.dwTypeData = szMenuName; mii.cch = sizeof(szMenuName)/sizeof(WCHAR); GetMenuItemInfoInternalW(hmenu, i, TRUE, &mii); // Out with the old, in with the new if (!NtUserRemoveMenu(hmenu, i, MF_BYPOSITION)) return(FALSE); mii.fMask |= MIIM_SUBMENU; mii.hSubMenu = hNewWindow; return(InternalInsertMenuItem(hmenu, i, TRUE, &mii)); } } return(FALSE); }

void xxxInitActivateDlg (  HWND  hwnd, PWND  pwndMDI )

Definition at line 611 of file mdimenu.c. References CCHTITLEMAX, CheckLock, CKIDS, DWORD, FindPwndChild(), FIRST, GetDlgItem(), GetWindowText(), HWq, L, MAXITEMS, NtUserGetDC(), NtUserReleaseDC, NtUserSetFocus(), SendDlgItemMessage(), Size, szTitle, TestWF, ThreadLockAlways, ThreadUnlock, UINT, WFDISABLED, and WFVISIBLE. Referenced by MDIActivateDlgInit(). { PMDI pmdi; UINT wKid; HWND hwndT; PWND pwndT; WCHAR szTitle[CCHTITLEMAX]; TL tlpwndT; SIZE Size; HDC hDC; DWORD width = 0; CheckLock(pwndMDI); /* * Get a pointer to the MDI structure */ pmdi = ((PMDIWND)pwndMDI)->pmdi; hDC = NtUserGetDC(hwnd); /* * Insert the list of titles. * Note the wKid-th item in the listbox has ID wKid+FIRST(pwnd), so that * the listbox is in creation order (like the menu). This is also * helpful when we go to select one... */ for (wKid = 0; wKid < CKIDS(pmdi); wKid++) { pwndT = FindPwndChild(pwndMDI, (UINT)(wKid + FIRST(pmdi))); if (pwndT && TestWF(pwndT, WFVISIBLE) && !TestWF(pwndT, WFDISABLED)) { ThreadLockAlways(pwndT, &tlpwndT); GetWindowText(HWq(pwndT), szTitle, CCHTITLEMAX); SendDlgItemMessage(hwnd, 100, LB_ADDSTRING, 0, (LPARAM)szTitle); GetTextExtentPoint(hDC, szTitle, lstrlen(szTitle), &Size); if (Size.cx > (LONG)width) { width = Size.cx; } ThreadUnlock(&tlpwndT); } } /* * Select the currently active window. */ SendDlgItemMessage(hwnd, 100, LB_SETTOPINDEX, MAXITEMS - 1, 0L); SendDlgItemMessage(hwnd, 100, LB_SETCURSEL, MAXITEMS - 1, 0L); /* * Set the horizontal extent of the list box to the longest window title. */ SendDlgItemMessage(hwnd, 100, LB_SETHORIZONTALEXTENT, width, 0L); NtUserReleaseDC(hwnd, hDC); /* * Set the focus to the listbox. */ hwndT = GetDlgItem(hwnd, 100); NtUserSetFocus(hwndT); }

---