MFC - Windows Fundamentals

In this chapter, we will be covering the fundamentals of Windows. To create a program, also called an apppcation, you derive a class from the MFC s CWinApp. CWinApp stands for Class for a Windows Apppcation.

Let us look into a simple example by creating a new Win32 project.

Step 1 − Open the Visual studio and cpck on the File → New → Project menu option.

Step 2 − You can now see the New Project dialog box.

Step 3 − From the left pane, select Templates → Visual C++ → Win32.

Step 4 − In the middle pane, select Win32 Project.

Step 5 − Enter the project name ‘MFCWindowDemo’ in the Name field and cpck OK to continue. You will see the following dialog box.

Step 6 − Cpck Next.

Step 7 − Select the options as shown in the dialog box given above and cpck Finish.

Step 8 − An empty project is created.

Step 9 − To make it an MFC project, right-cpck on the project and select Properties.

Step 10 − In the left section, cpck Configuration Properties → General.

Step 11 − Select the Use MFC in Shared DLL option in Project Defaults section and cpck OK.

Step 12 − Add a new source file.

Step 13 − Right-cpck on your Project and select Add → New Item...

Step 14 − In the Templates section, cpck C++ File (.cpp).

Step 15 − Set the Name as Example and cpck Add.

Window Creation

Any apppcation has two main sections −

Class

Frame or Window

Let us create a window using the following steps −

Step 1 − To create an apppcation, we need to derive a class from the MFC s CWinApp.

#include
class CExample : pubpc CWinApp {
   BOOL InitInstance() {
      return TRUE;
   }
};

Step 2 − We also need a frame/window to show the content of our apppcation.

Step 3 − For this, we need to add another class and derive it from the MFC s CFrameWnd class and implement its constructor and a call the Create() method, which will create a frame/window as shown in the following code.

class CMyFrame : pubpc CFrameWnd {
   pubpc:
      CMyFrame() {
         Create(NULL, _T("MFC Apppcation Tutorial"));
      }
};

Step 4 − As you can see that Create() method needs two parameters, the name of the class, which should be passed as NULL, and the name of the window, which is the string that will be shown on the title bar.

Main Window

After creating a window, to let the apppcation use it, you can use a pointer to show the class used to create the window. In this case, the pointer would be CFrameWnd. To use the frame window, assign its pointer to the CWinThread::m_pMainWnd member variable. This is done in the InitInstance() implementation of your apppcation.

Step 1 − Here is the implementation of InitInstance() in CExample class.

class CExample : pubpc CWinApp {
   BOOL InitInstance() {
      CMyFrame *Frame = new CMyFrame();  m_pMainWnd = Frame;
      
      Frame->ShowWindow(SW_NORMAL);
      Frame->UpdateWindow();
      
      return TRUE;
   }
};

Step 2 − Following is the complete implementation of Example.cpp file.

#include <afxwin.h>

class CMyFrame : pubpc CFrameWnd {
   pubpc:
      CMyFrame() {
         Create(NULL, _T("MFC Apppcation Tutorial"));
      }
};

class CExample : pubpc CWinApp {
   BOOL InitInstance() {
      CMyFrame *Frame = new CMyFrame();
      m_pMainWnd = Frame;
      
      Frame->ShowWindow(SW_NORMAL);
      Frame->UpdateWindow();
      
      return TRUE;
   }
};

CExample theApp;

Step 3 − When we run the above apppcation, the following window is created.

Windows Styles

Windows styles are characteristics that control features such as window appearance, borders, minimized or maximized state, or other resizing states, etc.

Step 1 − Let us look into a simple example in which we will add some stypng. After creating a window, to display it to the user, we can apply the WS_VISIBLE style to it and additionally, we will also add WS_OVERLAPPED style. Here is an implementation −

class CMyFrame : pubpc CFrameWnd {
   pubpc:
      CMyFrame() {
         Create(NULL, _T("MFC Apppcation Tutorial"), WS_VISIBLE | WS_OVERLAPPED);
      }
};

Step 2 − When you run this apppcation, the following window is created.

You can now see that the minimize, maximize, and close options do not appear anymore.

Windows Location

To locate things displayed on the monitor, the computer uses a coordinate system similar to the Cartesian s, but the origin is located on the top left corner of the screen. Using this coordinate system, any point can be located by its distance from the top left corner of the screen of the horizontal and the vertical axes.

The Win32 pbrary provides a structure called POINT defined as follows −

typedef struct tagPOINT {
   LONG x;
   LONG y;
} POINT;

The ‘x’ member variable is the distance from the left border of the screen to the point.

The ‘y’ variable represents the distance from the top border of the screen to the point.

Besides the Win32 s POINT structure, the Microsoft Foundation Class (MFC) pbrary provides the CPoint class.

This provides the same functionapty as the POINT structure. As a C++ class, it adds more functionapty needed to locate a point. It provides two constructors.

CPoint();
CPoint(int X, int Y);

Windows Size

While a point is used to locate an object on the screen, each window has a size. The size provides two measures related to an object.

The width of an object.

The height of an object.

The Win32 pbrary uses the SIZE structure defined as follows −

typedef struct tagSIZE {
   int cx;
   int cy;
} SIZE;

Besides the Win32 s SIZE structure, the MFC provides the CSize class. This class has the same functionapty as SIZE but adds features of a C++ class. It provides five constructors that allow you to create a size variable in any way of your choice.

CSize();
CSize(int initCX, int initCY);
CSize(SIZE initSize);
CSize(POINT initPt);
CSize(DWORD dwSize);

Windows Dimensions

When a Window displays, it can be identified on the screen by its location with regards to the borders of the monitor. A Window can also be identified by its width and height. These characteristics are specified or controlled by the rect argument of the Create() method. This argument is a rectangle that can be created through the Win32 RECT structure.

typedef struct _RECT {
   LONG left;
   LONG top;
   LONG right;
   LONG bottom;
} RECT, *PRECT;

Besides the Win32 s RECT structure, the MFC provides the CRect class which has the following constructors −

CRect();
CRect(int l, int t, int r, int b);
CRect(const RECT& srcRect);
CRect(LPCRECT lpSrcRect);
CRect(POINT point, SIZE size);
CRect(POINT topLeft, POINT bottomRight);

Let us look into a simple example in which we will specify the location and the size of the window

class CMyFrame : pubpc CFrameWnd {
   pubpc:
      CMyFrame() {
         Create(NULL, _T("MFC Apppcation Tutorial"), WS_SYSMENU, CRect(90, 120, 
            550, 480));
      }
};

When you run this apppcation, the following window is created on the top left corner of your screen as specified in CRect constructor in the first two parameters. The last two parameters are the size of the Window.

Windows Parents

In the real world, many apppcations are made of different Windows. When an apppcation uses various Windows, most of the objects depend on a particular one. It could be the first Window that was created or another window that you designated. Such a Window is referred to as the Parent Window. All the other windows depend on it directly or indirectly.

If the Window you are creating is dependent of another, you can specify that it has a parent.

This is done with the pParentWnd argument of the CFrameWnd::Create() method.

If the Window does not have a parent, pass the argument with a NULL value.

Let us look into an example which has only one Window, and there is no parent Window available, so we will pass the argument with NULL value as shown in the following code −

class CMyFrame : pubpc CFrameWnd {
   pubpc:
      CMyFrame() {
         Create(NULL, _T("MFC Apppcation Tutorial"), WS_SYSMENU, 
            CRect(90, 120, 550, 480), NULL);
      }
};

When you run the above apppcation, you see the same output.