This is a short write-up that I did quite a while ago to show to a newly joined colleague how MFC UI can be created from the program without requiring the definition of resources. This is really very simple MFC programming and I’m including it here as I’m going to shut down the other blog site that I used to maintain and want to transfer some of the content that I spent some effort on to here.

This sample shows how a child window can be embedded inside the simple window that we created in the previous lesson. Objectives of this write-up are:

• Show how windows messages can be trapped and handled in window-object methods.
• Creation of a standard control inside a parent window.
• Proper handling of WM_SIZE message so that the child window occupies the entire client-area of the parent window when parent window is resized.
• Retrieving the handle to the child window from outside the scope of the parent window in order to change its properties.

Code

#include <afxwin.h>
#include <afxcmn.h>

// declare a simple window
class MyWnd : public CWnd {
	//
	// child window is a list-view control, but can be
	// substituted with any other standard windows control
	CListCtrl m_wndList;

public:
	static const UINT IDW_LISTCTRL = 1000;

	MyWnd() : CWnd()
	{}

	DECLARE_MESSAGE_MAP()

	int OnCreate(LPCREATESTRUCT lpCreateStruct)
	{
		// pass the message to base class so that it can complete
		// its logic
		if (CWnd::OnCreate(lpCreateStruct) == -1)
			return -1;  // -1 indicates OnCreate failure
		// create the list-view control
		CRect rc;
		if (!m_wndList.CreateEx(
			WS_EX_CLIENTEDGE, // window extended style
			WS_VISIBLE|WS_CHILD|
			WS_CLIPCHILDREN|LVS_REPORT, // window style
			rc, // unitialized rc is okay as we resize the child
			    // window in the WM_SIZE handler
			this, // parent window
			IDW_LISTCTRL)) // window id
			return -1;
		//
		// add a few columns to the list-view control.
		m_wndList.InsertColumn(
			0, // column index
			_T("Name"), // title
			LVCFMT_LEFT, // column content format style
			150, // column width
			0); // subitem index that uniquely refers to this column
		m_wndList.InsertColumn(1,
			_T("Address1"),
			LVCFMT_LEFT,
			200,
			1);
		m_wndList.InsertColumn(2,
			_T("Address2"),
			LVCFMT_LEFT,
			200,
			2);
		m_wndList.InsertColumn(3,
			_T("Country"),
			LVCFMT_LEFT,
			80,
			3);
		m_wndList.InsertColumn(4,
			_T("Zip"),
			LVCFMT_LEFT,
			60,
			4);
		return 0;
	}
	void OnSize(UINT uSizeType, int cx, int cy)
	{
		CWnd::OnSize(uSizeType, cx, cy);
		// resize the child window to fit the entire client area
		m_wndList.MoveWindow(0, 0, cx, cy);
	}
};

BEGIN_MESSAGE_MAP(MyWnd, CWnd)
	ON_WM_CREATE()
	ON_WM_SIZE()
END_MESSAGE_MAP()

//
// There must be one instance of a CWinApp derived class per program
class MyApp : public CWinApp {
	CWnd* m_pWnd;
public:
	MyApp()
	: CWinApp()
	, m_pWnd(0)
	{}
	BOOL InitInstance()
	{
		MyWnd* pWnd = new MyWnd;
		if (!pWnd->CreateEx(WS_EX_CLIENTEDGE,
			::AfxRegisterWndClass(0, 0, ::GetSysColorBrush(COLOR_WINDOW), 0),
			_T("My Window"),
			WS_OVERLAPPEDWINDOW,
			0,
			0,
			CW_USEDEFAULT,
			CW_USEDEFAULT,
			NULL,
			0) )
			return FALSE;
		m_pWnd = m_pMainWnd = pWnd;

		// retrieve a pointer to the list-view child window and append an item to it.
		CListCtrl* pListCtrl = (CListCtrl*)m_pWnd->GetDlgItem(MyWnd::IDW_LISTCTRL);
		ASSERT(pListCtrl);
		int iItem = pListCtrl->InsertItem(
			pListCtrl->GetItemCount(),
			_T("John Smith"));
		pListCtrl->SetItemText(iItem, 1, _T("110 Sunset Blvd"));
		pListCtrl->SetItemText(iItem, 2, _T("Ocean Drive"));
		pListCtrl->SetItemText(iItem, 3, _T("Singapore"));
		pListCtrl->SetItemText(iItem, 4, _T("234590"));

		// add an extended list-view specific style to change the control's behavior
		// Specifically, we tell the control to highlight the entire item when it is
		// selected. By default only the coulmn 1 is highlighted when the item
		// is selected.
		pListCtrl->SetExtendedStyle(LVS_EX_FULLROWSELECT);

		pWnd->ShowWindow(SW_SHOW);
		pWnd->UpdateWindow();

		return TRUE;
	}
	int ExitInstance()
	{
		delete m_pWnd; m_pWnd = 0;
		return 0;
	}
};
MyApp theApp;

How to Compile

Compile the code using the command line:

cl /MT /EHsc /D "_UNICODE" /D "UNICODE" tut1.cpp /link 
/subsystem:windows /ENTRY:"wWinMainCRTStartup"

Discussion

In this sample, we add a child window inside the simple window that we created earlier. For simplicity, we use a standard windows control as the child window and I picked the list-view control as this is one of the most powerful, versatile and often misunderstood control of all windows controls.

Firstly we add two message handler methods to our MyWnd class. These methods handle WM_CREATE and WM_SIZE windows messages respectively. The prototypes for these methods are defined in CWnd base class (from which CListCtrl, the list-view control class, is derived) and all we do is override the respective virtual methods (all message handler methods are defined as virtual allowing the derived class to override them). In order to trap the WM_CREATE and WM_SIZE messages sent to MyWnd into our own methods we place the necessary macros ON_WM_CREATE() and ON_WM_SIZE() between the BEGIN_MESSAGE_MAP() and END_MESSAGE_MAP() macros. Though it might appear complicated, these macros do very little other than initialize the data structure declared through the DECLARE_MESSAGE_MAP() macro with the function pointers to the OnCreate and OnSize methods.

In OnCreate(), we first pass the call to the base class so that it can complete its handling. This is an approach that is used throughout MFC (save for a few special messages where our handler is executed first and the base class method is optionally invoked). Subsequently, the child window is created and in our case we add a few columns to the list-view control to illustrate how easy it is to add columns to the list-view control. Also, note how the list-view window styles are appended to the standard window styles to initialize the list-view control in report mode (LVS_REPORT window style). Take note of the last parameter to the CreateEx() call. This is the id of the list control window that uniquely identifies this window to MyWnd amongst all its children. We’ll use this later to retrieve a pointer to this window from outside the scope of MyWnd object and manipulate it.

In OnSize(), since we want the list-view control to occupy the entire client area, we resize the child control using the MoveWindow() method passing the client area dimensions cx and cy as parameter.

Lastly, inside MyApp::InitInstance() we access the list-view child window and manipulate it directly. This is done by retrieving a pointer to the child window object through the CWnd::GetDlgItem() method, which returns a CWnd* to a child window, given the child window’s id. Of course for our example, we could have made CListCtrl a public data member which would have given us direct access to the child window. However, the purpose of this sample is to demonstrate this concept which is used extensively throughout MFC programs, especially in dialogs, to work on child windows.

Exercise

Add another child window to MyWnd such that the two children, the original list-view control and the new child window occupy half the client area of MyWnd at all times.