810 lines
22 KiB
C
810 lines
22 KiB
C
/*
|
|
* MDIMENU.C -
|
|
|
|
* Copyright (c) 1985 - 1999, Microsoft Corporation
|
|
|
|
* MDI "Window" Menu Support
|
|
|
|
* History
|
|
* 11-14-90 MikeHar Ported from windows
|
|
* 14-Feb-1991 mikeke Added Revalidation code
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
* FindPwndChild
|
|
|
|
* History:
|
|
* 11-14-90 MikeHar Ported from windows
|
|
*/
|
|
|
|
|
|
PWND FindPwndChild(PWND pwndMDI, UINT wChildID)
|
|
{
|
|
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)
|
|
/*
|
|
* History:
|
|
* 11-14-90 MikeHar Ported from windows
|
|
* 4-16-91 Win31 Merge
|
|
*/
|
|
{
|
|
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 ModifyMenuItem(PWND pwnd)
|
|
/*
|
|
* History:
|
|
* 11-14-90 MikeHar Ported from windows
|
|
*/
|
|
{
|
|
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;
|
|
|
|
MakeMenuItem(sz, pwnd);/*Parent is MDI Client.*/
|
|
|
|
/*
|
|
* 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);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL MDIAddSysMenu(HMENU hMenuFrame, HWND hwndChild)
|
|
/*
|
|
* Insert the MDI child's system menu onto the existing Menu.
|
|
* History:
|
|
* 11-14-90 MikeHar Ported from windows
|
|
*/
|
|
{
|
|
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)
|
|
/*
|
|
* History:
|
|
* 11-14-90 MikeHar Ported from windows
|
|
*/
|
|
{
|
|
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;
|
|
|
|
SetWindowState(pwndChild, WFSYSMENU);/*Enable the sysmenu in the child window.*/
|
|
NtUserRemoveMenu(hMenuFrame, 0, MF_BYPOSITION);/*Take the child sysmenu popup out of the frame menu.*/
|
|
NtUserDeleteMenu(hMenuFrame, iLastItem - 1, MF_BYPOSITION); /*Delete the restore button from the menu bar.*/
|
|
|
|
pwndChild = ValidateHwnd(hwndChild);
|
|
if (pwndChild == NULL)
|
|
return FALSE;
|
|
|
|
if (!TestWF(pwndChild, WFOLDUI)) {
|
|
NtUserDeleteMenu(hMenuFrame, iLastItem - 2, MF_BYPOSITION);
|
|
NtUserDeleteMenu(hMenuFrame, iLastItem - 3, MF_BYPOSITION);
|
|
}
|
|
|
|
NtUserRedrawFrame(hwndChild);/*Make sure that the child's frame is redrawn to reflect the added system menu.*/
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* AppendToWindowsMenu
|
|
|
|
* Add the title of the MDI child window 'hwndChild' to the bottom of the
|
|
* "Window" menu (or add the "More Windows ..." item) if there's room.
|
|
|
|
* MDI Child # Add
|
|
* ------------- --------------------
|
|
* < MAXITEMS Child # and Title
|
|
* = MAXITEMS "More Windows ..."
|
|
* > MAXITEMS nothing
|
|
|
|
* History:
|
|
* 17-Mar-1992 mikeke from win31
|
|
*/
|
|
BOOL FAR PASCAL AppendToWindowsMenu(PWND pwndMDI, PWND pwndChild)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
BOOL SwitchWindowsMenus(HMENU hmenu, HMENU hOldWindow, HMENU hNewWindow)
|
|
/*
|
|
* Switch the "Window" menu in the frame menu bar 'hMenu' from 'hOldWindow' to 'hNewWindow'
|
|
* History:
|
|
* 17-Mar-1992 mikeke from win31
|
|
*/
|
|
{
|
|
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 ShiftMenuIDs(PWND pwnd, PWND pwndVictim)
|
|
/*
|
|
* Shift the id's of the MDI child windows of the MDI client window 'hWnd'
|
|
* down by 1 (id--) starting with the child window 'hwndVictim' -- moving
|
|
* 'hwndVictim' to the end of the list
|
|
|
|
* History:
|
|
* 17-Mar-1992 mikeke from win31
|
|
*/
|
|
{
|
|
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);
|
|
}
|
|
|
|
|
|
HMENU MDISetMenu(PWND pwndMDI, BOOL fRefresh, HMENU hNewSys, HMENU hNewWindow)
|
|
/*
|
|
* History:
|
|
* 11-14-90 MikeHar Ported from windows
|
|
*/
|
|
{
|
|
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 xxxInitActivateDlg(HWND hwnd, PWND pwndMDI)
|
|
/*
|
|
* History:
|
|
* 11-14-90 MikeHar Ported from windows
|
|
*/
|
|
{
|
|
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);
|
|
}
|
|
|
|
|
|
VOID MDIActivateDlgSize(HWND hwnd, int width, int height)
|
|
/*
|
|
* The minimum allowed size and the previous one are saved as properties of the parent window.
|
|
* History:
|
|
* Oct 97 MCostea Created
|
|
*/
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
VOID MDIActivateDlgInit(HWND hwnd, LPARAM lParam)
|
|
/*
|
|
* The minimum allowed size and the previous one are saved as properties of the parent window.
|
|
* History:
|
|
* Oct 97 MCostea Created
|
|
*/
|
|
{
|
|
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 MDIActivateDlgProcWorker(HWND hwnd, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
/*
|
|
* MDIActivateDlgProc
|
|
|
|
* History:
|
|
* 11-14-90 MikeHar Ported from windows
|
|
*/
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
INT_PTR WINAPI MDIActivateDlgProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
return MDIActivateDlgProcWorker(hwnd, message, wParam, lParam);
|
|
}
|
|
|
|
|
|
INT_PTR WINAPI MDIActivateDlgProcW(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
return MDIActivateDlgProcWorker(hwnd, message, wParam, lParam);
|
|
}
|