ReactOS 0.4.15-dev-8096-ga0eec98
mdi.c File Reference
#include <user32.h>
Include dependency graph for mdi.c:

Go to the source code of this file.

Classes

struct  MDICLIENTINFO
 
struct  CASCADE_INFO
 

Macros

#define MDI_MAXTITLELENGTH   0xa1
 
#define WM_MDICALCCHILDSCROLL   0x003F /* this is exactly what Windows uses */
 
#define MDI_MOREWINDOWSLIMIT
 
#define MDI_IDC_LISTBOX   100
 
#define IDS_MDI_MOREWINDOWS   13
 
#define MDIF_NEEDUPDATE   0x0001
 
#define MIN_THRESHOLD(xy)   (((xy) * 4) / 7) /* in the rate 4/7 */
 
#define MAX_THRESHOLD(xy)   (((xy) * 5) / 7) /* in the rate 5/7 */
 

Typedefs

typedef struct CASCADE_INFO CASCADE_INFO
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (mdi)
 
static void MDI_UpdateFrameText (HWND, HWND, BOOL, LPCWSTR)
 
static BOOL MDI_AugmentFrameMenu (HWND, HWND)
 
static BOOL MDI_RestoreFrameMenu (HWND, HWND, HBITMAP)
 
static LONG MDI_ChildActivate (HWND, HWND)
 
static LRESULT MDI_RefreshMenu (MDICLIENTINFO *)
 
static HWND MDI_MoreWindowsDialog (HWND)
 
HWNDWIN_ListChildren (HWND hWndparent)
 
static HWND MDI_GetChildByID (HWND hwnd, UINT id, MDICLIENTINFO *ci)
 
static void MDI_PostUpdate (HWND hwnd, MDICLIENTINFO *ci, WORD recalc)
 
static MDICLIENTINFOget_client_info (HWND client)
 
static BOOL is_close_enabled (HWND hwnd, HMENU hSysMenu)
 
static HWND MDI_GetWindow (MDICLIENTINFO *clientInfo, HWND hWnd, BOOL bNext, DWORD dwStyleMask)
 
void MDI_CalcDefaultChildPos (HWND hwndClient, INT total, LPPOINT lpPos, INT delta, UINT *id)
 
static LRESULT MDISetMenu (HWND hwnd, HMENU hmenuFrame, HMENU hmenuWindow)
 
static void MDI_ChildGetMinMaxInfo (HWND client, HWND hwnd, MINMAXINFO *lpMinMax)
 
static void MDI_SwitchActiveChild (MDICLIENTINFO *ci, HWND hwndTo, BOOL activate)
 
static LRESULT MDIDestroyChild (HWND client, MDICLIENTINFO *ci, HWND child, BOOL flagDestroy)
 
static HBITMAP CreateMDIMenuBitmap (void)
 
static LONG MDICascade (HWND client, MDICLIENTINFO *ci)
 
static void MDITile (HWND client, MDICLIENTINFO *ci, WPARAM wParam)
 
LRESULT WINAPI MDIClientWndProc_common (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, BOOL unicode)
 
