ReactOS 0.4.15-dev-8434-g155a7c7
Classes | Typedefs | Functions
layout.h File Reference
#include <assert.h>
Include dependency graph for layout.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  LAYOUT_INFO
 
struct  LAYOUT_DATA
 

Typedefs

typedef struct LAYOUT_INFO LAYOUT_INFO
 
typedef struct LAYOUT_DATA LAYOUT_DATA
 

Functions

static __inline void _layout_ModifySystemMenu (LAYOUT_DATA *pData, BOOL bEnableResize)
 
static __inline HDWP _layout_MoveGrip (LAYOUT_DATA *pData, HDWP hDwp OPTIONAL)
 
static __inline void LayoutShowGrip (LAYOUT_DATA *pData, BOOL bShow)
 
static __inline void _layout_GetPercents (LPRECT prcPercents, UINT uEdges)
 
static __inline HDWP _layout_DoMoveItem (LAYOUT_DATA *pData, HDWP hDwp, const LAYOUT_INFO *pLayout, const RECT *rcClient)
 
static __inline void _layout_ArrangeLayout (LAYOUT_DATA *pData)
 
static __inline void _layout_InitLayouts (LAYOUT_DATA *pData)
 
static __inline void LayoutUpdate (HWND ignored1, LAYOUT_DATA *pData, LPCVOID ignored2, UINT ignored3)
 
static __inline void LayoutEnableResize (LAYOUT_DATA *pData, BOOL bEnable)
 
static __inline LAYOUT_DATA * LayoutInit (HWND hwndParent, const LAYOUT_INFO *pLayouts, INT cLayouts)
 
static __inline void LayoutDestroy (LAYOUT_DATA *pData)
 

Typedef Documentation

◆ LAYOUT_DATA

typedef struct LAYOUT_DATA LAYOUT_DATA

◆ LAYOUT_INFO

typedef struct LAYOUT_INFO LAYOUT_INFO

Function Documentation

◆ _layout_ArrangeLayout()

static __inline void _layout_ArrangeLayout ( LAYOUT_DATA *  pData)
static

Definition at line 137 of file layout.h.

138{
139 RECT rcClient;
140 UINT iItem;
141 HDWP hDwp = BeginDeferWindowPos(pData->m_cLayouts + 1);
142 if (hDwp == NULL)
143 return;
144
145 GetClientRect(pData->m_hwndParent, &rcClient);
146
147 for (iItem = 0; iItem < pData->m_cLayouts; ++iItem)
148 hDwp = _layout_DoMoveItem(pData, hDwp, &pData->m_pLayouts[iItem], &rcClient);
149
150 hDwp = _layout_MoveGrip(pData, hDwp);
151 EndDeferWindowPos(hDwp);
152}
NULL
#define NULL
Definition: types.h:112
_layout_DoMoveItem
static __inline HDWP _layout_DoMoveItem(LAYOUT_DATA *pData, HDWP hDwp, const LAYOUT_INFO *pLayout, const RECT *rcClient)
Definition: layout.h:108
_layout_MoveGrip
static __inline HDWP _layout_MoveGrip(LAYOUT_DATA *pData, HDWP hDwp OPTIONAL)
Definition: layout.h:42
UINT
unsigned int UINT
Definition: ndis.h:50
pData
TW_UINT32 TW_UINT16 TW_UINT16 TW_MEMREF pData
Definition: twain.h:1830
EndDeferWindowPos
BOOL WINAPI EndDeferWindowPos(_In_ HDWP)
GetClientRect
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)
BeginDeferWindowPos
HDWP WINAPI BeginDeferWindowPos(_In_ int)

Referenced by LayoutUpdate().

◆ _layout_DoMoveItem()

static __inline HDWP _layout_DoMoveItem ( LAYOUT_DATA *  pData,
HDWP  hDwp,
const LAYOUT_INFO *  pLayout,
const RECT *  rcClient 
)
static

Definition at line 108 of file layout.h.

