• Download source code - 153.22 KB
• Download demo - 75.8 KB

Introduction

In MFC, resizing or repositioning controls could be quite bothersome. If you are familiar with the .NET platform, things are much more simplified with the use of the Anchor and Dock properties of the Control class and design-time support for adding child controls to container controls. I tried to mimic some of these features of .NET, but the C++ way.

Background

There are other solutions available online (also on CodeProject) for this purpose. I think my solution stands out on its design, simplicity, and feature richness.

This solution allows you to do the following:

• Anchor a dialog item using the Anchor property.
• Create panels which contain other panels or UI controls.
• Restrict the size of UI controls or a panel by using minimum size and maximum size properties.
• Restrict the size of the dialog by using minimum size and maximum size properties.
• Create a horizontal or vertical split container.
• Freeze the splitter of split container so that users cannot use mouse to resize the panels.
• Set a panel to be fixed of a split container so that when the parent resizes only one of the non-fixed panel resizes.
• Set the parent of a UI control or a panel (not related to Win32 SetParent API).
• Show the resize grip on the lower right corner of the dialog using Visual Style (if the application supports it).

Let's take a brief look at how .NET does its resizing of child controls:

• Anchor - It allows a child control to be anchored to the left, top, right, or bottom edge or any combination of these four options.
• Dock - It allows a child control to be docked to the left, top, right, and bottom edges.
• Visual Studio Designer Support - If you place a frame control on a Windows Form and then drag a button control on top of the frame, the button becomes the actual child of the frame and grandchild of the Windows Form. But in the resource editor of MFC, if you place the frame on the dialog template and then drag a button on top of the frame control, the button is actually an immediate child of the dialog template and not the frame. This means if you move the frame, the button will not move.
• SplitContainer - Creating splitter windows has never been this simple since the invention of this control. It has two panels which can host other controls inside.

So in .NET, all controls are children or grandchildren of the WindowForm; this creates a hierarchical structure of controls. When a parent is resized or repositioned, all its children are resized or repositioned according to their Anchor or Dock property settings.

In my solution, I have implemented the Anchor, Panel, and SplitContainer concept. But I have not implemented the "Dock" feature yet (may be in the future).

There are several classes in this solution, but CWndResizer is the only class that a developer will work with.

Typically, you will design your dialog template in the Visual Studio Resource Editor, and then in the dialog class implementation, you will have a member variable like this:

private:
  CWndResizer m_resizer;

The samples included with this article uses CDialog class to demonstrate many features of this class. But this class can be used with any class derived from CWnd (CDialog, CPropertyPage, CPropertySheet, CFrmWnd, CFormView)

Before this class can do anything, you must call the Hook method like this:

BOOL CExample1Dlg::OnInitDialog()
{
  CDialog::OnInitDialog();
  BOOL bOk = m_resizer.Hook(this);
  ASSERT(bOk == TRUE);
}

In this article, I will refer to this window (that is passed to the Hook method) as "hooked-window".

By calling this method, it places a window procedure hook in the WndProc chain.

When you call the Hook method, it stores the client area of the hooked-window in a structure called CPanel. A panel is mainly a rectangle area given in client coordinate of the hooked-window. A panel can have zero or more panels as children. During creation of a panel, you assign a unique name for the panel. The name is used to refer to the panel or find a panel. The client area of the hooked-window is the root of the hierarchy and it is named "_root".

Each panel has Anchor, MinSize, MaxSize properties (along with some other properties). But you cannot directly set or get the properties of a panel; instead, you will use member methods of the CWndResizer class.

The idea is that when a CPanel is resized or repositioned, all its children are also resized and reposition relatively.

Now, let's look at some code snippets.

The following code will anchor the OK and Cancel buttons of your dialog to the bottom-right corner:

BOOL CExample1Dlg::OnInitDialog()
{
  CDialog::OnInitDialog();
  BOOL bOk = m_resizer.Hook(this);
  ASSERT(bOk == TRUE);

  bOk = m_resizer.SetAnchor(IDOK, ANCHOR_RIGHT | ANCHOR_BOTTOM);
  ASSERT(bOk == TRUE);

  bOk = m_resizer.SetAnchor(IDCANCEL, ANCHOR_RIGHT | ANCHOR_BOTTOM);
  ASSERT(bOk == TRUE);
}

If you want to create a panel and set its Anchor property to ANCHOR_HORIZONTALLY, you will do this:

BOOL CExample1Dlg::OnInitDialog()
{
  CDialog::OnInitDialog();
  BOOL bOk = m_resizer.Hook(this);
  ASSERT(bOk == TRUE);
  CRect rc(40, 40, 240, 240);
  bOk = m_resizer.CreatePanel(_T("MyNewPanel"), &rc);

  bOk = m_resizer.SetAnchor(_T("MyNewPanel"), ANCHOR_HORIZONTALLY);
  ASSERT(bOk == TRUE);

  ASSERT(bOk == TRUE);
}

Using the Code

The sample application demonstrates many features of this class.

The CWndResizer class has the following members:

• CreatePanel
• CreateSplitContainer
• GetAnchor
• GetFixedPanel
• GetIsSplitterFixed
• GetMaximumSize
• GetMinimumSize
• GetParent
• GetShowResizeGrip
• Hook
• InvokeOnResized
• SetAnchor
• SetFixedPanel
• SetIsSplitterFixed
• SetMaximumSize
• SetMinimumSize
• SetParent
• SetShowResizeGrip
• Unhook

BOOL CreatePanel(LPCTSTR panelName, const CRect * prcPanel);

BOOL CExample1Dlg::OnInitDialog()
{
  CDialog::OnInitDialog();
  BOOL bOk = m_resizer.Hook(this);
  ASSERT(bOk == TRUE);
  CRect rc(40, 40, 240, 240);
  bOk = m_resizer.CreatePanel(_T("MyNewPanel"), &rc);
  ASSERT(bOk == TRUE);

  // Subsequently you can use the name to refer to it
  bOk = m_resizer.SetAnchor(_T("MyNewPanel"), ANCHOR_HORIZONTALLY);
  ASSERT(bOk == TRUE);
}

BOOL CreateSplitContainer(LPCTSTR splitContainerName, 
	LPCTSTR panelNameA, LPCTSTR panelNameB);
BOOL CreateSplitContainer(LPCTSTR splitContainerName, 
	LPCTSTR panelNameA, UINT panelIDB);
BOOL CreateSplitContainer(LPCTSTR splitContainerName, 
	UINT panelIDA, LPCTSTR panelNameB);
BOOL CreateSplitContainer(LPCTSTR splitContainerName, 
	UINT panelIDA, UINT panelIDB);

BOOL GetAnchor(LPCTSTR panelName, UINT & anchor);
BOOL GetAnchor(UINT panelID, UINT & anchor);

BOOL GetFixedPanel(LPCTSTR splitContainer, short & panel);

BOOL GetIsSplitterFixed(LPCTSTR splitContainerName , BOOL &fixed);

BOOL GetMaximumSize(LPCTSTR panelName, CSize & size) ;
BOOL GetMaximumSize(UINT panelID, CSize & size) ;

BOOL GetMinimumSize(LPCTSTR panelName, CSize & size) ;
BOOL GetMinimumSize(UINT panelID, CSize & size) ;

BOOL GetParent(LPCTSTR panelName, CString & parentName);
BOOL GetParent(UINT panelID, CString & parentName);

BOOL GetShowResizeGrip();

BOOL Hook(CWnd * pWnd);

BOOL InvokeOnResized();

BOOL SetAnchor(LPCTSTR panelName, UINT & anchor);
BOOL SetAnchor(UINT panelID, UINT & anchor);

BOOL SetFixedPanel(LPCTSTR splitContainerName, short panel);

BOOL SetIsSplitterFixed(LPCTSTR splitContainerName , BOOL fixed);

BOOL SetMaximumSize(LPCTSTR panelName, CSize & size) ;
BOOL SetMaximumSize(UINT panelID, CSize & size) ;

BOOL SetMinimumSize(LPCTSTR panelName, CSize & size) ;
BOOL SetMinimumSize(UINT panelID, CSize & size) ;

BOOL SetParent(LPCTSTR panelName, LPCTSTR parentName);
BOOL SetParent(UINT panelID, LPCTSTR parentName);
BOOL SetParent(LPCTSTR panelName, UINT parentID);
BOOL SetParent(UINT panelID, UINT parentID);

void SetShowResizeGrip(BOOL show = TRUE);

BOOL Unhook();

Points of Interest

This solution does not require you to calculate any numbers on your part. This solution encapsulates all functionalities in the CWndResizer.

One can re-design it such that it exposes other objects (CPanel, CSplitContainer, etc.). The reason I designed it this way is because I did not want the user to have to know too many objects, and to simplify memory allocation and de-allocation.

Another thing is that it depends on MFC classes (CWnd etc.); again, one can remove all references to MFC classes and use pure Win32 APIs.

History

• 5^th November, 2010: Initial post
• 26^th November, 2010: Article updated
• 30^th November, 2010: Source code and demo updated