LRESULT WINAPI MDIClientWndProcA (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 
LRESULT WINAPI MDIClientWndProcW (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 
LRESULT WINAPI DefFrameProcA (HWND hwnd, HWND hwndMDIClient, UINT message, WPARAM wParam, LPARAM lParam)
 
LRESULT WINAPI DefFrameProcW (HWND hwnd, HWND hwndMDIClient, UINT message, WPARAM wParam, LPARAM lParam)
 
LRESULT WINAPI DefMDIChildProcA (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 
LRESULT WINAPI DefMDIChildProcW (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 
HWND WINAPI CreateMDIWindowA (LPCSTR lpClassName, LPCSTR lpWindowName, DWORD dwStyle, INT X, INT Y, INT nWidth, INT nHeight, HWND hWndParent, HINSTANCE hInstance, LPARAM lParam)
 
HWND WINAPI CreateMDIWindowW (LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, INT X, INT Y, INT nWidth, INT nHeight, HWND hWndParent, HINSTANCE hInstance, LPARAM lParam)
 
BOOL WINAPI TranslateMDISysAccel (HWND hwndClient, LPMSG msg)
 
void WINAPI CalcChildScroll (HWND hwnd, INT scroll)
 
void WINAPI ScrollChildren (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 
static BOOL CALLBACK GetCascadeChildProc (HWND hwnd, LPARAM lParam)
 
static BOOL QuerySizeFix (HWND hwnd, LPINT pcx, LPINT pcy)
 
WORD WINAPI CascadeWindows (HWND hwndParent, UINT wFlags, LPCRECT lpRect, UINT cKids, const HWND *lpKids)
 
WORD WINAPI CascadeChildWindows (HWND parent, UINT flags)
 
WORD WINAPI TileWindows (HWND hwndParent, UINT wFlags, LPCRECT lpRect, UINT cKids, const HWND *lpKids)
 
WORD WINAPI TileChildWindows (HWND parent, UINT flags)
 
static INT_PTR WINAPI MDI_MoreWindowsDlgProc (HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
 

Variables

const struct builtin_class_descr MDICLIENT_builtin_class
 

Macro Definition Documentation

◆ IDS_MDI_MOREWINDOWS

#define IDS_MDI_MOREWINDOWS   13

Definition at line 95 of file mdi.c.

◆ MAX_THRESHOLD

#define MAX_THRESHOLD (   xy)    (((xy) * 5) / 7) /* in the rate 5/7 */

◆ MDI_IDC_LISTBOX

#define MDI_IDC_LISTBOX   100

Definition at line 94 of file mdi.c.

◆ MDI_MAXTITLELENGTH

#define MDI_MAXTITLELENGTH   0xa1

Definition at line 88 of file mdi.c.

◆ MDI_MOREWINDOWSLIMIT

#define MDI_MOREWINDOWSLIMIT
Value:
9 /* after this number of windows, a "More Windows..."
option will appear under the Windows menu */

Definition at line 93 of file mdi.c.

◆ MDIF_NEEDUPDATE

#define MDIF_NEEDUPDATE   0x0001

Definition at line 97 of file mdi.c.

◆ MIN_THRESHOLD

#define MIN_THRESHOLD (   xy)    (((xy) * 4) / 7) /* in the rate 4/7 */

◆ WM_MDICALCCHILDSCROLL

#define WM_MDICALCCHILDSCROLL   0x003F /* this is exactly what Windows uses */

Definition at line 90 of file mdi.c.

Typedef Documentation

◆ CASCADE_INFO

Function Documentation

◆ CalcChildScroll()

void WINAPI CalcChildScroll ( HWND  hwnd,
INT  scroll 
)

Definition at line 1800 of file mdi.c.

1802{
1804 RECT childRect, clientRect;
1805 HWND *list;
1806 DWORD style;
1807 WINDOWINFO WindowInfo;
1808
1809 GetClientRect( hwnd, &clientRect );
1810 SetRectEmpty( &childRect );
1811
1812 /* The rectangle returned by GetClientRect always has 0,0 as top left
1813 * because it is in client coordinates. The rectangles returned by
1814 * GetWindowRect are in screen coordinates to make this complicated.
1815 *
1816 * Apparently (in ReactOS at least) the rcClient returned by GetWindowInfo
1817 * is in screen coordinates too.
1818 */
1819 WindowInfo.cbSize = sizeof(WindowInfo);
1820 if (!GetWindowInfo(hwnd, &WindowInfo))
1821 {
1822 ERR("Can't get window info\n");
1823 return;
1824 }
1825
1826 TRACE("CalcChildScroll 1\n");
1827 if ((list = WIN_ListChildren( hwnd )))
1828 {
1829 int i;
1830 for (i = 0; list[i]; i++)
1831 {
1833 if (style & WS_MAXIMIZE)
1834 {
1835 HeapFree( GetProcessHeap(), 0, list );
1837 ERR("CalcChildScroll 2\n");
1838 return;
1839 }
1840 if (style & WS_VISIBLE)
1841 {
1842 RECT rect;
1843 GetWindowRect( list[i], &rect );
1844 OffsetRect(&rect, -WindowInfo.rcClient.left,
1845 -WindowInfo.rcClient.top);
1846 //WIN_GetRectangles( list[i], COORDS_PARENT, &rect, NULL );
1847 TRACE("CalcChildScroll L\n");
1848 UnionRect( &childRect, &rect, &childRect );
1849 }
1850 }
1851 HeapFree( GetProcessHeap(), 0, list );
1852 }
1853 UnionRect( &childRect, &clientRect, &childRect );
1854 TRACE("CalcChildScroll 3\n");
1855 /* set common info values */
1856 info.cbSize = sizeof(info);
1857 info.fMask = SIF_POS | SIF_RANGE | SIF_PAGE;
1858 info.nPos = 0;
1859
1860 /* set the specific values and apply but only if window style allows */
1861 /* Note how we set nPos to 0 because we scroll the clients instead of
1862 * the window, and we set nPage to 1 bigger than the clientRect because
1863 * otherwise the scrollbar never disables. This causes a somewhat ugly
1864 * effect though while scrolling.
1865 */
1867 switch( scroll )
1868 {
1869 case SB_BOTH:
1870 case SB_HORZ:
1871 if (style & (WS_HSCROLL | WS_VSCROLL))
1872 {
1873 info.nMin = childRect.left;
1874 info.nMax = childRect.right;
1875 info.nPage = 1 + clientRect.right - clientRect.left;
1876 //info.nMax = childRect.right - clientRect.right;
1877 //info.nPos = clientRect.left - childRect.left;
1879 }
1880 if (scroll == SB_HORZ) break;
1881 /* fall through */
1882 case SB_VERT:
1883 if (style & (WS_HSCROLL | WS_VSCROLL))
1884 {
1885 info.nMin = childRect.top;
1886 info.nMax = childRect.bottom;
1887 info.nPage = 1 + clientRect.bottom - clientRect.top;
1888 //info.nMax = childRect.bottom - clientRect.bottom;
1889 //info.nPos = clientRect.top - childRect.top;
1891 }
1892 break;
1893 }
Arabic default style
Definition: afstyles.h:94
#define ERR(fmt,...)
Definition: debug.h:113
Definition: list.h:37
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define GetProcessHeap()
Definition: compat.h:736
#define HeapFree(x, y, z)
Definition: compat.h:735
unsigned long DWORD
Definition: ntddk_ex.h:95
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define WS_MAXIMIZE
Definition: pedump.c:623
#define WS_VSCROLL
Definition: pedump.c:627
#define WS_VISIBLE
Definition: pedump.c:620
#define WS_HSCROLL
Definition: pedump.c:628
#define list
Definition: rosglue.h:35
#define TRACE(s)
Definition: solgame.cpp:4
& rect
Definition: startmenu.cpp:1413
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
RECT rcClient
Definition: winuser.h:3768
DWORD cbSize
Definition: winuser.h:3766
HWND * WIN_ListChildren(HWND hWndparent)
Definition: mdi.c:139
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
#define GetWindowLongPtrW
Definition: winuser.h:4829
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
#define SIF_RANGE
Definition: winuser.h:1235
BOOL WINAPI GetWindowInfo(_In_ HWND, _Inout_ PWINDOWINFO)
#define SB_VERT
Definition: winuser.h:553
LONG WINAPI GetWindowLongW(_In_ HWND, _In_ int)
#define SIF_PAGE
Definition: winuser.h:1233
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)
#define SB_BOTH
Definition: winuser.h:555
BOOL WINAPI SetRectEmpty(_Out_ LPRECT)
#define SIF_POS
Definition: winuser.h:1234
BOOL WINAPI OffsetRect(_Inout_ LPRECT, _In_ int, _In_ int)
int WINAPI SetScrollInfo(_In_ HWND, _In_ int, _In_ LPCSCROLLINFO, _In_ BOOL)
BOOL WINAPI ShowScrollBar(_In_ HWND, _In_ int, _In_ BOOL)
BOOL WINAPI UnionRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
#define GWL_STYLE
Definition: winuser.h:852
#define SB_HORZ
Definition: winuser.h:552

Referenced by MDIClientWndProc_common(), and ScrollChildren().

◆ CascadeChildWindows()

WORD WINAPI CascadeChildWindows ( HWND  parent,
UINT  flags 
)

Definition at line 2207 of file mdi.c.

2209{
2210 return CascadeWindows( parent, flags, NULL, 0, NULL );
#define NULL
Definition: types.h:112
r parent
Definition: btrfs.c:3010
GLbitfield flags
Definition: glext.h:7161
WORD WINAPI CascadeWindows(HWND hwndParent, UINT wFlags, LPCRECT lpRect, UINT cKids, const HWND *lpKids)
Definition: mdi.c:2065

◆ CascadeWindows()

WORD WINAPI CascadeWindows ( HWND  hwndParent,
UINT  wFlags,
LPCRECT  lpRect,
UINT  cKids,
const HWND lpKids 
)

Definition at line 2065 of file mdi.c.

2068{
2070 HWND hwnd, hwndTop, hwndPrev;
2071 HMONITOR hMon;
2073 RECT rcWork, rcWnd;
2074 DWORD i, ret = 0;
2075 INT x, y, cx, cy, cxNew, cyNew, cxWork, cyWork, dx, dy;
2076 HDWP hDWP;
2077 POINT pt;
2078
2079 TRACE("(%p,0x%08x,...,%u,...)\n", hwndParent, wFlags, cKids);
2080
2081 hwndTop = GetTopWindow(hwndParent);
2082
2083 ZeroMemory(&info, sizeof(info));
2084 info.hwndDesktop = GetDesktopWindow();
2085 info.hTrayWnd = FindWindowW(L"Shell_TrayWnd", NULL);
2086 info.hwndProgman = FindWindowW(L"Progman", NULL);
2087 info.hwndParent = hwndParent;
2088 info.wFlags = wFlags;
2089
2090 if (cKids == 0 || lpKids == NULL)
2091 {
2092 info.hwndTop = hwndTop;
2094
2095 info.hwndTop = NULL;
2096 GetCascadeChildProc(hwndTop, (LPARAM)&info);
2097 }
2098 else
2099 {
2100 info.chwnd = cKids;
2101 info.ahwnd = (HWND *)lpKids;
2102 }
2103
2104 if (info.chwnd == 0 || info.ahwnd == NULL)
2105 return ret;
2106
2107 if (lpRect)
2108 {
2109 rcWork = *lpRect;
2110 }
2111 else if (hwndParent)
2112 {
2113 GetClientRect(hwndParent, &rcWork);
2114 }
2115 else
2116 {
2117 pt.x = pt.y = 0;
2118 hMon = MonitorFromPoint(pt, MONITOR_DEFAULTTOPRIMARY);
2119 mi.cbSize = sizeof(mi);
2120 GetMonitorInfoW(hMon, &mi);
2121 rcWork = mi.rcWork;
2122 }
2123
2124 hDWP = BeginDeferWindowPos(info.chwnd);
2125 if (hDWP == NULL)
2126 goto cleanup;
2127
2128 x = rcWork.left;
2129 y = rcWork.top;
2132 cxWork = rcWork.right - rcWork.left;
2133 cyWork = rcWork.bottom - rcWork.top;
2134 hwndPrev = NULL;
2135 for (i = info.chwnd; i > 0;) /* in reverse order */
2136 {
2137 --i;
2138 hwnd = info.ahwnd[i];
2139
2141 continue;
2142
2143 if ((info.wFlags & MDITILE_SKIPDISABLED) && !IsWindowEnabled(hwnd))
2144 continue;
2145
2146 if (IsZoomed(hwnd))
2148
2149 GetWindowRect(hwnd, &rcWnd);
2150 cxNew = cx = rcWnd.right - rcWnd.left;
2151 cyNew = cy = rcWnd.bottom - rcWnd.top;
2152
2153 /* if we can change the window size and it is not only one */
2154 if (info.chwnd != 1 && (GetWindowLongPtrW(hwnd, GWL_STYLE) & WS_THICKFRAME))
2155 {
2156 /* check the size */
2157#define MIN_THRESHOLD(xy) (((xy) * 4) / 7) /* in the rate 4/7 */
2158#define MAX_THRESHOLD(xy) (((xy) * 5) / 7) /* in the rate 5/7 */
2159 cxNew = max(min(cxNew, MAX_THRESHOLD(cxWork)), MIN_THRESHOLD(cxWork));
2160 cyNew = max(min(cyNew, MAX_THRESHOLD(cyWork)), MIN_THRESHOLD(cyWork));
2161#undef MIN_THRESHOLD
2162#undef MAX_THRESHOLD
2163 if (cx != cxNew || cy != cyNew)
2164 {
2165 /* too large. shrink if we can */
2166 if (QuerySizeFix(hwnd, &cxNew, &cyNew))
2167 {
2168 cx = cxNew;
2169 cy = cyNew;
2170 }
2171 }
2172 }
2173
2174 if (x + cx > rcWork.right)
2175 x = rcWork.left;
2176 if (y + cy > rcWork.bottom)
2177 y = rcWork.top;
2178
2179 hDWP = DeferWindowPos(hDWP, hwnd, HWND_TOP, x, y, cx, cy, SWP_NOACTIVATE);
2180 if (hDWP == NULL)
2181 {
2182 ret = 0;
2183 goto cleanup;
2184 }
2185
2186 x += dx;
2187 y += dy;
2188 hwndPrev = hwnd;
2189 ++ret;
2190 }
2191
2193
2194 if (hwndPrev)
2195 SetForegroundWindow(hwndPrev);
2196
2197cleanup:
2198 if (cKids == 0 || lpKids == NULL)
2199 HeapFree(GetProcessHeap(), 0, info.ahwnd);
2200
2201 return (WORD)ret;
static HWND hwndParent
Definition: cryptui.c:300
static void cleanup(void)
Definition: main.c:1335
#define pt(x, y)
Definition: drawing.c:79
unsigned short WORD
Definition: ntddk_ex.h:93
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
BOOL NTAPI NtUserEndDeferWindowPosEx(HDWP WinPosInfo, BOOL bAsync)
Definition: winpos.c:3245
GLint dy
Definition: linetemp.h:97
GLint dx
Definition: linetemp.h:97
#define min(a, b)
Definition: monoChain.cc:55
HMONITOR WINAPI MonitorFromPoint(POINT, DWORD)
#define L(x)
Definition: ntvdm.h:50
#define WS_THICKFRAME
Definition: pedump.c:630
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:586
_Out_opt_ int * cx
Definition: commctrl.h:585
DWORD cbSize
Definition: winuser.h:3784
#define max(a, b)
Definition: svc.c:63
int32_t INT
Definition: typedefs.h:58
int ret
#define MIN_THRESHOLD(xy)
static BOOL QuerySizeFix(HWND hwnd, LPINT pcx, LPINT pcy)
Definition: mdi.c:2047
static BOOL CALLBACK GetCascadeChildProc(HWND hwnd, LPARAM lParam)
Definition: mdi.c:1996
#define MAX_THRESHOLD(xy)
static MONITORINFO mi
Definition: win.c:7338
#define ZeroMemory
Definition: winbase.h:1712
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:531
LONG_PTR LPARAM
Definition: windef.h:208
#define SWP_NOACTIVATE
Definition: winuser.h:1242
BOOL WINAPI ShowWindow(_In_ HWND, _In_ int)
#define SM_CYSIZE
Definition: winuser.h:992
HWND WINAPI GetTopWindow(_In_opt_ HWND)
BOOL WINAPI SetForegroundWindow(_In_ HWND)
BOOL WINAPI EnumChildWindows(_In_opt_ HWND, _In_ WNDENUMPROC, _In_ LPARAM)
#define SM_CXSIZE
Definition: winuser.h:991
BOOL WINAPI IsIconic(_In_ HWND)
HWND WINAPI GetDesktopWindow(void)
Definition: window.c:656
BOOL WINAPI IsZoomed(_In_ HWND)
#define HWND_TOP
Definition: winuser.h:1207
#define SW_SHOWNA
Definition: winuser.h:778
#define SM_CXSIZEFRAME
Definition: winuser.h:993
BOOL WINAPI IsWindowEnabled(_In_ HWND)
#define MDITILE_SKIPDISABLED
Definition: winuser.h:2187
#define SW_RESTORE
Definition: winuser.h:779
HDWP WINAPI DeferWindowPos(_In_ HDWP, _In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
BOOL WINAPI GetMonitorInfoW(_In_ HMONITOR, _Inout_ LPMONITORINFO)
HWND WINAPI FindWindowW(_In_opt_ LPCWSTR, _In_opt_ LPCWSTR)
BOOL WINAPI IsWindowVisible(_In_ HWND)
#define SM_CYSIZEFRAME
Definition: winuser.h:995
int WINAPI GetSystemMetrics(_In_ int)
HDWP WINAPI BeginDeferWindowPos(_In_ int)

Referenced by CascadeChildWindows().

◆ CreateMDIMenuBitmap()

static HBITMAP CreateMDIMenuBitmap ( void  )
static

Definition at line 687 of file mdi.c.

689{
690 HDC hDCSrc = CreateCompatibleDC(0);
691 HDC hDCDest = CreateCompatibleDC(hDCSrc);
692 HBITMAP hbClose = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_OLD_CLOSE) );
693 HBITMAP hbCopy;
694 HBITMAP hobjSrc, hobjDest;
695
696 hobjSrc = SelectObject(hDCSrc, hbClose);
698 hobjDest = SelectObject(hDCDest, hbCopy);
699
701 hDCSrc, GetSystemMetrics(SM_CXSIZE), 0, SRCCOPY);
702
703 SelectObject(hDCSrc, hobjSrc);
704 DeleteObject(hbClose);
705 DeleteDC(hDCSrc);
706
707 hobjSrc = SelectObject( hDCDest, GetStockObject(BLACK_PEN) );
708
709 MoveToEx( hDCDest, GetSystemMetrics(SM_CXSIZE) - 1, 0, NULL );
711
712 SelectObject(hDCDest, hobjSrc );
713 SelectObject(hDCDest, hobjDest);
714 DeleteDC(hDCDest);
715
716 return hbCopy;
static VOID BitBlt(_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_reads_bytes_(Delta *Height) PUCHAR Buffer, _In_ ULONG BitsPerPixel, _In_ ULONG Delta)
Definition: common.c:57
pKey DeleteObject()
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:92
HGDIOBJ WINAPI GetStockObject(_In_ int)
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1539
BOOL WINAPI MoveToEx(_In_ HDC, _In_ int, _In_ int, _Out_opt_ LPPOINT)
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
#define SRCCOPY
Definition: wingdi.h:333
#define BLACK_PEN
Definition: wingdi.h:903
HBITMAP WINAPI CreateCompatibleBitmap(_In_ HDC hdc, _In_ INT cx, _In_ INT cy)
BOOL WINAPI DeleteDC(_In_ HDC)
BOOL WINAPI LineTo(_In_ HDC, _In_ int, _In_ int)
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
HBITMAP WINAPI LoadBitmapW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
Definition: cursoricon.c:2194

Referenced by MDIClientWndProc_common().

◆ CreateMDIWindowA()

HWND WINAPI CreateMDIWindowA ( LPCSTR  lpClassName,
LPCSTR  lpWindowName,
DWORD  dwStyle,
INT  X,
INT  Y,
INT  nWidth,
INT  nHeight,
HWND  hWndParent,
HINSTANCE  hInstance,
LPARAM  lParam 
)

Definition at line 1707 of file mdi.c.

1719{
1720 TRACE("(%s,%s,%08lx,%d,%d,%d,%d,%p,%p,%08lx)\n",
1721 debugstr_a(lpClassName),debugstr_a(lpWindowName),dwStyle,X,Y,
1722 nWidth,nHeight,hWndParent,hInstance,lParam);
1723
1724 return CreateWindowExA(WS_EX_MDICHILD, lpClassName, lpWindowName,
1725 dwStyle, X, Y, nWidth, nHeight, hWndParent,
1726 0, hInstance, (LPVOID)lParam);
HINSTANCE hInstance
Definition: charmap.c:19
LPARAM lParam
Definition: combotst.c:139
#define Y(I)
#define debugstr_a
Definition: kernel32.h:31
HWND WINAPI CreateWindowExA(_In_ DWORD dwExStyle, _In_opt_ LPCSTR lpClassName, _In_opt_ LPCSTR lpWindowName, _In_ DWORD dwStyle, _In_ int X, _In_ int Y, _In_ int nWidth, _In_ int nHeight, _In_opt_ HWND hWndParent, _In_opt_ HMENU hMenu, _In_opt_ HINSTANCE hInstance, _In_opt_ LPVOID lpParam)
#define WS_EX_MDICHILD
Definition: winuser.h:394

◆ CreateMDIWindowW()

HWND WINAPI CreateMDIWindowW ( LPCWSTR  lpClassName,
LPCWSTR  lpWindowName,
DWORD  dwStyle,
INT  X,
INT  Y,
INT  nWidth,
INT  nHeight,
HWND  hWndParent,
HINSTANCE  hInstance,
LPARAM  lParam 
)

Definition at line 1735 of file mdi.c.

1747{
1748 TRACE("(%s,%s,%08lx,%d,%d,%d,%d,%p,%p,%08lx)\n",
1749 debugstr_w(lpClassName), debugstr_w(lpWindowName), dwStyle, X, Y,
1750 nWidth, nHeight, hWndParent, hInstance, lParam);
1751
1752 return CreateWindowExW(WS_EX_MDICHILD, lpClassName, lpWindowName,
1753 dwStyle, X, Y, nWidth, nHeight, hWndParent,
1754 0, hInstance, (LPVOID)lParam);
#define debugstr_w
Definition: kernel32.h:32
HWND WINAPI CreateWindowExW(_In_ DWORD dwExStyle, _In_opt_ LPCWSTR lpClassName, _In_opt_ LPCWSTR lpWindowName, _In_ DWORD dwStyle, _In_ int X, _In_ int Y, _In_ int nWidth, _In_ int nHeight, _In_opt_ HWND hWndParent, _In_opt_ HMENU hMenu, _In_opt_ HINSTANCE hInstance, _In_opt_ LPVOID lpParam)

◆ DefFrameProcA()

LRESULT WINAPI DefFrameProcA ( HWND  hwnd,
HWND  hwndMDIClient,
UINT  message,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 1369 of file mdi.c.

1372{
1373 if (hwndMDIClient)
1374 {
1375 switch (message)
1376 {
1377 case WM_SETTEXT:
1378 {
1380 LPWSTR text = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1381 if (text == NULL)
1382 return 0;
1385 HeapFree( GetProcessHeap(), 0, text );
1386 }
1387 return 1; /* success. FIXME: check text length */
1388
1389 case WM_COMMAND:
1390 case WM_NCACTIVATE:
1391 case WM_NEXTMENU:
1392 case WM_SETFOCUS:
1393 case WM_SIZE:
1395 }
1396 }
HWND hwndMDIClient
Definition: mmc.c:26
WPARAM wParam
Definition: combotst.c:138
#define CP_ACP
Definition: compat.h:109
#define HeapAlloc
Definition: compat.h:733
#define MultiByteToWideChar
Definition: compat.h:110
const WCHAR * text
Definition: package.c:1799
GLenum GLsizei len
Definition: glext.h:6722
Definition: tftpd.h:60
static void MDI_UpdateFrameText(HWND, HWND, BOOL, LPCWSTR)
Definition: mdi.c:1027
LRESULT WINAPI DefFrameProcW(HWND hwnd, HWND hwndMDIClient, UINT message, WPARAM wParam, LPARAM lParam)
Definition: mdi.c:1403
#define WM_NEXTMENU
Definition: winuser.h:1806
LRESULT WINAPI DefWindowProcA(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define WM_SIZE
Definition: winuser.h:1611
#define WM_COMMAND
Definition: winuser.h:1740
#define WM_SETFOCUS
Definition: winuser.h:1613
#define WM_SETTEXT
Definition: winuser.h:1617
#define WM_NCACTIVATE
Definition: winuser.h:1688
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184

◆ DefFrameProcW()

LRESULT WINAPI DefFrameProcW ( HWND  hwnd,
HWND  hwndMDIClient,
UINT  message,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 1403 of file mdi.c.

1406{
1408
1409 TRACE("%p %p %04x (%s) %08lx %08lx\n", hwnd, hwndMDIClient, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1410
1411 if (ci)
1412 {
1413 switch (message)
1414 {
1415 case WM_COMMAND:
1416 {
1417 WORD id = LOWORD(wParam);
1418 /* check for possible syscommands for maximized MDI child */
1419 if (id < ci->idFirstChild || id >= ci->idFirstChild + ci->nActiveChildren)
1420 {
1421 if( (id - 0xf000) & 0xf00f ) break;
1422 if( !ci->hwndChildMaximized ) break;
1423 switch( id )
1424 {
1425 case SC_CLOSE:
1426 if (!is_close_enabled(ci->hwndActiveChild, 0)) break;
1427 case SC_SIZE:
1428 case SC_MOVE:
1429 case SC_MINIMIZE:
1430 case SC_MAXIMIZE:
1431 case SC_NEXTWINDOW:
1432 case SC_PREVWINDOW:
1433 case SC_RESTORE:
1435 wParam, lParam);
1436 }
1437 }
1438 else
1439 {
1440 HWND childHwnd;
1441 if (id - ci->idFirstChild == MDI_MOREWINDOWSLIMIT)
1442 /* User chose "More Windows..." */
1444 else
1445 /* User chose one of the windows listed in the "Windows" menu */
1446 childHwnd = MDI_GetChildByID(hwndMDIClient, id, ci);
1447
1448 if( childHwnd )
1450 }
1451 }
1452 break;
1453
1454 case WM_NCACTIVATE:
1456 break;
1457
1458 case WM_SETTEXT:
1460 return 1; /* success. FIXME: check text length */
1461
1462 case WM_SETFOCUS:
1464 break;
1465
1466 case WM_SIZE:
1468 break;
1469
1470 case WM_NEXTMENU:
1471 {
1472 MDINEXTMENU *next_menu = (MDINEXTMENU *)lParam;
1473
1475 {
1476 /* control menu is between the frame system menu and
1477 * the first entry of menu bar */
1478// WND *wndPtr = WIN_GetPtr(hwnd);
1479
1480 if( (wParam == VK_LEFT && GetMenu(hwnd) == next_menu->hmenuIn) ||
1481 (wParam == VK_RIGHT && GetSubMenu(GetMenu(hwnd), 0) == next_menu->hmenuIn) )
1482 {
1483// WIN_ReleasePtr(wndPtr);
1484// wndPtr = WIN_GetPtr(ci->hwndActiveChild);
1485 next_menu->hmenuNext = GetSubMenu(GetMenu(ci->hwndActiveChild), 0);
1486 next_menu->hwndNext = ci->hwndActiveChild;
1487 }
1488// WIN_ReleasePtr(wndPtr);
1489 }
1490 return 0;
1491 }
1492 }
1493 }
1494
#define LOWORD(l)
Definition: pedump.c:82
HWND hwndChildMaximized
Definition: mdi.c:115
UINT idFirstChild
Definition: mdi.c:120
HWND hwndActiveChild
Definition: mdi.c:116
UINT nActiveChildren
Definition: mdi.c:114
HMENU hmenuNext
Definition: winuser.h:3636
HMENU hmenuIn
Definition: winuser.h:3635
#define HIWORD(l)
Definition: typedefs.h:247
const char * SPY_GetMsgName(UINT msg, HWND hWnd)
Definition: spy.c:2218
#define MDI_MOREWINDOWSLIMIT
Definition: mdi.c:93
static HWND MDI_GetChildByID(HWND hwnd, UINT id, MDICLIENTINFO *ci)
Definition: mdi.c:186
static MDICLIENTINFO * get_client_info(HWND client)
Definition: mdi.c:224
static HWND MDI_MoreWindowsDialog(HWND)
Definition: mdi.c:2489
static BOOL is_close_enabled(HWND hwnd, HMENU hSysMenu)
Definition: mdi.c:248
UINT_PTR WPARAM
Definition: windef.h:207
#define WM_SYSCOMMAND
Definition: winuser.h:1741
LRESULT WINAPI DefWindowProcW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define SC_PREVWINDOW
Definition: winuser.h:2591
#define WM_MDIACTIVATE
Definition: winuser.h:1814
#define SC_SIZE
Definition: winuser.h:2584
#define SC_MINIMIZE
Definition: winuser.h:2586
#define SC_NEXTWINDOW
Definition: winuser.h:2590
HMENU WINAPI GetSubMenu(_In_ HMENU, _In_ int)
HWND WINAPI SetFocus(_In_opt_ HWND)
#define SC_CLOSE
Definition: winuser.h:2592
#define SC_MOVE
Definition: winuser.h:2585
#define VK_LEFT
Definition: winuser.h:2224
#define VK_RIGHT
Definition: winuser.h:2226
#define SC_RESTORE
Definition: winuser.h:2598
BOOL WINAPI MoveWindow(_In_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ BOOL)
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
HMENU WINAPI GetMenu(_In_ HWND)
#define SC_MAXIMIZE
Definition: winuser.h:2588

Referenced by DefFrameProcA().

◆ DefMDIChildProcA()

LRESULT WINAPI DefMDIChildProcA ( HWND  hwnd,
UINT  message,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 1500 of file mdi.c.

1503{
1506
1507 TRACE("%p %04x (%s) %08lx %08lx\n", hwnd, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1508
1510 if (!ci) return DefWindowProcA( hwnd, message, wParam, lParam );
1511
1512 switch (message)
1513 {
1514 case WM_SETTEXT:
1516 if( ci->hwndChildMaximized == hwnd )
1518 MDI_RefreshMenu( ci );
1519 return 1; /* success. FIXME: check text length */
1520
1521 case WM_GETMINMAXINFO:
1522 case WM_MENUCHAR:
1523 case WM_CLOSE:
1524 case WM_SETFOCUS:
1525 case WM_CHILDACTIVATE:
1526 case WM_SYSCOMMAND:
1527 case WM_SHOWWINDOW:
1528 case WM_SETVISIBLE:
1529 case WM_SIZE:
1530 case WM_NEXTMENU:
1531 case WM_SYSCHAR:
1532 case WM_DESTROY:
1534 }
static FILE * client
Definition: client.c:41
#define WM_SETVISIBLE
Definition: undocuser.h:31
#define WIN_GetFullHandle(h)
Definition: user_x.h:108
static LRESULT MDI_RefreshMenu(MDICLIENTINFO *)
Definition: mdi.c:411
LRESULT WINAPI DefMDIChildProcW(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
Definition: mdi.c:1541
#define WM_CLOSE
Definition: winuser.h:1621
#define WM_CHILDACTIVATE
Definition: winuser.h:1638
#define WM_SHOWWINDOW
Definition: winuser.h:1628
#define WM_SYSCHAR
Definition: winuser.h:1721
#define WM_GETMINMAXINFO
Definition: winuser.h:1640
#define WM_MENUCHAR
Definition: winuser.h:1748
HWND WINAPI GetParent(_In_ HWND)
#define WM_DESTROY
Definition: winuser.h:1609

◆ DefMDIChildProcW()

LRESULT WINAPI DefMDIChildProcW ( HWND  hwnd,
UINT  message,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 1541 of file mdi.c.

1544{
1547
1548 TRACE("%p %04x (%s) %08lx %08lx\n", hwnd, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1549
1551 if (!ci) return DefWindowProcW( hwnd, message, wParam, lParam );
1552
1553 switch (message)
1554 {
1555 case WM_SETTEXT:
1557 if( ci->hwndChildMaximized == hwnd )
1559 MDI_RefreshMenu( ci );
1560 return 1; /* success. FIXME: check text length */
1561
1562 case WM_GETMINMAXINFO:
1564 return 0;
1565
1566 case WM_MENUCHAR:
1567 return MAKELRESULT( 0, MNC_CLOSE ); /* MDI children don't have menu bars */
1568
1569 case WM_CLOSE:
1571 return 0;
1572
1573 case WM_SETFOCUS:
1574 if (ci->hwndActiveChild != hwnd)
1576 break;
1577
1578 case WM_CHILDACTIVATE:
1579 if (IsWindowEnabled( hwnd ))
1581 return 0;
1582
1583 case WM_SYSCOMMAND:
1584 switch (wParam & 0xfff0)
1585 {
1586 case SC_MOVE:
1587 if( ci->hwndChildMaximized == hwnd )
1588 return 0;
1589 break;
1590 case SC_RESTORE:
1591 case SC_MINIMIZE:
1592 break;
1593 case SC_MAXIMIZE:
1594 if (ci->hwndChildMaximized == hwnd)
1596 break;
1597 case SC_NEXTWINDOW:
1599 return 0;
1600 case SC_PREVWINDOW:
1602 return 0;
1603 }
1604 break;
1605
1606 case WM_SHOWWINDOW:
1607 case WM_SETVISIBLE:
1609 /*if (ci->hwndChildMaximized) ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1610 else*/ MDI_PostUpdate(client, ci, SB_BOTH+1);
1611 break;
1612
1613 case WM_SIZE:
1614 /* This is the only place where we switch to/from maximized state */
1615 /* do not change */
1616 TRACE("current active %p, maximized %p\n", ci->hwndActiveChild, ci->hwndChildMaximized);
1617
1618 if( ci->hwndChildMaximized == hwnd && wParam != SIZE_MAXIMIZED )
1619 {
1620 HWND frame;
1621
1622 ci->hwndChildMaximized = 0;
1623
1624 frame = GetParent(client);
1625 MDI_RestoreFrameMenu( frame, hwnd, ci->hBmpClose );
1626 MDI_UpdateFrameText( frame, client, TRUE, NULL );
1627 }
1628
1629 if( wParam == SIZE_MAXIMIZED )
1630 {
1631 HWND frame, hMaxChild = ci->hwndChildMaximized;
1632
1633 if( hMaxChild == hwnd ) break;
1634
1635 if( hMaxChild)
1636 {
1637 SendMessageW( hMaxChild, WM_SETREDRAW, FALSE, 0 );
1638
1639 MDI_RestoreFrameMenu( GetParent(client), hMaxChild, ci->hBmpClose );
1640 ShowWindow( hMaxChild, SW_SHOWNOACTIVATE );
1641
1642 SendMessageW( hMaxChild, WM_SETREDRAW, TRUE, 0 );
1643 }
1644
1645 TRACE("maximizing child %p\n", hwnd );
1646
1647 /* keep track of the maximized window. */
1648 ci->hwndChildMaximized = hwnd; /* !!! */
1649
1650 frame = GetParent(client);
1651 MDI_AugmentFrameMenu( frame, hwnd );
1652 MDI_UpdateFrameText( frame, client, TRUE, NULL );
1653 }
1654
1655 if( wParam == SIZE_MINIMIZED )
1656 {
1657 HWND switchTo = MDI_GetWindow( ci, hwnd, TRUE, WS_MINIMIZE );
1658
1659 if (!switchTo) switchTo = hwnd;
1660 SendMessageW( switchTo, WM_CHILDACTIVATE, 0, 0 );
1661 }
1662
1664 break;
1665
1666 case WM_NEXTMENU:
1667 {
1668 MDINEXTMENU *next_menu = (MDINEXTMENU *)lParam;
1670
1671 if( wParam == VK_LEFT ) /* switch to frame system menu */
1672 {
1673// WND *wndPtr = WIN_GetPtr( parent );
1674 next_menu->hmenuNext = GetSubMenu( GetMenu(parent), 0 );
1675// WIN_ReleasePtr( wndPtr );
1676 }
1677 if( wParam == VK_RIGHT ) /* to frame menu bar */
1678 {
1679 next_menu->hmenuNext = GetMenu(parent);
1680 }
1681 next_menu->hwndNext = parent;
1682 return 0;
1683 }
1684
1685 case WM_SYSCHAR:
1686 if (wParam == '-')
1687 {
1689 return 0;
1690 }
1691 break;
1692
1693 case WM_DESTROY:
1694 /* Remove itself from the Window menu */
1695 MDI_RefreshMenu(ci);
1696 break;
1697 }
#define WS_MINIMIZE
Definition: pedump.c:622
HBITMAP hBmpClose
Definition: mdi.c:125
static BOOL MDI_RestoreFrameMenu(HWND, HWND, HBITMAP)
Definition: mdi.c:962
static void MDI_PostUpdate(HWND hwnd, MDICLIENTINFO *ci, WORD recalc)
Definition: mdi.c:198
static LONG MDI_ChildActivate(HWND, HWND)
Definition: mdi.c:638
static BOOL MDI_AugmentFrameMenu(HWND, HWND)
Definition: mdi.c:869
static void MDI_ChildGetMinMaxInfo(HWND client, HWND hwnd, MINMAXINFO *lpMinMax)
Definition: mdi.c:510
static HWND MDI_GetWindow(MDICLIENTINFO *clientInfo, HWND hWnd, BOOL bNext, DWORD dwStyleMask)
Definition: mdi.c:267
#define SC_KEYMENU
Definition: winuser.h:2596
#define VK_SPACE
Definition: winuser.h:2219
#define SW_SHOWNOACTIVATE
Definition: winuser.h:774
#define WM_MDINEXT
Definition: winuser.h:1816
#define SIZE_MINIMIZED
Definition: winuser.h:2506
#define MAKELRESULT(l, h)
Definition: winuser.h:4010
#define SIZE_MAXIMIZED
Definition: winuser.h:2507
#define WM_MDIDESTROY
Definition: winuser.h:1813
#define MNC_CLOSE
Definition: winuser.h:2567
#define WM_SETREDRAW
Definition: winuser.h:1616

Referenced by DefMDIChildProcA().

◆ get_client_info()

static MDICLIENTINFO * get_client_info ( HWND  client)
static

Definition at line 224 of file mdi.c.

226{
227#ifdef __REACTOS__
229#else
231 WND *win = WIN_GetPtr( client );
232 if (win)
233 {
234 if (win == WND_OTHER_PROCESS || win == WND_DESKTOP)
235 {
236 if (IsWindow(client)) WARN( "client %p belongs to other process\n", client );
237 return NULL;
238 }
239 if (win->flags & WIN_ISMDICLIENT)
240 ret = (MDICLIENTINFO *)win->wExtra;
241 else
242 WARN( "%p is not an MDI client\n", client );
243 WIN_ReleasePtr( win );
244 }
245 return ret;
246#endif
#define WARN(fmt,...)
Definition: debug.h:115
#define GWLP_MDIWND
Definition: ntuser.h:786
static real win[4][36]
Definition: ntuser.h:694
#define GetWindowLongPtr
Definition: treelist.c:73
BOOL WINAPI IsWindow(_In_opt_ HWND)

Referenced by DefFrameProcW(), DefMDIChildProcA(), DefMDIChildProcW(), MDI_CalcDefaultChildPos(), MDI_ChildActivate(), MDI_MoreWindowsDlgProc(), MDI_UpdateFrameText(), MDIClientWndProc_common(), MDISetMenu(), and TranslateMDISysAccel().

◆ GetCascadeChildProc()

static BOOL CALLBACK GetCascadeChildProc ( HWND  hwnd,
LPARAM  lParam 
)
static

Definition at line 1996 of file mdi.c.

1998{
1999 DWORD count, size;
2000 HWND *ahwnd;
2001 CASCADE_INFO *pInfo = (CASCADE_INFO *)lParam;
2002
2003 if (hwnd == pInfo->hwndDesktop || hwnd == pInfo->hTrayWnd ||
2004 hwnd == pInfo->hwndProgman || hwnd == pInfo->hwndTop)
2005 {
2006 return TRUE;
2007 }
2008
2009 if (pInfo->hwndParent && GetParent(hwnd) != pInfo->hwndParent)
2010 return TRUE;
2011
2012 if ((pInfo->wFlags & MDITILE_SKIPDISABLED) && !IsWindowEnabled(hwnd))
2013 return TRUE;
2014
2016 return TRUE;
2017
2018 count = pInfo->chwnd;
2019 size = (count + 1) * sizeof(HWND);
2020
2021 if (count == 0 || pInfo->ahwnd == NULL)
2022 {
2023 count = 0;
2024 pInfo->ahwnd = (HWND *)HeapAlloc(GetProcessHeap(), 0, size);
2025 }
2026 else
2027 {
2028 ahwnd = (HWND *)HeapReAlloc(GetProcessHeap(), 0, pInfo->ahwnd, size);
2029 if (ahwnd == NULL)
2030 {
2031 HeapFree(GetProcessHeap(), 0, pInfo->ahwnd);
2032 }
2033 pInfo->ahwnd = ahwnd;
2034 }
2035
2036 if (pInfo->ahwnd == NULL)
2037 {
2038 pInfo->chwnd = 0;
2039 return FALSE;
2040 }
2041
2042 pInfo->ahwnd[count] = hwnd;
2043 pInfo->chwnd = count + 1;
2044 return TRUE;
#define HeapReAlloc
Definition: compat.h:734
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLsizeiptr size
Definition: glext.h:5919
DWORD chwnd
Definition: mdi.c:1992
HWND hwndParent
Definition: mdi.c:1987
HWND hwndDesktop
Definition: mdi.c:1988
HWND hwndTop
Definition: mdi.c:1985
UINT wFlags
Definition: mdi.c:1986
HWND hwndProgman
Definition: mdi.c:1990
HWND hTrayWnd
Definition: mdi.c:1989
HWND * ahwnd
Definition: mdi.c:1991

Referenced by CascadeWindows(), and TileWindows().

◆ is_close_enabled()

static BOOL is_close_enabled ( HWND  hwnd,
HMENU  hSysMenu 
)
static

Definition at line 248 of file mdi.c.

250{
252
253 if (!hSysMenu) hSysMenu = GetSystemMenu(hwnd, FALSE);
254 if (hSysMenu)
255 {
257 if (state == 0xFFFFFFFF || (state & (MF_DISABLED | MF_GRAYED)))
258 return FALSE;
259 }
260 return TRUE;
static int state
Definition: maze.c:121
unsigned int UINT
Definition: ndis.h:50
#define MF_BYCOMMAND
Definition: winuser.h:202
UINT WINAPI GetMenuState(_In_ HMENU, _In_ UINT, _In_ UINT)
HMENU WINAPI GetSystemMenu(_In_ HWND, _In_ BOOL)
#define GetClassLongPtrW
Definition: winuser.h:4564
#define CS_NOCLOSE
Definition: winuser.h:654
#define GCL_STYLE
Definition: winuser.h:670
#define MF_GRAYED
Definition: winuser.h:129
#define MF_DISABLED
Definition: winuser.h:130

Referenced by DefFrameProcW(), MDI_AugmentFrameMenu(), and TranslateMDISysAccel().

◆ MDI_AugmentFrameMenu()

static BOOL MDI_AugmentFrameMenu ( HWND  frame,
HWND  hChild 
)
static

Definition at line 869 of file mdi.c.

871{
872 HMENU menu = GetMenu( frame );
873 HMENU hSysPopup;
874 HBITMAP hSysMenuBitmap = 0;
875 HICON hIcon;
876 INT nItems;
877 UINT iId;
878
879 TRACE("frame %p,child %p\n",frame,hChild);
880
881 if( !menu ) return FALSE;
883 /* if the system buttons already exist do not add them again */
884 nItems = GetMenuItemCount(menu) - 1;
885 iId = GetMenuItemID(menu,nItems) ;
886 if (iId == SC_RESTORE || iId == SC_CLOSE)
887 {
888 ERR("system buttons already exist\n");
889 return FALSE;
890 }
892 /* create a copy of sysmenu popup and insert it into frame menu bar */
893 if (!(hSysPopup = GetSystemMenu(hChild, FALSE)))
894 {
895 TRACE("child %p doesn't have a system menu\n", hChild);
896 return FALSE;
897 }
898
900 SC_CLOSE, is_close_enabled(hChild, hSysPopup) ?
906
907 /* The system menu is replaced by the child icon */
908 hIcon = (HICON)SendMessageW(hChild, WM_GETICON, ICON_SMALL, 0);
909 if (!hIcon)
911 if (!hIcon)
912 hIcon = (HICON)SendMessageW(hChild, WM_GETICON, ICON_BIG, 0);
913 if (!hIcon)
915 if (!hIcon)
918 if (hIcon)
919 {
920 HDC hMemDC;
921 HBITMAP hBitmap, hOldBitmap;
922 HDC hdc = GetDC(hChild);
923
924 if (hdc)
925 {
926 int cx, cy;
929 hMemDC = CreateCompatibleDC(hdc);
931 hOldBitmap = SelectObject(hMemDC, hBitmap);
932 SetMapMode(hMemDC, MM_TEXT);
934 SelectObject (hMemDC, hOldBitmap);
935 DeleteDC(hMemDC);
937 hSysMenuBitmap = hBitmap;
938 }
939 }
940
942 (UINT_PTR)hSysPopup, (LPSTR)hSysMenuBitmap))
943 {
944 TRACE("not inserted\n");
945 DestroyMenu(hSysPopup);
946 return FALSE;
947 }
948
952 SetMenuDefaultItem(hSysPopup, SC_CLOSE, FALSE);
953
954 /* redraw menu */
955 DrawMenuBar(frame);
956
957 return TRUE;
int nItems
Definition: appswitch.c:56
static HBITMAP hBitmap
Definition: timezone.c:26
HDC hdc
Definition: main.c:9
static HICON
Definition: imagelist.c:84
static HTREEITEM hChild
Definition: treeview.c:381
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
HICON hIcon
Definition: msconfig.c:44
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
#define ICON_BIG
Definition: tnclass.cpp:51
#define ICON_SMALL
Definition: tnclass.cpp:48
int WINAPI SetMapMode(_In_ HDC, _In_ int)
#define DI_NORMAL
Definition: wingdi.h:72
#define MM_TEXT
Definition: wingdi.h:873
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
#define GCLP_HICONSM
Definition: winuser.h:675
#define HBMMENU_MBAR_RESTORE
Definition: winuser.h:2632
#define COLOR_MENU
Definition: winuser.h:917
BOOL WINAPI SetMenuDefaultItem(_In_ HMENU, _In_ UINT, _In_ UINT)
int WINAPI GetMenuItemCount(_In_opt_ HMENU)
#define IMAGE_ICON
Definition: winuser.h:212
#define GCLP_HICON
Definition: winuser.h:674
#define HBMMENU_MBAR_MINIMIZE
Definition: winuser.h:2633
HBRUSH WINAPI GetSysColorBrush(_In_ int)
HANDLE WINAPI LoadImageW(_In_opt_ HINSTANCE hInst, _In_ LPCWSTR name, _In_ UINT type, _In_ int cx, _In_ int cy, _In_ UINT fuLoad)
Definition: cursoricon.c:2234
#define SM_CYSMICON
Definition: winuser.h:1013
UINT WINAPI GetMenuItemID(_In_ HMENU, _In_ int)
BOOL WINAPI InsertMenuA(_In_ HMENU, _In_ UINT, _In_ UINT, _In_ UINT_PTR, _In_opt_ LPCSTR)
#define MF_POPUP
Definition: winuser.h:136
#define IDI_WINLOGO
Definition: winuser.h:709
#define SM_CXSMICON
Definition: winuser.h:1012
BOOL WINAPI DrawMenuBar(_In_ HWND)
#define MF_BYPOSITION
Definition: winuser.h:203
BOOL WINAPI DrawIconEx(_In_ HDC, _In_ int, _In_ int, _In_ HICON, _In_ int, _In_ int, _In_ UINT, _In_opt_ HBRUSH, _In_ UINT)
Definition: cursoricon.c:2059
HDC WINAPI GetDC(_In_opt_ HWND)
#define MF_BITMAP
Definition: winuser.h:131
#define HBMMENU_MBAR_CLOSE
Definition: winuser.h:2634
BOOL WINAPI DestroyMenu(_In_ HMENU)
#define LR_DEFAULTCOLOR
Definition: winuser.h:1087
#define HBMMENU_MBAR_CLOSE_D
Definition: winuser.h:2635
#define MF_HELP
Definition: winuser.h:142
BOOL WINAPI EnableMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
BOOL WINAPI AppendMenuW(_In_ HMENU, _In_ UINT, _In_ UINT_PTR, _In_opt_ LPCWSTR)
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by DefMDIChildProcW(), and MDISetMenu().

◆ MDI_CalcDefaultChildPos()

void MDI_CalcDefaultChildPos ( HWND  hwndClient,
INT  total,
LPPOINT  lpPos,
INT  delta,
UINT id 
)

Definition at line 308 of file mdi.c.

310{
311 INT nstagger;
312 RECT rect;
314
315 if (total < 0) /* we are called from CreateWindow */
316 {
317 MDICLIENTINFO *ci = get_client_info(hwndClient);
318 total = ci ? ci->nTotalCreated : 0; // Do not portsync wine
319 *id = ci ? ci->idFirstChild + ci->nActiveChildren : 0; // Do not portsync wine
320 TRACE("MDI child id %04x\n", *id);
321 }
322
323 GetClientRect( hwndClient, &rect );
324 if( rect.bottom - rect.top - delta >= spacing )
325 rect.bottom -= delta;
326
327 nstagger = (rect.bottom - rect.top)/(3 * spacing);
328 lpPos[1].x = (rect.right - rect.left - nstagger * spacing);
329 lpPos[1].y = (rect.bottom - rect.top - nstagger * spacing);
330 lpPos[0].x = lpPos[0].y = spacing * (total%(nstagger+1));
size_t total
UINT nTotalCreated
Definition: mdi.c:122
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
#define SM_CYFRAME
Definition: winuser.h:996
#define SM_CYCAPTION
Definition: winuser.h:963

Referenced by CreateWindowExA(), CreateWindowExW(), and MDICascade().

◆ MDI_ChildActivate()

static LONG MDI_ChildActivate ( HWND  client,
HWND  child 
)
static

Definition at line 638 of file mdi.c.

640{
641 MDICLIENTINFO *clientInfo;
642 HWND prevActiveWnd, frame;
643 BOOL isActiveFrameWnd;
644
645 clientInfo = get_client_info( client );
646
647 if (clientInfo->hwndActiveChild == child) return 0;
648
649 TRACE("%p\n", child);
650
651 frame = GetParent(client);
652 isActiveFrameWnd = (GetActiveWindow() == frame);
653 prevActiveWnd = clientInfo->hwndActiveChild;
654
655 /* deactivate prev. active child */
656 if(prevActiveWnd)
657 {
658 SendMessageW( prevActiveWnd, WM_NCACTIVATE, FALSE, 0L );
659 SendMessageW( prevActiveWnd, WM_MDIACTIVATE, (WPARAM)prevActiveWnd, (LPARAM)child);
660 }
661
662 MDI_SwitchActiveChild( clientInfo, child, FALSE );
663 clientInfo->hwndActiveChild = child;
664
665 MDI_RefreshMenu(clientInfo);
666
667 if( isActiveFrameWnd )
668 {
670 /* Let the client window manage focus for children, but if the focus
671 * is already on the client (for instance this is the 1st child) then
672 * SetFocus won't work. It appears that Windows sends WM_SETFOCUS
673 * manually in this case.
674 */
675 if (SetFocus(client) == client)
677 }
678
679 SendMessageW( child, WM_MDIACTIVATE, (WPARAM)prevActiveWnd, (LPARAM)child );
680 return TRUE;
unsigned int BOOL
Definition: ntddk_ex.h:94
static HWND child
Definition: cursoricon.c:298
static void MDI_SwitchActiveChild(MDICLIENTINFO *ci, HWND hwndTo, BOOL activate)
Definition: mdi.c:533
HWND WINAPI GetActiveWindow(void)
Definition: winpos.c:138

Referenced by DefMDIChildProcW(), and MDIDestroyChild().

◆ MDI_ChildGetMinMaxInfo()

static void MDI_ChildGetMinMaxInfo ( HWND  client,
HWND  hwnd,
MINMAXINFO lpMinMax 
)
static

Definition at line 510 of file mdi.c.

512{
513 RECT rect;
514
518
519 lpMinMax->ptMaxSize.x = rect.right -= rect.left;
520 lpMinMax->ptMaxSize.y = rect.bottom -= rect.top;
521
522 lpMinMax->ptMaxPosition.x = rect.left;
523 lpMinMax->ptMaxPosition.y = rect.top;
524
525 TRACE("max rect %s\n", wine_dbgstr_rect(&rect));
static const char * wine_dbgstr_rect(const RECT *prc)
Definition: atltest.h:160
POINT ptMaxPosition
Definition: winuser.h:3629
POINT ptMaxSize
Definition: winuser.h:3628
BOOL WINAPI AdjustWindowRectEx(_Inout_ LPRECT, _In_ DWORD, _In_ BOOL, _In_ DWORD)
#define GWL_EXSTYLE
Definition: winuser.h:851

Referenced by DefMDIChildProcW().

◆ MDI_GetChildByID()

static HWND MDI_GetChildByID ( HWND  hwnd,
UINT  id,
MDICLIENTINFO ci 
)
static

Definition at line 186 of file mdi.c.

188{
189 int i;
190
191 for (i = 0; ci->nActiveChildren; i++)
192 {
193 if (GetWindowLongPtrW( ci->child[i], GWLP_ID ) == id)
194 return ci->child[i];
195 }
196 return 0;
HWND * child
Definition: mdi.c:117
#define GWLP_ID
Definition: winuser.h:860

Referenced by DefFrameProcW().

◆ MDI_GetWindow()

static HWND MDI_GetWindow ( MDICLIENTINFO clientInfo,
HWND  hWnd,
BOOL  bNext,
DWORD  dwStyleMask 
)
static

Definition at line 267 of file mdi.c.

270{
271 int i;
272 HWND *list;
273 HWND last = 0;
274
275 dwStyleMask |= WS_DISABLED | WS_VISIBLE;
276 if( !hWnd ) hWnd = clientInfo->hwndActiveChild;
277
278 if (!(list = WIN_ListChildren( GetParent(hWnd) ))) return 0;
279 i = 0;
280 /* start from next after hWnd */
281 while (list[i] && list[i] != hWnd) i++;
282 if (list[i]) i++;
283
284 for ( ; list[i]; i++)
285 {
286 if (GetWindow( list[i], GW_OWNER )) continue;
287 if ((GetWindowLongPtrW( list[i], GWL_STYLE ) & dwStyleMask) != WS_VISIBLE) continue;
288 last = list[i];
289 if (bNext) goto found;
290 }
291 /* now restart from the beginning */
292 for (i = 0; list[i] && list[i] != hWnd; i++)
293 {
294 if (GetWindow( list[i], GW_OWNER )) continue;
295 if ((GetWindowLongPtrW( list[i], GWL_STYLE ) & dwStyleMask) != WS_VISIBLE) continue;
296 last = list[i];
297 if (bNext) goto found;
298 }
299 found:
301 return last;
HWND hWnd
Definition: settings.c:17
static UINT UINT last
Definition: font.c:45
#define WS_DISABLED
Definition: pedump.c:621
#define GW_OWNER
Definition: winuser.h:766
HWND WINAPI GetWindow(_In_ HWND, _In_ UINT)

Referenced by DefMDIChildProcW(), MDIClientWndProc_common(), and MDIDestroyChild().

◆ MDI_MoreWindowsDialog()

static HWND MDI_MoreWindowsDialog ( HWND  hwnd)
static

Definition at line 2489 of file mdi.c.

2491{
2492 LPCVOID template;
2493 HRSRC hRes;
2494 HANDLE hDlgTmpl;
2495
2496 hRes = FindResourceA(User32Instance, "MDI_MOREWINDOWS", (LPSTR)RT_DIALOG);
2497
2498 if (hRes == 0)
2499 return 0;
2500
2501 hDlgTmpl = LoadResource(User32Instance, hRes );
2502
2503 if (hDlgTmpl == 0)
2504 return 0;
2505
2506 template = LockResource( hDlgTmpl );
2507
2508 if (template == 0)
2509 return 0;
2510
2511 return (HWND) DialogBoxIndirectParamA(User32Instance, template, hwnd,
HRSRC WINAPI FindResourceA(HMODULE hModule, LPCSTR name, LPCSTR type)
Definition: res.c:155
LPVOID WINAPI LockResource(HGLOBAL handle)
Definition: res.c:550
HGLOBAL WINAPI LoadResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:532
#define RT_DIALOG
Definition: pedump.c:367
HINSTANCE User32Instance
Definition: dllmain.c:27
static INT_PTR WINAPI MDI_MoreWindowsDlgProc(HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
Definition: mdi.c:2420
CONST void * LPCVOID
Definition: windef.h:191
INT_PTR WINAPI DialogBoxIndirectParamA(_In_opt_ HINSTANCE, _In_ LPCDLGTEMPLATE, _In_opt_ HWND, _In_opt_ DLGPROC, _In_ LPARAM)

Referenced by DefFrameProcW().

◆ MDI_MoreWindowsDlgProc()

static INT_PTR WINAPI MDI_MoreWindowsDlgProc ( HWND  hDlg,
UINT  iMsg,
WPARAM  wParam,
LPARAM  lParam 
)
static

Definition at line 2420 of file mdi.c.

2422{
2423 switch (iMsg)
2424 {
2425 case WM_INITDIALOG:
2426 {
2427 UINT widest = 0;
2428 UINT length;
2429 UINT i;
2432
2433 for (i = 0; i < ci->nActiveChildren; i++)
2434 {
2436
2437 if (!InternalGetWindowText( ci->child[i], buffer, sizeof(buffer)/sizeof(WCHAR) ))
2438 continue;
2441 length = strlenW(buffer); /* FIXME: should use GetTextExtentPoint */
2442 if (length > widest)
2443 widest = length;
2444 }
2445 /* Make sure the horizontal scrollbar scrolls ok */
2447
2448 /* Set the current selection */
2450 return TRUE;
2451 }
2452
2453 case WM_COMMAND:
2454 switch (LOWORD(wParam))
2455 {
2456 default:
2457 if (HIWORD(wParam) != LBN_DBLCLK) break;
2458 /* fall through */
2459 case IDOK:
2460 {
2461 /* windows are sorted by menu ID, so we must return the
2462 * window associated to the given id
2463 */
2467 EndDialog(hDlg, res);
2468 return TRUE;
2469 }
2470 case IDCANCEL:
2471 EndDialog(hDlg, 0);
2472 return TRUE;
2473 }
2474 break;
2475 }
2476 return FALSE;
HWND hListBox
Definition: enumfonts.cpp:27
GLuint res
Definition: glext.h:9613
GLuint buffer
Definition: glext.h:5915
GLuint index
Definition: glext.h:6031
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
#define strlenW(s)
Definition: unicode.h:34
#define MDI_IDC_LISTBOX
Definition: mdi.c:94
#define MDI_MAXTITLELENGTH
Definition: mdi.c:88
LONG_PTR LRESULT
Definition: windef.h:209
#define LB_GETITEMDATA
Definition: winuser.h:2041
#define LB_SETHORIZONTALEXTENT
Definition: winuser.h:2064
#define IDCANCEL
Definition: winuser.h:831
#define LBN_DBLCLK
Definition: winuser.h:2071
#define WM_INITDIALOG
Definition: winuser.h:1739
#define LB_ADDSTRING
Definition: winuser.h:2031
HWND WINAPI GetDlgItem(_In_opt_ HWND, _In_ int)
#define IDOK
Definition: winuser.h:830
#define LB_SETITEMDATA
Definition: winuser.h:2065
#define LB_SETCURSEL
Definition: winuser.h:2063
#define LB_GETCURSEL
Definition: winuser.h:2039
INT WINAPI InternalGetWindowText(_In_ HWND hWnd, _Out_writes_to_(cchMaxCount, return+1) LPWSTR pString, _In_ int cchMaxCount)
BOOL WINAPI EndDialog(_In_ HWND, _In_ INT_PTR)

Referenced by MDI_MoreWindowsDialog().

◆ MDI_PostUpdate()

static void MDI_PostUpdate ( HWND  hwnd,
MDICLIENTINFO ci,
WORD  recalc 
)
static

Definition at line 198 of file mdi.c.

200{
201 if( !(ci->mdiFlags & MDIF_NEEDUPDATE) )
202 {
205 }
206 ci->sbRecalc = recalc;
UINT mdiFlags
Definition: mdi.c:123
UINT sbRecalc
Definition: mdi.c:124
#define MDIF_NEEDUPDATE
Definition: mdi.c:97
#define WM_MDICALCCHILDSCROLL
Definition: mdi.c:90
BOOL WINAPI PostMessageA(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

Referenced by DefMDIChildProcW(), MDIClientWndProc_common(), and MDIDestroyChild().

◆ MDI_RefreshMenu()

static LRESULT MDI_RefreshMenu ( MDICLIENTINFO ci)
static

Definition at line 411 of file mdi.c.

413{
414 UINT i, count, visible, id;
416
417 TRACE("children %u, window menu %p\n", ci->nActiveChildren, ci->hWindowMenu);
418
419 if (!ci->hWindowMenu)
420 return 0;
421
422 if (!IsMenu(ci->hWindowMenu))
423 {
424 WARN("Window menu handle %p is no longer valid\n", ci->hWindowMenu);
425 return 0;
426 }
427
428 /* Windows finds the last separator in the menu, and if after it
429 * there is a menu item with MDI magic ID removes all existing
430 * menu items after it, and then adds visible MDI children.
431 */
433 for (i = 0; i < count; i++)
434 {
435 MENUITEMINFOW mii;
436
437 memset(&mii, 0, sizeof(mii));
438 mii.cbSize = sizeof(mii);
439 mii.fMask = MIIM_TYPE;
440 if (GetMenuItemInfoW(ci->hWindowMenu, i, TRUE, &mii))
441 {
442 if (mii.fType & MF_SEPARATOR)
443 {
444 /* Windows checks only ID of the menu item */
445 memset(&mii, 0, sizeof(mii));
446 mii.cbSize = sizeof(mii);
447 mii.fMask = MIIM_ID;
448 if (GetMenuItemInfoW(ci->hWindowMenu, i + 1, TRUE, &mii))
449 {
450 if (mii.wID == ci->idFirstChild)
451 {
452 TRACE("removing %u items including separator\n", count - i);
454 /* nothing */;
455
456 break;
457 }
458 }
459 }
460 }
461 }
462
463 visible = 0;
464 for (i = 0; i < ci->nActiveChildren; i++)
465 {
467 {
468 id = ci->idFirstChild + visible;
469
470 if (visible == MDI_MOREWINDOWSLIMIT)
471 {
474 break;
475 }
476
477 if (!visible)
478 /* Visio expects that separator has id 0 */
480
481 visible++;
482
483 SetWindowLongPtrW(ci->child[i], GWLP_ID, id);
484
485 buf[0] = '&';
486 buf[1] = '0' + visible;
487 buf[2] = ' ';
488 InternalGetWindowText(ci->child[i], buf + 3, sizeof(buf)/sizeof(WCHAR) - 3);
489 TRACE("Adding %p, id %u %s\n", ci->child[i], id, debugstr_w(buf));
491
492 if (ci->child[i] == ci->hwndActiveChild)
494 }
495 else
496 TRACE("MDI child %p is not visible, skipping\n", ci->child[i]);
497 }
498
499 return (LRESULT)ci->hFrameMenu;
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLuint id
Definition: glext.h:5910
#define memset(x, y, z)
Definition: compat.h:39
HMENU hWindowMenu
Definition: mdi.c:119
HMENU hFrameMenu
Definition: mdi.c:118
#define IDS_MDI_MOREWINDOWS
Definition: mdi.c:95
#define MIIM_ID
Definition: winuser.h:722
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
#define MF_STRING
Definition: winuser.h:138
#define MF_CHECKED
Definition: winuser.h:132
BOOL WINAPI IsMenu(_In_ HMENU)
DWORD WINAPI CheckMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
#define MF_SEPARATOR
Definition: winuser.h:137
BOOL WINAPI RemoveMenu(_In_ HMENU, _In_ UINT, _In_ UINT)
BOOL WINAPI GetMenuItemInfoW(_In_ HMENU, _In_ UINT, _In_ BOOL, _Inout_ LPMENUITEMINFOW)
#define SetWindowLongPtrW
Definition: winuser.h:5346
#define MIIM_TYPE
Definition: winuser.h:725

Referenced by DefMDIChildProcA(), DefMDIChildProcW(), MDI_ChildActivate(), MDIClientWndProc_common(), and MDISetMenu().

◆ MDI_RestoreFrameMenu()

static BOOL MDI_RestoreFrameMenu ( HWND  frame,
HWND  hChild,
HBITMAP  hBmpClose 
)
static

Definition at line 962 of file mdi.c.

964{
965 MENUITEMINFOW menuInfo;
966 HMENU menu = GetMenu( frame );
967 INT nItems;
968 UINT iId;
969
970 TRACE("frame %p,child %p\n",frame, hChild);
971
972 if (!menu) return FALSE;
973
974 /* if there is no system buttons then nothing to do */
975 nItems = GetMenuItemCount(menu) - 1;
976 iId = GetMenuItemID(menu, nItems);
977 if ( !(iId == SC_RESTORE || iId == SC_CLOSE) )
978 {
979 ERR("no system buttons then nothing to do\n");
980 return FALSE;
981 }
982
983 /*
984 * Remove the system menu, If that menu is the icon of the window
985 * as it is in win95, we have to delete the bitmap.
986 */
987 memset(&menuInfo, 0, sizeof(menuInfo));
988 menuInfo.cbSize = sizeof(menuInfo);
989 menuInfo.fMask = MIIM_DATA | MIIM_TYPE | MIIM_BITMAP;
990
991 GetMenuItemInfoW(menu,
992 0,
993 TRUE,
994 &menuInfo);
995
997
998 if ( (menuInfo.fType & MFT_BITMAP) &&
999 (menuInfo.dwTypeData != 0) &&
1000 (menuInfo.dwTypeData != (LPWSTR)hBmpClose) )
1001 {
1002 DeleteObject(menuInfo.dwTypeData);
1003 }
1004
1005 if ( menuInfo.hbmpItem != 0 )
1006 DeleteObject(menuInfo.hbmpItem);
1007
1008 /* close */
1010 /* restore */
1012 /* minimize */
1014
1015 DrawMenuBar(frame);
1016
1017 return TRUE;
LPWSTR dwTypeData
Definition: winuser.h:3269
BOOL WINAPI DeleteMenu(_In_ HMENU, _In_ UINT, _In_ UINT)
#define MIIM_BITMAP
Definition: winuser.h:728
#define MFT_BITMAP
Definition: winuser.h:738
#define MIIM_DATA
Definition: winuser.h:726

Referenced by DefMDIChildProcW(), MDIClientWndProc_common(), MDIDestroyChild(), and MDISetMenu().

◆ MDI_SwitchActiveChild()

static void MDI_SwitchActiveChild ( MDICLIENTINFO ci,
HWND  hwndTo,
BOOL  activate 
)
static

Definition at line 533 of file mdi.c.

535{
536 HWND hwndPrev;
537
538 hwndPrev = ci->hwndActiveChild;
539
540 TRACE("from %p, to %p\n", hwndPrev, hwndTo);
541
542 if ( hwndTo != hwndPrev )
543 {
544 BOOL was_zoomed = IsZoomed(hwndPrev);
545
546 if (was_zoomed)
547 {
548 /* restore old MDI child */
549 SendMessageW( hwndPrev, WM_SETREDRAW, FALSE, 0 );
550 ShowWindow( hwndPrev, SW_RESTORE );
551 SendMessageW( hwndPrev, WM_SETREDRAW, TRUE, 0 );
552
553 /* activate new MDI child */
554 SetWindowPos( hwndTo, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE );
555 /* maximize new MDI child */
556 ShowWindow( hwndTo, SW_MAXIMIZE );
557 }
558 /* activate new MDI child */
559 SetWindowPos( hwndTo, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | (activate ? 0 : SWP_NOACTIVATE) );
560 }
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
#define SWP_NOMOVE
Definition: winuser.h:1244
#define SWP_NOSIZE
Definition: winuser.h:1245
#define SW_MAXIMIZE
Definition: winuser.h:772

Referenced by MDI_ChildActivate(), MDIClientWndProc_common(), and MDIDestroyChild().

◆ MDI_UpdateFrameText()

static void MDI_UpdateFrameText ( HWND  frame,
HWND  hClient,
BOOL  repaint,
LPCWSTR  lpTitle 
)
static

Definition at line 1027 of file mdi.c.

1029{
1031 MDICLIENTINFO *ci = get_client_info( hClient );
1032
1033 TRACE("frameText %s\n", debugstr_w(lpTitle));
1034
1035 if (!ci) return;
1036
1037 if (!lpTitle && !ci->frameTitle) /* first time around, get title from the frame window */
1038 {
1039 GetWindowTextW( frame, lpBuffer, sizeof(lpBuffer)/sizeof(WCHAR) );
1040 lpTitle = lpBuffer;
1041 }
1042
1043 /* store new "default" title if lpTitle is not NULL */
1044 if (lpTitle)
1045 {
1046 HeapFree( GetProcessHeap(), 0, ci->frameTitle );
1047 if ((ci->frameTitle = HeapAlloc( GetProcessHeap(), 0, (strlenW(lpTitle)+1)*sizeof(WCHAR))))
1048 strcpyW( ci->frameTitle, lpTitle );
1049 }
1050
1051 if (ci->frameTitle)
1052 {
1053 if (ci->hwndChildMaximized)
1054 {
1055 /* combine frame title and child title if possible */
1056
1057 static const WCHAR lpBracket[] = {' ','-',' ','[',0};
1058 static const WCHAR lpBracket2[] = {']',0};
1059 int i_frame_text_length = strlenW(ci->frameTitle);
1060
1062
1063 if( i_frame_text_length + 6 < MDI_MAXTITLELENGTH )
1064 {
1065 strcatW( lpBuffer, lpBracket );
1066 if (GetWindowTextW( ci->hwndActiveChild, lpBuffer + i_frame_text_length + 4,
1067 MDI_MAXTITLELENGTH - i_frame_text_length - 5 ))
1068 strcatW( lpBuffer, lpBracket2 );
1069 else
1070 lpBuffer[i_frame_text_length] = 0; /* remove bracket */
1071 }
1072 }
1073 else
1074 {
1076 }
1077 }
1078 else
1079 lpBuffer[0] = '\0';
1080
1082
1083 if (repaint)
1084 {
1086 SetWindowPos( frame, 0,0,0,0,0, SWP_FRAMECHANGED |
1088 }
TCHAR lpTitle[80]
Definition: ctm.c:69
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
#define DC_ACTIVE
Definition: dc21x4.h:120
#define lstrcpynW
Definition: compat.h:738
DWORD_PTR NTAPI NtUserCallTwoParam(DWORD_PTR Param1, DWORD_PTR Param2, DWORD Routine)
Definition: simplecall.c:434
@ TWOPARAM_ROUTINE_REDRAWTITLE
Definition: ntuser.h:1640
#define strcatW(d, s)
Definition: unicode.h:36
#define strcpyW(d, s)
Definition: unicode.h:35
LPWSTR frameTitle
Definition: mdi.c:121
uint32_t DWORD_PTR
Definition: typedefs.h:65
int WINAPI GetWindowTextW(HWND hWnd, LPWSTR lpString, int nMaxCount)
Definition: window.c:1412
#define SWP_FRAMECHANGED
Definition: winuser.h:1240
#define SWP_NOZORDER
Definition: winuser.h:1247

Referenced by DefFrameProcA(), DefFrameProcW(), DefMDIChildProcA(), DefMDIChildProcW(), and MDIDestroyChild().

◆ MDICascade()

static LONG MDICascade ( HWND  client,
MDICLIENTINFO ci 
)
static

Definition at line 721 of file mdi.c.

723{
724 HWND *win_array;
725 BOOL has_icons = FALSE;
726 int i, total;
727
728 if (ci->hwndChildMaximized)
730
731 if (ci->nActiveChildren == 0) return 0;
732
733 if (!(win_array = WIN_ListChildren( client ))) return 0;
734
735 /* remove all the windows we don't want */
736 for (i = total = 0; win_array[i]; i++)
737 {
738 if (!IsWindowVisible( win_array[i] )) continue;
739 if (GetWindow( win_array[i], GW_OWNER )) continue; /* skip owned windows */
740 if (IsIconic( win_array[i] ))
741 {
742 has_icons = TRUE;
743 continue;
744 }
745 win_array[total++] = win_array[i];
746 }
747 win_array[total] = 0;
748
749 if (total)
750 {
751 INT delta = 0, n = 0, i;
752 POINT pos[2];
754
755 /* walk the list (backwards) and move windows */
756 for (i = total - 1; i >= 0; i--)
757 {
758 LONG style;
760
762 TRACE("move %p to (%ld,%ld) size [%ld,%ld]\n",
763 win_array[i], pos[0].x, pos[0].y, pos[1].x, pos[1].y);
764 style = GetWindowLongW(win_array[i], GWL_STYLE);
765
766 if (!(style & WS_SIZEBOX)) posOptions |= SWP_NOSIZE;
767 SetWindowPos( win_array[i], 0, pos[0].x, pos[0].y, pos[1].x, pos[1].y,
768 posOptions);
769 }
770 }
771 HeapFree( GetProcessHeap(), 0, win_array );
772
773 if (has_icons) ArrangeIconicWindows( client );
774 return 0;
GLdouble n
Definition: glext.h:7729
#define WS_SIZEBOX
Definition: pedump.c:642
long LONG
Definition: pedump.c:60
void MDI_CalcDefaultChildPos(HWND hwndClient, INT total, LPPOINT lpPos, INT delta, UINT *id)
Definition: mdi.c:308
UINT WINAPI ArrangeIconicWindows(_In_ HWND)
#define SWP_DRAWFRAME
Definition: winuser.h:1239
#define SM_CYICONSPACING
Definition: winuser.h:1002
#define SM_CYICON
Definition: winuser.h:973
#define WM_MDIRESTORE
Definition: winuser.h:1815

Referenced by MDIClientWndProc_common().

◆ MDIClientWndProc_common()

LRESULT WINAPI MDIClientWndProc_common ( HWND  hwnd,
UINT  message,
WPARAM  wParam,
LPARAM  lParam,
BOOL  unicode 
)

Definition at line 1097 of file mdi.c.

1099{
1100 MDICLIENTINFO *ci = NULL;
1101
1102 TRACE("%p %04x (%s) %08lx %08lx\n", hwnd, message, SPY_GetMsgName(message, hwnd), wParam, lParam);
1103
1104 if (!(ci = get_client_info( hwnd )))
1105 {
1106#ifdef __REACTOS__
1107 if (message == WM_NCCREATE)
1108 {
1109 if (!(ci = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ci))))
1110 return FALSE;
1112 ci->hBmpClose = 0;
1113 NtUserSetWindowFNID( hwnd, FNID_MDICLIENT); // wine uses WIN_ISMDICLIENT
1114 }
1115#else
1116 if (message == WM_NCCREATE) win_set_flags( hwnd, WIN_ISMDICLIENT, 0 );
1117#endif
1118 return unicode ? DefWindowProcW( hwnd, message, wParam, lParam ) :
1120 }
1121
1122 switch (message)
1123 {
1124 case WM_CREATE:
1125 {
1126 /* Since we are using only cs->lpCreateParams, we can safely
1127 * cast to LPCREATESTRUCTA here */
1129 LPCLIENTCREATESTRUCT ccs = (LPCLIENTCREATESTRUCT)cs->lpCreateParams;
1130
1131 ci->hWindowMenu = ccs->hWindowMenu;
1132 ci->idFirstChild = ccs->idFirstChild;
1133 ci->hwndChildMaximized = 0;
1134 ci->child = NULL;
1135 ci->nActiveChildren = 0;
1136 ci->nTotalCreated = 0;
1137 ci->frameTitle = NULL;
1138 ci->mdiFlags = 0;
1139 ci->hFrameMenu = GetMenu(cs->hwndParent);
1140
1141 if (!ci->hBmpClose) ci->hBmpClose = CreateMDIMenuBitmap();
1142
1143 TRACE("Client created: hwnd %p, Window menu %p, idFirst = %04x\n",
1144 hwnd, ci->hWindowMenu, ci->idFirstChild );
1145 return 0;
1146 }
1147
1148 case WM_DESTROY:
1149 {
1150 if( ci->hwndChildMaximized )
1152
1153 ci->nActiveChildren = 0;
1154 MDI_RefreshMenu(ci);
1155
1156 HeapFree( GetProcessHeap(), 0, ci->child );
1157 HeapFree( GetProcessHeap(), 0, ci->frameTitle );
1158#ifdef __REACTOS__
1159 HeapFree( GetProcessHeap(), 0, ci );
1161#endif
1162 return 0;
1163 }
1164
1165#ifdef __REACTOS__
1166 case WM_NCDESTROY:
1167 {
1169 return 0;
1170 }
1171#endif
1172
1173 case WM_MDIACTIVATE:
1174 {
1175 if( ci->hwndActiveChild != (HWND)wParam )
1177 return 0;
1178 }
1179
1180 case WM_MDICASCADE:
1181 return MDICascade(hwnd, ci);
1182
1183 case WM_MDICREATE:
1184 if (lParam)
1185 {
1186 HWND child;
1187
1188 if (unicode)
1189 {
1192 csW->szTitle, csW->style,
1193 csW->x, csW->y, csW->cx, csW->cy,
1194 hwnd, 0, csW->hOwner,
1195 (LPVOID)csW->lParam);
1196 }
1197 else
1198 {
1201 csA->szTitle, csA->style,
1202 csA->x, csA->y, csA->cx, csA->cy,
1203 hwnd, 0, csA->hOwner,
1204 (LPVOID)csA->lParam);
1205 }
1206 return (LRESULT)child;
1207 }
1208 return 0;
1209
1210 case WM_MDIDESTROY:
1211 return MDIDestroyChild( hwnd, ci, (HWND)wParam, TRUE );
1212
1213 case WM_MDIGETACTIVE:
1214 if (lParam) *(BOOL *)lParam = IsZoomed(ci->hwndActiveChild);
1215 return (LRESULT)ci->hwndActiveChild;
1216
1217 case WM_MDIICONARRANGE:
1220 ci->sbRecalc = SB_BOTH+1;
1221#ifdef __REACTOS__
1223#else
1225#endif
1226 return 0;
1227
1228 case WM_MDIMAXIMIZE:
1230 return 0;
1231
1232 case WM_MDINEXT: /* lParam != 0 means previous window */
1233 {
1234 HWND hwnd = wParam ? WIN_GetFullHandle((HWND)wParam) : ci->hwndActiveChild;
1235 HWND next = MDI_GetWindow( ci, hwnd, !lParam, 0 );
1237 if(!lParam)
1239 break;
1240 }
1241
1242 case WM_MDIRESTORE:
1244 return 0;
1245
1246 case WM_MDISETMENU:
1247 return MDISetMenu( hwnd, (HMENU)wParam, (HMENU)lParam );
1248
1249 case WM_MDIREFRESHMENU:
1250 return MDI_RefreshMenu( ci );
1251
1252 case WM_MDITILE:
1255 MDITile( hwnd, ci, wParam );
1256 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1257 return 0;
1258
1259 case WM_VSCROLL:
1260 case WM_HSCROLL:
1263 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1264 return 0;
1265
1266 case WM_SETFOCUS:
1267 if (ci->hwndActiveChild && !IsIconic( ci->hwndActiveChild ))
1269 return 0;
1270
1271 case WM_NCACTIVATE:
1272 if( ci->hwndActiveChild )
1274 break;
1275
1276 case WM_PARENTNOTIFY:
1277 switch (LOWORD(wParam))
1278 {
1279 case WM_CREATE:
1281 {
1282 // ReactOS See rev 33503
1283 if (!ci->child)
1284 ci->child = HeapAlloc(GetProcessHeap(), 0, sizeof(HWND));
1285 else
1286 ci->child = HeapReAlloc(GetProcessHeap(), 0, ci->child, sizeof(HWND) * (ci->nActiveChildren + 1));
1287
1288 TRACE("Adding MDI child %p, # of children %d\n",
1290
1291 if (ci->child != NULL)
1292 {
1293 ci->child[ci->nActiveChildren] = (HWND)lParam;
1294 ci->nTotalCreated++;
1295 ci->nActiveChildren++;
1296 }
1297 }
1298 break;
1299
1300 case WM_LBUTTONDOWN:
1301 {
1302 HWND child;
1303 POINT pt;
1304 pt.x = (short)LOWORD(lParam);
1305 pt.y = (short)HIWORD(lParam);
1307
1308 TRACE("notification from %p (%li,%li)\n",child,pt.x,pt.y);
1309
1310 if( child && child != hwnd && child != ci->hwndActiveChild )
1311 SetWindowPos(child, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
1312 break;
1313 }
1314
1315 case WM_DESTROY:
1317 }
1318 return 0;
1319
1320 case WM_SIZE:
1321 if( ci->hwndActiveChild && IsZoomed(ci->hwndActiveChild) )
1322 {
1323 RECT rect;
1324
1325 SetRect(&rect, 0, 0, LOWORD(lParam), HIWORD(lParam));
1328 MoveWindow(ci->hwndActiveChild, rect.left, rect.top,
1329 rect.right - rect.left, rect.bottom - rect.top, 1);
1330 }
1331 else
1332 MDI_PostUpdate(hwnd, ci, SB_BOTH+1);
1333
1334 break;
1335
1337 if( (ci->mdiFlags & MDIF_NEEDUPDATE) && ci->sbRecalc )
1338 {
1340 ci->sbRecalc = 0;
1341 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1342 }
1343 return 0;
1344 }
1345 return unicode ? DefWindowProcW( hwnd, message, wParam, lParam ) :
HANDLE HWND
Definition: compat.h:19
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
#define cs
Definition: i386-dis.c:442
#define FNID_DESTROY
Definition: ntuser.h:898
BOOL NTAPI NtUserSetWindowFNID(HWND hWnd, WORD fnID)
Definition: window.c:4330
#define FNID_MDICLIENT
Definition: ntuser.h:872
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
static unsigned __int64 next
Definition: rand_nt.c:6
static void MDITile(HWND client, MDICLIENTINFO *ci, WPARAM wParam)
Definition: mdi.c:779
void WINAPI CalcChildScroll(HWND hwnd, INT scroll)
Definition: mdi.c:1800
static LRESULT MDISetMenu(HWND hwnd, HMENU hmenuFrame, HMENU hmenuWindow)
Definition: mdi.c:335
static LRESULT MDIDestroyChild(HWND client, MDICLIENTINFO *ci, HWND child, BOOL flagDestroy)
Definition: mdi.c:566
static HBITMAP CreateMDIMenuBitmap(void)
Definition: mdi.c:687
static LONG MDICascade(HWND client, MDICLIENTINFO *ci)
Definition: mdi.c:721
void WINAPI ScrollChildren(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: mdi.c:1899
#define SW_SHOWNORMAL
Definition: winuser.h:770
HWND WINAPI ChildWindowFromPoint(_In_ HWND, _In_ POINT)
#define WM_MDITILE
Definition: winuser.h:1818
#define WM_MDISETMENU
Definition: winuser.h:1822
#define WM_HSCROLL
Definition: winuser.h:1743
#define WM_MDICREATE
Definition: winuser.h:1812
#define WM_VSCROLL
Definition: winuser.h:1744
#define WM_MDICASCADE
Definition: winuser.h:1819
#define WM_CREATE
Definition: winuser.h:1608
struct tagCREATESTRUCTA * LPCREATESTRUCTA
#define GetWindowLongPtrA
Definition: winuser.h:4828
#define WM_LBUTTONDOWN
Definition: winuser.h:1776
#define WM_NCCREATE
Definition: winuser.h:1683
#define WM_MDIREFRESHMENU
Definition: winuser.h:1826
#define WM_MDIICONARRANGE
Definition: winuser.h:1820
#define WM_MDIMAXIMIZE
Definition: winuser.h:1817
struct tagCLIENTCREATESTRUCT * LPCLIENTCREATESTRUCT
#define WM_NCDESTROY
Definition: winuser.h:1684
#define WM_MDIGETACTIVE
Definition: winuser.h:1821
#define WM_PARENTNOTIFY
Definition: winuser.h:1803
#define HWND_BOTTOM
Definition: winuser.h:1205
BOOL WINAPI SetRect(_Out_ LPRECT, _In_ int, _In_ int, _In_ int, _In_ int)

Referenced by MDIClientWndProcA(), MDIClientWndProcW(), and RegisterClientPFN().

◆ MDIClientWndProcA()

LRESULT WINAPI MDIClientWndProcA ( HWND  hwnd,
UINT  message,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 1351 of file mdi.c.

1353{
1354 if (!IsWindow(hwnd)) return 0;
LRESULT WINAPI MDIClientWndProc_common(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, BOOL unicode)
Definition: mdi.c:1097

Referenced by RegisterClientPFN().

◆ MDIClientWndProcW()

LRESULT WINAPI MDIClientWndProcW ( HWND  hwnd,
UINT  message,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 1360 of file mdi.c.

1362{
1363 if (!IsWindow(hwnd)) return 0;

Referenced by RegisterClientPFN().

◆ MDIDestroyChild()

static LRESULT MDIDestroyChild ( HWND  client,
MDICLIENTINFO ci,
HWND  child,
BOOL  flagDestroy 
)
static

Definition at line 566 of file mdi.c.

569{
570 UINT i;
571
572 TRACE("# of managed children %u\n", ci->nActiveChildren);
573
574 if( child == ci->hwndActiveChild )
575 {
576 HWND next = MDI_GetWindow(ci, child, TRUE, 0);
577 if (next)
579 else
580 {
582 if (child == ci->hwndChildMaximized)
583 {
584 HWND frame = GetParent(client);
586 ci->hwndChildMaximized = 0;
588 }
589 if (flagDestroy)
591 }
592 }
593
594 for (i = 0; i < ci->nActiveChildren; i++)
595 {
596 if (ci->child[i] == child)
597 {
598 HWND *new_child = HeapAlloc(GetProcessHeap(), 0, (ci->nActiveChildren - 1) * sizeof(HWND));
599 if (new_child != NULL)
600 {
601 memcpy(new_child, ci->child, i * sizeof(HWND));
602 if (i + 1 < ci->nActiveChildren)
603 memcpy(new_child + i, ci->child + i + 1, (ci->nActiveChildren - i - 1) * sizeof(HWND));
604 HeapFree(GetProcessHeap(), 0, ci->child);
605 ci->child = new_child;
606 }
607 else
608 {
609 UINT c;
610 for (c = i; c < ci->nActiveChildren - 1; c++)
611 {
612 ci->child[c] = ci->child[c+1];
613 }
614 }
615
616 ci->nActiveChildren--;
617 break;
618 }
619 }
620
621 if (flagDestroy)
622 {
626 }
627
628 TRACE("child destroyed - %p\n", child);
629 return 0;
const GLubyte * c
Definition: glext.h:8905
#define c
Definition: ke_i.h:80
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define SW_HIDE
Definition: winuser.h:768
BOOL WINAPI DestroyWindow(_In_ HWND)

Referenced by MDIClientWndProc_common().

◆ MDISetMenu()

static LRESULT MDISetMenu ( HWND  hwnd,
HMENU  hmenuFrame,
HMENU  hmenuWindow 
)
static

Definition at line 335 of file mdi.c.

338{
339 MDICLIENTINFO *ci;
340 HWND hwndFrame = GetParent(hwnd);
341
342 TRACE("%p, frame menu %p, window menu %p\n", hwnd, hmenuFrame, hmenuWindow);
343
344 if (hmenuFrame && !IsMenu(hmenuFrame))
345 {
346 WARN("hmenuFrame is not a menu handle\n");
347 return 0L;
348 }
349
350 if (hmenuWindow && !IsMenu(hmenuWindow))
351 {
352 WARN("hmenuWindow is not a menu handle\n");
353 return 0L;
354 }
355
356 if (!(ci = get_client_info( hwnd ))) return 0;
357
358 TRACE("old frame menu %p, old window menu %p\n", ci->hFrameMenu, ci->hWindowMenu);
359
360 if (hmenuFrame)
361 {
362 if (hmenuFrame == ci->hFrameMenu) return (LRESULT)hmenuFrame;
363
364 if (ci->hwndChildMaximized)
366 }
367
368 if( hmenuWindow && hmenuWindow != ci->hWindowMenu )
369 {
370 /* delete menu items from ci->hWindowMenu
371 * and add them to hmenuWindow */
372 /* Agent newsreader calls this function with ci->hWindowMenu == NULL */
373 if( ci->hWindowMenu && ci->nActiveChildren )
374 {
375 UINT nActiveChildren_old = ci->nActiveChildren;
376
377 /* Remove all items from old Window menu */
378 ci->nActiveChildren = 0;
379 MDI_RefreshMenu(ci);
380
381 ci->hWindowMenu = hmenuWindow;
382
383 /* Add items to the new Window menu */
384 ci->nActiveChildren = nActiveChildren_old;
385 MDI_RefreshMenu(ci);
386 }
387 else
388 ci->hWindowMenu = hmenuWindow;
389 }
390
391 if (hmenuFrame)
392 {
393 SetMenu(hwndFrame, hmenuFrame);
394 if( hmenuFrame != ci->hFrameMenu )
395 {
396 HMENU oldFrameMenu = ci->hFrameMenu;
397
398 ci->hFrameMenu = hmenuFrame;
399 if (ci->hwndChildMaximized)
401
402 return (LRESULT)oldFrameMenu;
403 }
404 }
405
406 return 0;
BOOL WINAPI SetMenu(_In_ HWND, _In_opt_ HMENU)

Referenced by MDIClientWndProc_common().

◆ MDITile()

static void MDITile ( HWND  client,
MDICLIENTINFO ci,
WPARAM  wParam 
)
static

Definition at line 779 of file mdi.c.

781{
782 HWND *win_array;
783 int i, total, rows, columns;
784 BOOL has_icons = FALSE;
785
786 if (ci->hwndChildMaximized)
788
789 if (ci->nActiveChildren == 0) return;
790
791 if (!(win_array = WIN_ListChildren( client ))) return;
792
793 /* remove all the windows we don't want */
794 for (i = total = rows = 0; win_array[i]; i++)
795 {
796 if (!IsWindowVisible( win_array[i] )) continue;
797 if (GetWindow( win_array[i], GW_OWNER )) continue; /* skip owned windows (icon titles) */
798 if (IsIconic( win_array[i] ))
799 {
800 has_icons = TRUE;
801 continue;
802 }
803 if ((wParam & MDITILE_SKIPDISABLED) && !IsWindowEnabled( win_array[i] )) continue;
804 if(total == (rows * (rows + 2))) rows++; /* total+1 == (rows+1)*(rows+1) */
805 win_array[total++] = win_array[i];
806 }
807 win_array[total] = 0;
808
809 TRACE("%u windows to tile\n", total);
810
811 if (total)
812 {
813 HWND *pWnd = win_array;
814 RECT rect;
815 int x, y, xsize, ysize;
816 int r, c, i;
817
819 columns = total/rows;
820 //while(total < rows*columns) rows++;
821
822 if( wParam & MDITILE_HORIZONTAL ) /* version >= 3.1 */
823 {
824 i = rows;
825 rows = columns; /* exchange r and c */
826 columns = i;
827 }
828
829 if (has_icons)
830 {
832 rect.bottom = ( y - GetSystemMetrics(SM_CYICON) < rect.top )? rect.bottom: y;
833 }
834
835 ysize = rect.bottom / rows;
836 xsize = rect.right / columns;
837
838 for (x = i = 0, c = 1; c <= columns && *pWnd; c++)
839 {
840 if (c == columns)
841 {
842 rows = total - i;
843 ysize = rect.bottom / rows;
844 }
845
846 y = 0;
847 for (r = 1; r <= rows && *pWnd; r++, i++)
848 {
850 LONG style = GetWindowLongW(win_array[i], GWL_STYLE);
851 if (!(style & WS_SIZEBOX)) posOptions |= SWP_NOSIZE;
852
853 SetWindowPos(*pWnd, 0, x, y, xsize, ysize, posOptions);
854 y += ysize;
855 pWnd++;
856 }
857 x += xsize;
858 }
859 }
860 HeapFree( GetProcessHeap(), 0, win_array );
861 if (has_icons) ArrangeIconicWindows( client );
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define MDITILE_HORIZONTAL
Definition: winuser.h:2188

Referenced by MDIClientWndProc_common().

◆ QuerySizeFix()

static BOOL QuerySizeFix ( HWND  hwnd,
LPINT  pcx,
LPINT  pcy 
)
static

Definition at line 2047 of file mdi.c.

2049{
2050 MINMAXINFO mmi;
2051 DWORD_PTR dwResult;
2052
2053 mmi.ptMinTrackSize.x = mmi.ptMinTrackSize.y = 0;
2056 SMTO_ABORTIFHUNG | SMTO_NORMAL, 120, &dwResult))
2057 {
2058 *pcx = min(max(*pcx, mmi.ptMinTrackSize.x), mmi.ptMaxTrackSize.x);
2059 *pcy = min(max(*pcy, mmi.ptMinTrackSize.y), mmi.ptMaxTrackSize.y);
2060 return TRUE;
2061 }
2062 return FALSE;
POINT ptMinTrackSize
Definition: winuser.h:3630
POINT ptMaxTrackSize
Definition: winuser.h:3631
#define MAXLONG
Definition: umtypes.h:116
LRESULT WINAPI SendMessageTimeoutW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM, _In_ UINT, _In_ UINT, _Out_opt_ PDWORD_PTR)
#define SMTO_ABORTIFHUNG
Definition: winuser.h:1223
#define SMTO_NORMAL
Definition: winuser.h:1225

Referenced by CascadeWindows(), and TileWindows().

◆ ScrollChildren()

void WINAPI ScrollChildren ( HWND  hWnd,
UINT  uMsg,
WPARAM  wParam,
LPARAM  lParam 
)

Definition at line 1899 of file mdi.c.

1902{
1903 INT newPos = -1;
1904 INT curPos, length, minPos, maxPos, shift;
1905 RECT rect;
1906
1907 GetClientRect( hWnd, &rect );
1908
1909 switch(uMsg)
1910 {
1911 case WM_HSCROLL:
1912 GetScrollRange(hWnd,SB_HORZ,&minPos,&maxPos);
1913 curPos = GetScrollPos(hWnd,SB_HORZ);
1914 length = (rect.right - rect.left) / 2;
1916 break;
1917 case WM_VSCROLL:
1918 GetScrollRange(hWnd,SB_VERT,&minPos,&maxPos);
1919 curPos = GetScrollPos(hWnd,SB_VERT);
1920 length = (rect.bottom - rect.top) / 2;
1922 break;
1923 default:
1924 return;
1925 }
1926
1927 switch( wParam )
1928 {
1929 case SB_LINEUP:
1930 newPos = curPos - shift;
1931 break;
1932 case SB_LINEDOWN:
1933 newPos = curPos + shift;
1934 break;
1935 case SB_PAGEUP:
1936 newPos = curPos - length;
1937 break;
1938 case SB_PAGEDOWN:
1939 newPos = curPos + length;
1940 break;
1941
1942 case SB_THUMBPOSITION:
1943 newPos = LOWORD(lParam);
1944 break;
1945
1946 case SB_THUMBTRACK:
1947 return;
1948
1949 case SB_TOP:
1950 newPos = minPos;
1951 break;
1952 case SB_BOTTOM:
1953 newPos = maxPos;
1954 break;
1955 case SB_ENDSCROLL:
1957 return;
1958 }
1959
1960 if( newPos > maxPos )
1961 newPos = maxPos;
1962 else
1963 if( newPos < minPos )
1964 newPos = minPos;
1965
1966 SetScrollPos(hWnd, (uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ , newPos, TRUE);
1967
1968 if( uMsg == WM_VSCROLL )
1969 ScrollWindowEx(hWnd ,0 ,curPos - newPos, NULL, NULL, 0, NULL,
1971 else
1972 ScrollWindowEx(hWnd ,curPos - newPos, 0, NULL, NULL, 0, NULL,
#define shift
Definition: input.c:1755
#define SB_THUMBTRACK
Definition: winuser.h:573
#define SB_LINEUP
Definition: winuser.h:564
#define SW_SCROLLCHILDREN
Definition: winuser.h:2578
#define SM_CXVSCROLL
Definition: winuser.h:961
#define SB_BOTTOM
Definition: winuser.h:577
#define SW_INVALIDATE
Definition: winuser.h:2579
int WINAPI SetScrollPos(_In_ HWND, _In_ int, _In_ int, _In_ BOOL)
#define SM_CYHSCROLL
Definition: winuser.h:962
BOOL WINAPI GetScrollRange(_In_ HWND, _In_ int, _Out_ LPINT, _Out_ LPINT)
#define SB_PAGEDOWN
Definition: winuser.h:569
#define SB_LINEDOWN
Definition: winuser.h:565
#define SB_TOP
Definition: winuser.h:578
#define SW_ERASE
Definition: winuser.h:2580
#define SB_ENDSCROLL
Definition: winuser.h:574
int WINAPI GetScrollPos(_In_ HWND, _In_ int)
int WINAPI ScrollWindowEx(_In_ HWND, _In_ int, _In_ int, _In_opt_ LPCRECT, _In_opt_ LPCRECT, _In_opt_ HRGN, _Out_opt_ LPRECT, _In_ UINT)
#define SB_PAGEUP
Definition: winuser.h:568
#define SB_THUMBPOSITION
Definition: winuser.h:572

Referenced by MDIClientWndProc_common().

◆ TileChildWindows()

WORD WINAPI TileChildWindows ( HWND  parent,
UINT  flags 
)

Definition at line 2401 of file mdi.c.

2403{
2404 return TileWindows( parent, flags, NULL, 0, NULL );
WORD WINAPI TileWindows(HWND hwndParent, UINT wFlags, LPCRECT lpRect, UINT cKids, const HWND *lpKids)
Definition: mdi.c:2221

◆ TileWindows()

WORD WINAPI TileWindows ( HWND  hwndParent,
UINT  wFlags,
LPCRECT  lpRect,
UINT  cKids,
const HWND lpKids 
)

Definition at line 2221 of file mdi.c.

2224{
2225 HWND hwnd, hwndTop, hwndPrev;
2227 RECT rcWork, rcWnd;
2228 DWORD i, iRow, iColumn, cRows, cColumns, ret = 0;
2229 INT x, y, cx, cy, cxNew, cyNew, cxWork, cyWork, cxCell, cyCell, cxMin2, cyMin3;
2230 HDWP hDWP;
2232 HMONITOR hMon;
2233 POINT pt;
2234
2235 TRACE("(%p,0x%08x,...,%u,...)\n", hwndParent, wFlags, cKids);
2236
2237 hwndTop = GetTopWindow(hwndParent);
2238
2239 ZeroMemory(&info, sizeof(info));
2240 info.hwndDesktop = GetDesktopWindow();
2241 info.hTrayWnd = FindWindowW(L"Shell_TrayWnd", NULL);
2242 info.hwndProgman = FindWindowW(L"Progman", NULL);
2243 info.hwndParent = hwndParent;
2244 info.wFlags = wFlags;
2245
2246 if (cKids == 0 || lpKids == NULL)
2247 {
2248 info.hwndTop = hwndTop;
2250
2251 info.hwndTop = NULL;
2252 GetCascadeChildProc(hwndTop, (LPARAM)&info);
2253 }
2254 else
2255 {
2256 info.chwnd = cKids;
2257 info.ahwnd = (HWND *)lpKids;
2258 }
2259
2260 if (info.chwnd == 0 || info.ahwnd == NULL)
2261 return ret;
2262
2263 if (lpRect)
2264 {
2265 rcWork = *lpRect;
2266 }
2267 else if (hwndParent)
2268 {
2269 GetClientRect(hwndParent, &rcWork);
2270 }
2271 else
2272 {
2273 pt.x = pt.y = 0;
2274 hMon = MonitorFromPoint(pt, MONITOR_DEFAULTTOPRIMARY);
2275 mi.cbSize = sizeof(mi);
2276 GetMonitorInfoW(hMon, &mi);
2277 rcWork = mi.rcWork;
2278 }
2279
2280 cxWork = rcWork.right - rcWork.left;
2281 cyWork = rcWork.bottom - rcWork.top;
2282
2283 cxMin2 = GetSystemMetrics(SM_CXMIN) * 2;
2284 cyMin3 = GetSystemMetrics(SM_CYMIN) * 3;
2285
2286 /* calculate the numbers and widths of columns and rows */
2287 if (info.wFlags & MDITILE_HORIZONTAL)
2288 {
2289 cColumns = info.chwnd;
2290 cRows = 1;
2291 for (;;)
2292 {
2293 cxCell = cxWork / cColumns;
2294 cyCell = cyWork / cRows;
2295 if (cyCell <= cyMin3 || cxCell >= cxMin2)
2296 break;
2297
2298 ++cRows;
2299 cColumns = (info.chwnd + cRows - 1) / cRows;
2300 }
2301 }
2302 else
2303 {
2304 cRows = info.chwnd;
2305 cColumns = 1;
2306 for (;;)
2307 {
2308 cxCell = cxWork / cColumns;
2309 cyCell = cyWork / cRows;
2310 if (cxCell <= cxMin2 || cyCell >= cyMin3)
2311 break;
2312
2313 ++cColumns;
2314 cRows = (info.chwnd + cColumns - 1) / cColumns;
2315 }
2316 }
2317
2318 hDWP = BeginDeferWindowPos(info.chwnd);
2319 if (hDWP == NULL)
2320 goto cleanup;
2321
2322 x = rcWork.left;
2323 y = rcWork.top;
2324 hwndPrev = NULL;
2325 iRow = iColumn = 0;
2326 for (i = info.chwnd; i > 0;) /* in reverse order */
2327 {
2328 --i;
2329 hwnd = info.ahwnd[i];
2330
2331 if (IsZoomed(hwnd))
2333
2334 GetWindowRect(hwnd, &rcWnd);
2335 cx = rcWnd.right - rcWnd.left;
2336 cy = rcWnd.bottom - rcWnd.top;
2337
2338 /* if we can change the window size */
2340 {
2341 cxNew = cxCell;
2342 cyNew = cyCell;
2343 /* shrink if we can */
2344 if (QuerySizeFix(hwnd, &cxNew, &cyNew))
2345 {
2346 cx = cxNew;
2347 cy = cyNew;
2348 }
2349 }
2350
2351 hDWP = DeferWindowPos(hDWP, hwnd, HWND_TOP, x, y, cx, cy, SWP_NOACTIVATE);
2352 if (hDWP == NULL)
2353 {
2354 ret = 0;
2355 goto cleanup;
2356 }
2357
2358 if (info.wFlags & MDITILE_HORIZONTAL)
2359 {
2360 x += cxCell;
2361 ++iColumn;
2362 if (iColumn >= cColumns)
2363 {
2364 iColumn = 0;
2365 ++iRow;
2366 x = rcWork.left;
2367 y += cyCell;
2368 }
2369 }
2370 else
2371 {
2372 y += cyCell;
2373 ++iRow;
2374 if (iRow >= cRows)
2375 {
2376 iRow = 0;
2377 ++iColumn;
2378 x += cxCell;
2379 y = rcWork.top;
2380 }
2381 }
2382 hwndPrev = hwnd;
2383 ++ret;
2384 }
2385
2387
2388 if (hwndPrev)
2389 SetForegroundWindow(hwndPrev);
2390
2391cleanup:
2392 if (cKids == 0 || lpKids == NULL)
2393 HeapFree(GetProcessHeap(), 0, info.ahwnd);
2394
2395 return (WORD)ret;
#define SM_CXMIN
Definition: winuser.h:989
#define SM_CYMIN
Definition: winuser.h:990

Referenced by TileChildWindows().

◆ TranslateMDISysAccel()

BOOL WINAPI TranslateMDISysAccel ( HWND  hwndClient,
LPMSG  msg 
)

Definition at line 1759 of file mdi.c.

1761{
1762 if (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
1763 {
1764 MDICLIENTINFO *ci = get_client_info( hwndClient );
1765 WPARAM wParam = 0;
1766
1767 if (!ci || !IsWindowEnabled(ci->hwndActiveChild)) return 0;
1768
1769 /* translate if the Ctrl key is down and Alt not. */
1770
1771 if( (GetKeyState(VK_CONTROL) & 0x8000) && !(GetKeyState(VK_MENU) & 0x8000))
1772 {
1773 switch( msg->wParam )
1774 {
1775 case VK_F6:
1776 case VK_TAB:
1778 break;
1779 case VK_F4:
1780 case VK_RBUTTON:
1782 {
1783 wParam = SC_CLOSE;
1784 break;
1785 }
1786 /* fall through */
1787 default:
1788 return FALSE;
1789 }
1790 TRACE("wParam = %04lx\n", wParam);
1792 return TRUE;
1793 }
1794 }
1795 return FALSE; /* failure */
#define msg(x)
Definition: auth_time.c:54
#define VK_TAB
Definition: winuser.h:2199
#define VK_RBUTTON
Definition: winuser.h:2191
#define VK_CONTROL
Definition: winuser.h:2203
#define VK_F6
Definition: winuser.h:2260
#define VK_F4
Definition: winuser.h:2258
#define VK_SHIFT
Definition: winuser.h:2202
#define WM_KEYDOWN
Definition: winuser.h:1715
#define WM_SYSKEYDOWN
Definition: winuser.h:1719
SHORT WINAPI GetKeyState(_In_ int)
#define VK_MENU
Definition: winuser.h:2204

◆ WIN_ListChildren()

HWND * WIN_ListChildren ( HWND  hWndparent)

Definition at line 139 of file mdi.c.

141{
142
143 DWORD dwCount = 0;
144 HWND* pHwnd = NULL;
145 HANDLE hHeap;
147
148 Status = NtUserBuildHwndList(NULL, hWndparent, FALSE, 0, dwCount, NULL, &dwCount);
149
150 if ( !NT_SUCCESS( Status ) )
151 return 0;
152
153 /* allocate buffer to receive HWND handles */
154 hHeap = GetProcessHeap();
155
156 pHwnd = HeapAlloc ( hHeap, 0, sizeof(HWND)*(dwCount+1) );
157 if ( !pHwnd )
158 {
160 return 0;
161 }
162
163 /* now call kernel again to fill the buffer this time */
164 Status = NtUserBuildHwndList(NULL, hWndparent, FALSE, 0, dwCount, pHwnd, &dwCount);
165
166 if ( !NT_SUCCESS( Status ) )
167 {
168 if ( pHwnd )
169 HeapFree ( hHeap, 0, pHwnd );
170 return 0;
171 }
172
173 pHwnd[dwCount] = (HWND) 0;
174
175 return pHwnd;
LONG NTSTATUS
Definition: precomp.h:26
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define SetLastError(x)
Definition: compat.h:752
Status
Definition: gdiplustypes.h:25
NTSTATUS NTAPI NtUserBuildHwndList(HDESK hDesktop, HWND hwndParent, BOOLEAN bChildren, ULONG dwThreadId, ULONG cHwnd, HWND *phwndList, ULONG *pcHwndNeeded)
Definition: window.c:1518

Referenced by AnyPopup(), CalcChildScroll(), DIALOG_IdToHwnd(), GetDlgItem(), MDI_GetWindow(), MDICascade(), MDITile(), and User32DefWindowProc().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( mdi  )

Variable Documentation

◆ MDICLIENT_builtin_class

const struct builtin_class_descr MDICLIENT_builtin_class
Initial value:
=
{
L"MDIClient",
0,
sizeof(MDIWND),
(HBRUSH)(COLOR_APPWORKSPACE+1)
}
struct _MDIWND MDIWND
LRESULT WINAPI MDIClientWndProcW(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
Definition: mdi.c:1360
LRESULT WINAPI MDIClientWndProcA(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
Definition: mdi.c:1351
#define IDC_ARROW
Definition: winuser.h:687
#define COLOR_APPWORKSPACE
Definition: winuser.h:925

Definition at line 212 of file mdi.c.