110{
111 RECT rcChild, NewRect, rcPercents;
112 LONG nWidth, nHeight;
113
114 if (!GetWindowRect(pLayout->m_hwndCtrl, &rcChild))
115 return hDwp;
116 MapWindowPoints(NULL, pData->m_hwndParent, (LPPOINT)&rcChild, 2);
117
118 nWidth = rcClient->right - rcClient->left;
119 nHeight = rcClient->bottom - rcClient->top;
120
121 _layout_GetPercents(&rcPercents, pLayout->m_uEdges);
122 NewRect.left = pLayout->m_margin1.cx + nWidth * rcPercents.left / 100;
123 NewRect.top = pLayout->m_margin1.cy + nHeight * rcPercents.top / 100;
124 NewRect.right = pLayout->m_margin2.cx + nWidth * rcPercents.right / 100;
125 NewRect.bottom = pLayout->m_margin2.cy + nHeight * rcPercents.bottom / 100;
126
127 if (!EqualRect(&NewRect, &rcChild))
128 {
129 hDwp = DeferWindowPos(hDwp, pLayout->m_hwndCtrl, NULL, NewRect.left, NewRect.top,
130 NewRect.right - NewRect.left, NewRect.bottom - NewRect.top,
131 SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREPOSITION | SWP_NOCOPYBITS);
132 }
133 return hDwp;
134}
_layout_GetPercents
static __inline void _layout_GetPercents(LPRECT prcPercents, UINT uEdges)
Definition: layout.h:99
LONG
long LONG
Definition: pedump.c:60
LAYOUT_INFO::m_uEdges
UINT m_uEdges
Definition: layout.h:12
LAYOUT_INFO::m_margin2
SIZE m_margin2
Definition: layout.h:15
LAYOUT_INFO::m_hwndCtrl
HWND m_hwndCtrl
Definition: layout.h:13
LAYOUT_INFO::m_margin1
SIZE m_margin1
Definition: layout.h:14
_SIZE::cx
LONG cx
Definition: kdterminal.h:27
_SIZE::cy
LONG cy
Definition: kdterminal.h:28
tagRECT::right
LONG right
Definition: windef.h:308
tagRECT::bottom
LONG bottom
Definition: windef.h:309
tagRECT::top
LONG top
Definition: windef.h:307
tagRECT::left
LONG left
Definition: windef.h:306
SWP_NOACTIVATE
#define SWP_NOACTIVATE
Definition: winuser.h:1242
SWP_NOREPOSITION
#define SWP_NOREPOSITION
Definition: winuser.h:1250
GetWindowRect
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
MapWindowPoints
int WINAPI MapWindowPoints(_In_opt_ HWND hWndFrom, _In_opt_ HWND hWndTo, _Inout_updates_(cPoints) LPPOINT lpPoints, _In_ UINT cPoints)
SWP_NOCOPYBITS
#define SWP_NOCOPYBITS
Definition: winuser.h:1243
DeferWindowPos
HDWP WINAPI DeferWindowPos(_In_ HDWP, _In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
SWP_NOZORDER
#define SWP_NOZORDER
Definition: winuser.h:1247
EqualRect
BOOL WINAPI EqualRect(_In_ LPCRECT, _In_ LPCRECT)

Referenced by _layout_ArrangeLayout().

◆ _layout_GetPercents()

static __inline void _layout_GetPercents ( LPRECT  prcPercents,
UINT  uEdges 
)
static

Definition at line 99 of file layout.h.

100{
101 prcPercents->left = (uEdges & BF_LEFT) ? 0 : 100;
102 prcPercents->right = (uEdges & BF_RIGHT) ? 100 : 0;
103 prcPercents->top = (uEdges & BF_TOP) ? 0 : 100;
104 prcPercents->bottom = (uEdges & BF_BOTTOM) ? 100 : 0;
105}
BF_LEFT
#define BF_LEFT
Definition: winuser.h:454
BF_BOTTOM
#define BF_BOTTOM
Definition: winuser.h:457
BF_TOP
#define BF_TOP
Definition: winuser.h:455
BF_RIGHT
#define BF_RIGHT
Definition: winuser.h:456

Referenced by _layout_DoMoveItem(), and _layout_InitLayouts().

◆ _layout_InitLayouts()

static __inline void _layout_InitLayouts ( LAYOUT_DATA *  pData)
static

Definition at line 155 of file layout.h.

156{
157 RECT rcClient, rcChild, rcPercents;
158 LONG nWidth, nHeight;
159 UINT iItem;
160
161 GetClientRect(pData->m_hwndParent, &rcClient);
162 nWidth = rcClient.right - rcClient.left;
163 nHeight = rcClient.bottom - rcClient.top;
164
165 for (iItem = 0; iItem < pData->m_cLayouts; ++iItem)
166 {
167 LAYOUT_INFO *pInfo = &pData->m_pLayouts[iItem];
168 if (pInfo->m_hwndCtrl == NULL)
169 {
170 pInfo->m_hwndCtrl = GetDlgItem(pData->m_hwndParent, pInfo->m_nCtrlID);
171 if (pInfo->m_hwndCtrl == NULL)
172 continue;
173 }
174
175 GetWindowRect(pInfo->m_hwndCtrl, &rcChild);
176 MapWindowPoints(NULL, pData->m_hwndParent, (LPPOINT)&rcChild, 2);
177
178 _layout_GetPercents(&rcPercents, pInfo->m_uEdges);
179 pInfo->m_margin1.cx = rcChild.left - nWidth * rcPercents.left / 100;
180 pInfo->m_margin1.cy = rcChild.top - nHeight * rcPercents.top / 100;
181 pInfo->m_margin2.cx = rcChild.right - nWidth * rcPercents.right / 100;
182 pInfo->m_margin2.cy = rcChild.bottom - nHeight * rcPercents.bottom / 100;
183 }
184}
LAYOUT_INFO
Definition: layout.h:10
LAYOUT_INFO::m_nCtrlID
UINT m_nCtrlID
Definition: layout.h:11
GetDlgItem
HWND WINAPI GetDlgItem(_In_opt_ HWND, _In_ int)

Referenced by LayoutInit().

◆ _layout_ModifySystemMenu()

static __inline void _layout_ModifySystemMenu ( LAYOUT_DATA *  pData,
BOOL  bEnableResize 
)
static

Definition at line 26 of file layout.h.

27{
28 if (bEnableResize)
29 {
30 GetSystemMenu(pData->m_hwndParent, TRUE); /* revert */
31 }
32 else
33 {
34 HMENU hSysMenu = GetSystemMenu(pData->m_hwndParent, FALSE);
35 RemoveMenu(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
36 RemoveMenu(hSysMenu, SC_SIZE, MF_BYCOMMAND);
37 RemoveMenu(hSysMenu, SC_RESTORE, MF_BYCOMMAND);
38 }
39}
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
HMENU
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
MF_BYCOMMAND
#define MF_BYCOMMAND
Definition: winuser.h:202
GetSystemMenu
HMENU WINAPI GetSystemMenu(_In_ HWND, _In_ BOOL)
SC_SIZE
#define SC_SIZE
Definition: winuser.h:2584
RemoveMenu
BOOL WINAPI RemoveMenu(_In_ HMENU, _In_ UINT, _In_ UINT)
SC_RESTORE
#define SC_RESTORE
Definition: winuser.h:2598
SC_MAXIMIZE
#define SC_MAXIMIZE
Definition: winuser.h:2588

Referenced by LayoutEnableResize().

◆ _layout_MoveGrip()

static __inline HDWP _layout_MoveGrip ( LAYOUT_DATA *  pData,
HDWP hDwp  OPTIONAL 
)
static

Definition at line 42 of file layout.h.

43{
44 if (!IsWindowVisible(pData->m_hwndGrip))
45 return hDwp;
46
47 SIZE size = { GetSystemMetrics(SM_CXVSCROLL), GetSystemMetrics(SM_CYHSCROLL) };
48 const UINT uFlags = SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOCOPYBITS;
49 RECT rcClient;
50 GetClientRect(pData->m_hwndParent, &rcClient);
51
52 if (hDwp)
53 {
54 hDwp = DeferWindowPos(hDwp, pData->m_hwndGrip, NULL,
55 rcClient.right - size.cx, rcClient.bottom - size.cy,
56 size.cx, size.cy, uFlags);
57 }
58 else
59 {
60 SetWindowPos(pData->m_hwndGrip, NULL,
61 rcClient.right - size.cx, rcClient.bottom - size.cy,
62 size.cx, size.cy, uFlags);
63 }
64 return hDwp;
65}
uFlags
UINT uFlags
Definition: api.c:59
size
GLsizeiptr size
Definition: glext.h:5919
_SIZE
Definition: kdterminal.h:26
SetWindowPos
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
SM_CXVSCROLL
#define SM_CXVSCROLL
Definition: winuser.h:961
SM_CYHSCROLL
#define SM_CYHSCROLL
Definition: winuser.h:962
SWP_NOOWNERZORDER
#define SWP_NOOWNERZORDER
Definition: winuser.h:1249
IsWindowVisible
BOOL WINAPI IsWindowVisible(_In_ HWND)
GetSystemMetrics
int WINAPI GetSystemMetrics(_In_ int)

Referenced by _layout_ArrangeLayout(), and LayoutShowGrip().

◆ LayoutDestroy()

static __inline void LayoutDestroy ( LAYOUT_DATA *  pData)
static

Definition at line 252 of file layout.h.

253{
254 if (!pData)
255 return;
256 HeapFree(GetProcessHeap(), 0, pData->m_pLayouts);
257 HeapFree(GetProcessHeap(), 0, pData);
258}
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735

Referenced by BrFolder_OnDestroy().

◆ LayoutEnableResize()

static __inline void LayoutEnableResize ( LAYOUT_DATA *  pData,
BOOL  bEnable 
)
static

Definition at line 200 of file layout.h.

201{
202 LayoutShowGrip(pData, bEnable);
203 _layout_ModifySystemMenu(pData, bEnable);
204}
_layout_ModifySystemMenu
static __inline void _layout_ModifySystemMenu(LAYOUT_DATA *pData, BOOL bEnableResize)
Definition: layout.h:26
LayoutShowGrip
static __inline void LayoutShowGrip(LAYOUT_DATA *pData, BOOL bShow)
Definition: layout.h:68
bEnable
_In_ BOOL bEnable
Definition: winddi.h:3426

◆ LayoutInit()

static __inline LAYOUT_DATA * LayoutInit ( HWND  hwndParent,
const LAYOUT_INFO *  pLayouts,
INT  cLayouts 
)
static

Definition at line 207 of file layout.h.

208{
209 BOOL bShowGrip;
210 SIZE_T cb;
211 LAYOUT_DATA *pData = (LAYOUT_DATA *)HeapAlloc(GetProcessHeap(), 0, sizeof(LAYOUT_DATA));
212 if (pData == NULL)
213 {
214 assert(0);
215 return NULL;
216 }
217
218 if (cLayouts < 0) /* NOTE: If cLayouts was negative, then don't show size grip */
219 {
220 cLayouts = -cLayouts;
221 bShowGrip = FALSE;
222 }
223 else
224 {
225 bShowGrip = TRUE;
226 }
227
228 cb = cLayouts * sizeof(LAYOUT_INFO);
229 pData->m_cLayouts = cLayouts;
230 pData->m_pLayouts = (LAYOUT_INFO *)HeapAlloc(GetProcessHeap(), 0, cb);
231 if (pData->m_pLayouts == NULL)
232 {
233 assert(0);
234 HeapFree(GetProcessHeap(), 0, pData);
235 return NULL;
236 }
237 memcpy(pData->m_pLayouts, pLayouts, cb);
238
239 assert(IsWindow(hwndParent));
240
241 pData->m_hwndParent = hwndParent;
242
243 pData->m_hwndGrip = NULL;
244 if (bShowGrip)
245 LayoutShowGrip(pData, bShowGrip);
246
247 _layout_InitLayouts(pData);
248 return pData;
249}
hwndParent
static HWND hwndParent
Definition: cryptui.c:300
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
assert
#define assert(x)
Definition: debug.h:53
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
_layout_InitLayouts
static __inline void _layout_InitLayouts(LAYOUT_DATA *pData)
Definition: layout.h:155
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
cb
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
LAYOUT_DATA
Definition: layout.h:18
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
IsWindow
BOOL WINAPI IsWindow(_In_opt_ HWND)

Referenced by BrFolder_OnInitDialog().

◆ LayoutShowGrip()

static __inline void LayoutShowGrip ( LAYOUT_DATA *  pData,
BOOL  bShow 
)
static

Definition at line 68 of file layout.h.

69{
70 UINT uSWP = SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE |
71 SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED;
72 DWORD style = GetWindowLongPtrW(pData->m_hwndParent, GWL_STYLE);
73 DWORD new_style = (bShow ? (style | WS_SIZEBOX) : (style & ~WS_SIZEBOX));
74 if (style != new_style)
75 {
76 SetWindowLongPtrW(pData->m_hwndParent, GWL_STYLE, new_style); /* change style */
77 SetWindowPos(pData->m_hwndParent, NULL, 0, 0, 0, 0, uSWP); /* frame changed */
78 }
79
80 if (!bShow)
81 {
82 ShowWindow(pData->m_hwndGrip, SW_HIDE);
83 return;
84 }
85
86 if (pData->m_hwndGrip == NULL)
87 {
88 /* CORE-19585: WS_GROUP set to avoid navigation over the grip control */
89 DWORD style = WS_GROUP | WS_CHILD | WS_CLIPSIBLINGS | SBS_SIZEGRIP;
90 pData->m_hwndGrip = CreateWindowExW(0, L"SCROLLBAR", NULL, style,
91 0, 0, 0, 0, pData->m_hwndParent,
92 NULL, GetModuleHandleW(NULL), NULL);
93 }
94 _layout_MoveGrip(pData, NULL);
95 ShowWindow(pData->m_hwndGrip, SW_SHOWNOACTIVATE);
96}
style
Arabic default style
Definition: afstyles.h:94
GetModuleHandleW
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:838
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
L
#define L(x)
Definition: ntvdm.h:50
WS_CHILD
#define WS_CHILD
Definition: pedump.c:617
WS_SIZEBOX
#define WS_SIZEBOX
Definition: pedump.c:642
WS_GROUP
#define WS_GROUP
Definition: pedump.c:633
WS_CLIPSIBLINGS
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
SW_HIDE
#define SW_HIDE
Definition: winuser.h:768
GetWindowLongPtrW
#define GetWindowLongPtrW
Definition: winuser.h:4829
SWP_FRAMECHANGED
#define SWP_FRAMECHANGED
Definition: winuser.h:1240
SBS_SIZEGRIP
#define SBS_SIZEGRIP
Definition: winuser.h:332
ShowWindow
BOOL WINAPI ShowWindow(_In_ HWND, _In_ int)
SWP_NOMOVE
#define SWP_NOMOVE
Definition: winuser.h:1244
SW_SHOWNOACTIVATE
#define SW_SHOWNOACTIVATE
Definition: winuser.h:774
SWP_NOSIZE
#define SWP_NOSIZE
Definition: winuser.h:1245
CreateWindowExW
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)
SetWindowLongPtrW
#define SetWindowLongPtrW
Definition: winuser.h:5355
GWL_STYLE
#define GWL_STYLE
Definition: winuser.h:852

Referenced by LayoutEnableResize(), and LayoutInit().

◆ LayoutUpdate()

static __inline void LayoutUpdate ( HWND  ignored1,
LAYOUT_DATA *  pData,
LPCVOID  ignored2,
UINT  ignored3 
)
static

Definition at line 188 of file layout.h.

189{
190 UNREFERENCED_PARAMETER(ignored1);
191 UNREFERENCED_PARAMETER(ignored2);
192 UNREFERENCED_PARAMETER(ignored3);
193 if (pData == NULL || !pData->m_hwndParent)
194 return;
195 assert(IsWindow(pData->m_hwndParent));
196 _layout_ArrangeLayout(pData);
197}
_layout_ArrangeLayout
static __inline void _layout_ArrangeLayout(LAYOUT_DATA *pData)
Definition: layout.h:137
UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317

Referenced by BrFolderDlgProc().