The Microsoft Foundation Class Library Application Framework

1
The Microsoft Foundation Class Library
Application Framework

2
The Microsoft Foundation Class Library
Application Framework

• Application framework
• An integrated collection of object-oriented
  software components that offers all that's needed
  for a generic application.
• An Application Framework vs. a Class Library
• - An application framework is a superset of a
  class library.
• - An ordinary library is an isolated set of
  classes designed to be incorporated into any
  program, but an application framework defines the
  structure of the program itself.

3
Why Use the Application Framework?

• MyApp.h header file for the MYAPP application
• The MFC library is the C Microsoft Windows API.
• Application framework applications use a standard
  structure.
• Application framework applications are small and
  fast.
• The Visual C tools reduce coding drudgery
• The MFC library application framework is feature
  rich

4
An Application Framework Example

• source code for the header and implementation
  files for our
• MYAPPapplication.
• // application class
• class CMyApp public CWinApp
• public
• virtual BOOL InitInstance()

5

• // frame window class
• class CMyFrame public CFrameWnd
• public
• CMyFrame()
• protected
• // "afx_msg" indicates that the next two
  functions are part
• // of the MFC library message dispatch system
  afx_msg void OnLButtonDown(UINT nFlags, CPoint
  point)
• afx_msg void OnPaint()
• DECLARE_MESSAGE_MAP()

6
MyApp.cpp - implementation file for the MYAPP
application

• include ltafxwin.hgt // MFC library header file
  declares base classes
• include "myapp.h"
• CMyApp theApp // the one and only CMyApp object
• BOOL CMyAppInitInstance()
• m_pMainWnd new CMyFrame()
• m_pMainWnd-gtShowWindow(m_nCmdShow)
• m_pMainWnd-gtUpdateWindow()
• return TRUE
• BEGIN_MESSAGE_MAP(CMyFrame, CFrameWnd)
  ON_WM_LBUTTONDOWN()
• ON_WM_PAINT()
• END_MESSAGE_MAP()

7
MyApp.cpp (continued)

• CMyFrameCMyFrame()
• Create(NULL, "MYAPP Application")
• void CMyFrameOnLButtonDown(UINT nFlags, CPoint
  point)
• TRACE("Entering CMyFrameOnLButtonDown - lx,
  d, d\n", (long) nFlags, point.x, point.y)
• void CMyFrameOnPaint()
• CPaintDC dc(this)
• dc.TextOut(0, 0, "Hello, world!")
• Full Code

8
The program elements

• The WinMain function
• Windows requires your application to have a
  WinMain function. You don't see WinMain here
  because it's hidden inside the application
  framework.
• The CMyApp class
• An object of class CMyApp represents an
  application. The program defines a single global
  CMyApp object, theApp. The CWinApp base class
  determines most of theApp's behavior.
• Application startup
• When the user starts the application, Windows
  calls the application framework's built-in
  WinMain function, and WinMain looks for your
  globally constructed application object of a
  class derived from CWinApp.
• In a C program global objects are constructed
  before the main program is executed.

9
The program elements

• The CMyAppInitInstance member function
• When the WinMain function finds the application
  object, it calls the virtual InitInstance member
  function, which makes the calls needed to
  construct and display the application's main
  frame window. You must override InitInstance in
  your derived application class because the
  CWinApp base class doesn't know what kind of main
  frame window you want.
• The CWinAppRun member function
• The Run function is hidden in the base class,
  but it dispatches the application's messages to
  its windows, thus keeping the application
  running. WinMain calls Run after it calls
  InitInstance.
• The CMyFrame class
• An object of class CMyFrame represents the
  application's main frame window. When the
  constructor calls the Create member function of
  the base class CFrameWnd, Windows creates the
  actual window structure and the application
  framework links it to the C object. The
  ShowWindow and UpdateWindow functions, also
  member functions of the base class, must be
  called in order to display the window.

10
The program elements

• The CMyFrameOnLButtonDown function
• MFC library's message-handling capability.
• The function invokes the MFC library TRACE macro
  to display a message in the debugging window.
• The CMyFrameOnPaint function
• - The application framework calls this important
  mapped member function of
• class CMyFrame every time it's necessary
  to repaint the window at the start of
• the program, when the user resizes the
  window, and when all or part of the
• window is newly exposed.
• - The CPaintDC statement relates to the Graphics
  Device Interface (GDI) and is
• explained in later chapters. The TextOut
  function displays "Hello, world!"
• Application shutdown
• - The user shuts down the application by closing
  the main frame window.
• - This action initiates a sequence of events,
  which ends with the destruction of
• the CMyFrame object, the exit from Run,
  the exit from WinMain, and the
• destruction of the CMyApp object.

11
MFC Library Message Mapping

• The MFC library application framework doesn't use
  virtual functions for Windows messages. Instead,
  it uses macros to "map" specified messages to
  derived class member functions
• Why the rejection of virtual functions?
• What about message handlers for menu command
  messages and messages from button clicks?
• An MFC message handler requires a function
  prototype, a function body, and an entry (macro
  invocation) in the message map.
• BEGIN_MESSAGE_MAP(CMyFrame, CFrameWnd)
• ON_WM_LBUTTONDOWN()
• ON_WM_PAINT()
• END_MESSAGE_MAP()

12
Documents and Views

• Typically, MFC application will contain
  application and frame classes plus two other
  classes that represent the "document" and the
  "view."
• This document-view architecture is the core of
  the application framework
• The document-view architecture separates data
  from the user's view of the data. One obvious
  benefit is multiple views of the same data.

13
The Visual C Components

14
The Visual C Components

• Microsoft Visual C is two complete Windows
  application development systems in one product.
• You can develop C-language Windows programs using
  only the Win32 API.
• You can use many Visual C tools, including the
  resource editors, to make low-level Win32
  programming easier.
• Components
• The Project
• The Resource EditorsWorkspace ResourceView
• The C/C Compiler
• The Source Code Editor
• The Resource Compiler
• The Linker
• The Debugger
• AppWizard
• Classwizard
• overview of the Visual C application build
  process.

15
Microsoft Visual C 6.0 and the Build Process

• Visual C 6.0 in action.
• what is a project?
• A project is a collection of interrelated source
  files that are compiled and linked to make up an
  executable Windows-based program or a DLL.
• Source files for each project are generally
  stored in a separate subdirectory.
• A project depends on many files outside the
  project subdirectory too, such as include files
  and library files.
• A makefile stores compiler and linker options and
  expresses all the
• interrelationships among source files.
• A make program reads the makefile and then
  invokes the compiler,
• assembler, resource compiler, and linker to
  produce the final
• output, which is generally an executable file.

16
Contd

• In a Visual C 6.0 project, there is no makefile
  (with an MAK extension) unless you tell the
  system to export one.
• A text-format project file (with a DSP extension)
  serves the same purpose.
• A separate text-format workspace file (with a DSW
  extension) has an entry for each project in the
  workspace.
• It's possible to have multiple projects in a
  workspace, but all the
• examples in this book have just one project
  per workspace.
• To work on an existing project, you tell Visual
  C to open the DSW file and then you can edit
  and build the project.

17
VC Project Files

• Visual C creates some intermediate files too
• File Extension Description
• APS Supports ResourceView
• BSC Browser information file
• CLW Supports ClassWizard
• DEP Dependency file
• DSP Project file
• DSW Workspace file
• MAK External makefile
• NCB Supports ClassView
• OPT Holds workspace configuration
• PLG Builds log file
• Do not delete or edit in a text editor.

18
The Resource EditorsWorkspace ResourceView

• Each project usually has one text-format resource
  script (RC) file that describes the project's
  menu, dialog, string, and accelerator resources.
• The RC file also has include statements to bring
  in resources from other subdirectories.
• These resources include project-specific items,
  such as bitmap (BMP) and icon (ICO) files, and
  resources common to all Visual C programs, such
  as error message strings.
• Editing the RC file outside the resource editors
  is not recommended.
• The resource editors can also process EXE and
  DLL files, so you can use the clipboard to
  "steal" resources, such as bitmaps and icons,
  from other Windows applications.

19
The C/C Compiler

• The Visual C compiler can process both C source
  code and C source code.
• It determines the language by looking at the
  source code's filename extension.
• A C extension indicates C source code, and CPP or
  CXX indicates C source code.
• The compiler is compliant with all ANSI
  standards, including the latest recommendations
  of a working group on C libraries, and has
  additional Microsoft extensions.
• Templates, exceptions, and runtime type
  identification (RTTI) are fully supported in
  Visual C version 6.0.
• The C Standard Template Library (STL) is also
  included, although it is not integrated into the
  MFC library.

20
The Other Components

• The Source Code Editor
• Visual C 6.0 includes a sophisticated source
  code editor that supports many features such as
  dynamic syntax coloring, auto-tabbing, keyboard
  bindings
• The Resource Compiler
• The Visual C resource compiler reads an ASCII
  resource script (RC) file from the resource
  editors and writes a binary RES file for the
  linker.
• The Linker
• The linker reads the OBJ and RES files produced
  by the C/C compiler and the resource compiler,
  and it accesses LIB files for MFC code, runtime
  library code, and Windows code. It then writes
  the project's EXE file.

21
The Debugger

• The Visual C debugger has been steadily
  improving, but it doesn't actually fix the bugs
  yet. The debugger works closely with Visual C
  to ensure that breakpoints are saved on disk.
• The Visual C debugger window.

22
AppWizard

• AppWizard
• AppWizard is a code generator that creates a
  working skeleton of a Windows application with
  features, class names, and source code filenames
  that you specify through dialog boxes.
• AppWizard code is minimalist code the
  functionality is inside the application framework
  base classes.
• AppWizard gets you started quickly with a new
  application.

23
ClassWizard

• ClassWizard
• ClassWizard is a program (implemented as a DLL)
  that's accessible from Visual C's View menu.
• ClassWizard takes the drudgery out of maintaining
  Visual C class code.
• Need a new class, a new virtual function, or a
  new message-handler function?
• ClassWizard writes the prototypes, the function
  bodies, and (if necessary) the code to link the
  Windows message to the function.
• ClassWizard can update class code that you write,
  so you avoid the maintenance problems common to
  ordinary code generators.

24
Basic Event Handling, Mapping Modes, and a
Scrolling View- T8
25
Basic Event Handling, Mapping Modes, and a
Scrolling View

• The Message Handler
• void CMyViewOnLButtonDown(UINT nFlags, CPoint
  point)
• // event processing code here
• The Message Map
• BEGIN_MESSAGE_MAP(CMyView, CView)
  ON_WM_LBUTTONDOWN()
• // entry specifically for
  OnLButtonDown
• // other message map
  entries
• END_MESSAGE_MAP()
• Finally, your class header file needs the
  statement
• DECLARE_MESSAGE_MAP()

26
Invalid Rectangle Theory

• InvalidateRect triggers a Windows WM_PAINT
  message, which is mapped in the CView class to
  call to the virtual OnDraw function.
• If necessary, OnDraw can access the "invalid
  rectangle" parameter that was passed to
  InvalidateRect.
• Your OnDraw function could call the CDC member
  function GetClipBox to determine the invalid
  rectangle, and then it could avoid drawing
  objects outside it.
• OnDraw is being called not only in response to
  your InvalidateRect call but also when the user
  resizes or exposes the window.
• Thus, OnDraw is responsible for all drawing in a
  window, and it has to adapt to whatever invalid
  rectangle it gets.

27
The Window's Client Area

• The Window's Client Area
• A window has a rectangular client area that
  excludes the border, caption bar, menu bar, and
  any toolbars.
• The CWnd member function GetClientRect supplies
  you with the client-area dimensions.
• Normally, you're not allowed to draw outside the
  client area, and most mouse messages are received
  only when the mouse cursor is in the client area.
  
• CRect, CPoint, and CSize Arithmetic
• The CRect, CPoint, and CSize classes are derived
  from the Windows RECT, POINT, and SIZE
  structures, and thus they inherit public integer
  data members as follows
• CRect left, top, right, bottom
• CPoint x, y
• CSize cx, cy

28

• Mapping Modes T8
• The device context has the default mapping mode,
  MM_TEXT, assigned to it. The statement
• pDC-gtRectangle(CRect(0, 0, 200, 200))
• Windows provides a number of other mapping modes,
  or coordinate systems, that can be associated
  with the device context.
• Coordinates in the current mapping mode are
  called logical coordinates.

29
If you assign the MM_HIMETRIC mapping mode, for
example, a logical unit is 1/100 millimeter (mm)
instead of 1 pixel. In the MM_HIMETRIC mapping
mode, the y axis runs in the opposite direction
to that in the MM_TEXT mode y values decrease as
you move down. Thus, a 4-by-4-cm square is
drawn in logical coordinates this way
pDC-gtRectangle(CRect(0, 0, 4000, -4000))
30

• The MM_TEXT Mapping Mode
• In MM_TEXT, coordinates map to pixels, values of
  x increase as you move right, and values of y
  increase as you move down,
• But you're allowed to change the origin through
  calls to the CDC functions SetViewportOrg and
  SetWindowOrg.
• Here's some code that sets the window origin to
  (100, 100) in logical coordinate space and then
  draws a 200-by-200-pixel square offset by (100,
  100).
• The logical point (100, 100) maps to the device
  point (0, 0). A scrolling window uses this kind
  of transformation.
• void CMyViewOnDraw(CDC pDC)
• pDC-gtSetMapMode(MM_TEXT)
• pDC-gtSetWindowOrg(CPoint(100, 100))
• pDC-gtRectangle(CRect(100, 100, 300, 300))

31

• The Fixed-Scale Mapping Modes
• One important group of Windows mapping modes
  provides fixed scaling
• In the MM_HIMETRIC mapping mode, x values
  increase as you move right and y values decrease
  as you move down.
• The only difference among the fixed mapping modes
  is the actual scale factor, listed in the table
  shown here.
• Mapping Mode Logical Unit
• MM_LOENGLISH 0.01 inch
• MM_HIENGLISH 0.001 inch
• MM_LOMETRIC 0.1 mm
• MM_HIMETRIC 0.01 mm
• MM_TWIPS 1/1440 inch

32

• The Variable-Scale Mapping Modes
• Windows provides two mapping modes,
  MM_ISOTROPIC and MM_ANISOTROPIC, that allow you
  to change the scale factor as well as the
  origin.
• With these mapping modes, your drawing can
  change size as the user changes the size of the
  window.
• Also, if you invert the scale of one axis, you
  can "flip" an image about the other axis and you
  can define your own arbitrary fixed- scale
  factors.
• With the MM_ISOTROPIC mode, a 11 aspect ratio
  is always preserved. In other words, a circle
  is always a circle as the scale factor changes.
• With the MM_ANISOTROPIC mode, the x and y scale
  factors can change independently. Circles can
  be squished into ellipses.

33
Here's an OnDraw function that draws an ellipse
that fits exactly in its window void
CMyViewOnDraw(CDC pDC) CRect
rectClient  GetClientRect(rectClient)
pDC-gtSetMapMode(MM_ANISOTROPIC)
pDC-gtSetWindowExt(1000, 1000)
pDC-gtSetViewportExt(rectClient.right,
-rectClient.bottom) pDC-gtSetViewportOrg(rectCl
ient.right / 2, rectClient.bottom / 2) 
pDC-gtEllipse(CRect(-500, -500, 500, 500))
The functions SetWindowExt and SetViewportExt
work together to set the scale, based on the
window's current client rectangle returned by the
GetClientRect function.





 
34

• The resulting window size is exactly 1000-by-1000
  logical units.
• The SetViewportOrg function sets the origin to
  the center of the window. Thus, a centered
  ellipse with a radius of 500 logical units fills
  the window exactly.
• If you substitute MM_ISOTROPIC for MM_ANISOTROPIC
  in the preceding example, the "ellipse" is always
  a circle
• It expands to fit the smallest dimension of the
  window rectangle.

35

• The EX04B ExampleConverting to the MM_HIMETRIC
  Mapping Mode
• Use ClassWizard to override the virtual
  OnPrepareDC function.
• ClassWizard can override virtual functions for
  selected MFC base classes, including CView.
• It generates the correct function prototype in
  the class's header file and a skeleton function
  in the CPP file.
• Select the class name CEx04aView in the Object
  IDs list, and then double-click on the
  OnPrepareDC function in the Messages list. Edit
  the function as shown here
• void CEx04aViewOnPrepareDC(CDC pDC,
  CPrintInfo pInfo)
• pDC-gtSetMapMode(MM_HIMETRIC)
• CViewOnPrepareDC(pDC, pInfo)
• The application framework calls the virtual
  OnPrepareDC function just before it calls OnDraw.

36

• Edit the view class constructor. You must change
  the coordinate values for the ellipse rectangle.
  That rectangle is now 4-by-4 centimeters instead
  of 200-by-200 pixels. Note that the y value must
  be negative otherwise, the ellipse will be drawn
  on the "virtual screen" right above your monitor!
  
• Change the values as shown here
• CEx04aViewCEx04aView() m_rectEllipse(0, 0,
  4000, -4000)
• m_nColor GRAY_BRUSH

37

• Edit the OnLButtonDown function. This function
  must now convert the ellipse rectangle to device
  coordinates in order to do the hit-test. Change
  the function as shown in the following code
• void CEx04aViewOnLButtonDown(UINT nFlags,
  CPoint point)
• CClientDC dc(this)
• OnPrepareDC(dc)
• CRect rectDevice m_rectEllipse
• dc.LPtoDP(rectDevice)
• if (rectDevice.PtInRect(point))
• if (m_nColor GRAY_BRUSH)
• m_nColor WHITE_BRUSH
• else
• m_nColor GRAY_BRUSH
• InvalidateRect(rectDevice)

38
4. Build and run the EX04B program. The output
should look similar to the output from EX04A,
except that the ellipse size will be different.
If you try using Print Preview again, the
ellipse should appear much larger than it did in
EX04A.
39
Basic Event Handling, Mapping Modes, and a
Scrolling View- T8
40
Basic Event Handling, Mapping Modes, and a
Scrolling View

• The Message Handler
• void CMyViewOnLButtonDown(UINT nFlags, CPoint
  point)
• // event processing code here
• The Message Map
• BEGIN_MESSAGE_MAP(CMyView, CView)
  ON_WM_LBUTTONDOWN()
• // entry specifically for
  OnLButtonDown
• // other message map
  entries
• END_MESSAGE_MAP()
• Finally, your class header file needs the
  statement
• DECLARE_MESSAGE_MAP()

41
Invalid Rectangle Theory

• InvalidateRect triggers a Windows WM_PAINT
  message, which is mapped in the CView class to
  call to the virtual OnDraw function.
• If necessary, OnDraw can access the "invalid
  rectangle" parameter that was passed to
  InvalidateRect.
• Your OnDraw function could call the CDC member
  function GetClipBox to determine the invalid
  rectangle, and then it could avoid drawing
  objects outside it.
• OnDraw is being called not only in response to
  your InvalidateRect call but also when the user
  resizes or exposes the window.
• Thus, OnDraw is responsible for all drawing in a
  window, and it has to adapt to whatever invalid
  rectangle it gets.

42
The Window's Client Area

• The Window's Client Area
• A window has a rectangular client area that
  excludes the border, caption bar, menu bar, and
  any toolbars.
• The CWnd member function GetClientRect supplies
  you with the client-area dimensions.
• Normally, you're not allowed to draw outside the
  client area, and most mouse messages are received
  only when the mouse cursor is in the client area.
  
• CRect, CPoint, and CSize Arithmetic
• The CRect, CPoint, and CSize classes are derived
  from the Windows RECT, POINT, and SIZE
  structures, and thus they inherit public integer
  data members as follows
• CRect left, top, right, bottom
• CPoint x, y
• CSize cx, cy

43

• Mapping Modes T8
• The device context has the default mapping mode,
  MM_TEXT, assigned to it. The statement
• pDC-gtRectangle(CRect(0, 0, 200, 200))
• Windows provides a number of other mapping modes,
  or coordinate systems, that can be associated
  with the device context.
• Coordinates in the current mapping mode are
  called logical coordinates.

44
If you assign the MM_HIMETRIC mapping mode, for
example, a logical unit is 1/100 millimeter (mm)
instead of 1 pixel. In the MM_HIMETRIC mapping
mode, the y axis runs in the opposite direction
to that in the MM_TEXT mode y values decrease as
you move down. Thus, a 4-by-4-cm square is
drawn in logical coordinates this way
pDC-gtRectangle(CRect(0, 0, 4000, -4000))
45

• The MM_TEXT Mapping Mode
• In MM_TEXT, coordinates map to pixels, values of
  x increase as you move right, and values of y
  increase as you move down,
• But you're allowed to change the origin through
  calls to the CDC functions SetViewportOrg and
  SetWindowOrg.
• Here's some code that sets the window origin to
  (100, 100) in logical coordinate space and then
  draws a 200-by-200-pixel square offset by (100,
  100).
• The logical point (100, 100) maps to the device
  point (0, 0). A scrolling window uses this kind
  of transformation.
• void CMyViewOnDraw(CDC pDC)
• pDC-gtSetMapMode(MM_TEXT)
• pDC-gtSetWindowOrg(CPoint(100, 100))
• pDC-gtRectangle(CRect(100, 100, 300, 300))

46

• The Fixed-Scale Mapping Modes
• One important group of Windows mapping modes
  provides fixed scaling
• In the MM_HIMETRIC mapping mode, x values
  increase as you move right and y values decrease
  as you move down.
• The only difference among the fixed mapping modes
  is the actual scale factor, listed in the table
  shown here.
• Mapping Mode Logical Unit
• MM_LOENGLISH 0.01 inch
• MM_HIENGLISH 0.001 inch
• MM_LOMETRIC 0.1 mm
• MM_HIMETRIC 0.01 mm
• MM_TWIPS 1/1440 inch

47

• The Variable-Scale Mapping Modes
• Windows provides two mapping modes,
  MM_ISOTROPIC and MM_ANISOTROPIC, that allow you
  to change the scale factor as well as the
  origin.
• With these mapping modes, your drawing can
  change size as the user changes the size of the
  window.
• Also, if you invert the scale of one axis, you
  can "flip" an image about the other axis and you
  can define your own arbitrary fixed- scale
  factors.
• With the MM_ISOTROPIC mode, a 11 aspect ratio
  is always preserved. In other words, a circle
  is always a circle as the scale factor changes.
• With the MM_ANISOTROPIC mode, the x and y scale
  factors can change independently. Circles can
  be squished into ellipses.

48
Here's an OnDraw function that draws an ellipse
that fits exactly in its window void
CMyViewOnDraw(CDC pDC) CRect
rectClient  GetClientRect(rectClient)
pDC-gtSetMapMode(MM_ANISOTROPIC)
pDC-gtSetWindowExt(1000, 1000)
pDC-gtSetViewportExt(rectClient.right,
-rectClient.bottom) pDC-gtSetViewportOrg(rectCl
ient.right / 2, rectClient.bottom / 2) 
pDC-gtEllipse(CRect(-500, -500, 500, 500))
The functions SetWindowExt and SetViewportExt
work together to set the scale, based on the
window's current client rectangle returned by the
GetClientRect function.





 
49

• The resulting window size is exactly 1000-by-1000
  logical units.
• The SetViewportOrg function sets the origin to
  the center of the window. Thus, a centered
  ellipse with a radius of 500 logical units fills
  the window exactly.
• If you substitute MM_ISOTROPIC for MM_ANISOTROPIC
  in the preceding example, the "ellipse" is always
  a circle
• It expands to fit the smallest dimension of the
  window rectangle.

50

• The EX04B ExampleConverting to the MM_HIMETRIC
  Mapping Mode
• Use ClassWizard to override the virtual
  OnPrepareDC function.
• ClassWizard can override virtual functions for
  selected MFC base classes, including CView.
• It generates the correct function prototype in
  the class's header file and a skeleton function
  in the CPP file.
• Select the class name CEx04aView in the Object
  IDs list, and then double-click on the
  OnPrepareDC function in the Messages list. Edit
  the function as shown here
• void CEx04aViewOnPrepareDC(CDC pDC,
  CPrintInfo pInfo)
• pDC-gtSetMapMode(MM_HIMETRIC)
• CViewOnPrepareDC(pDC, pInfo)
• The application framework calls the virtual
  OnPrepareDC function just before it calls OnDraw.

51

• Edit the view class constructor. You must change
  the coordinate values for the ellipse rectangle.
  That rectangle is now 4-by-4 centimeters instead
  of 200-by-200 pixels. Note that the y value must
  be negative otherwise, the ellipse will be drawn
  on the "virtual screen" right above your monitor!
  
• Change the values as shown here
• CEx04aViewCEx04aView() m_rectEllipse(0, 0,
  4000, -4000)
• m_nColor GRAY_BRUSH

52

• Edit the OnLButtonDown function. This function
  must now convert the ellipse rectangle to device
  coordinates in order to do the hit-test. Change
  the function as shown in the following code
• void CEx04aViewOnLButtonDown(UINT nFlags,
  CPoint point)
• CClientDC dc(this)
• OnPrepareDC(dc)
• CRect rectDevice m_rectEllipse
• dc.LPtoDP(rectDevice)
• if (rectDevice.PtInRect(point))
• if (m_nColor GRAY_BRUSH)
• m_nColor WHITE_BRUSH
• else
• m_nColor GRAY_BRUSH
• InvalidateRect(rectDevice)

53
4. Build and run the EX04B program. The output
should look similar to the output from EX04A,
except that the ellipse size will be different.
If you try using Print Preview again, the
ellipse should appear much larger than it did in
EX04A.
54
The Modal Dialog and Windows Common Controls

55
Dialog Using Appwizard and Classwizard
56
The Modal Dialog and Windows Common Controls

• The two kinds of dialogs are modal and modeless.
• The CDialog base class supports both modal and
  modeless dialogs
• Modal Dialog Box
• The user cannot work elsewhere in the same
  application (more correctly, in the same user
  interface thread) until the dialog is closed.
  Example Open File dialog
• Modeless Dialog
• The user can work in another window in the
  application while the dialog remains on the
  screen
• Example Microsoft Word's Find and Replace
  dialog is a good example of a modeless dialog
  you can edit your document while the dialog is
  open.
• Controls.
• A dialog contains a number of elements called
  controls. Dialog controls include edit controls,
  buttons, list boxes, combo boxes, static text,
  tree views, progress indicators, sliders, and so
  forth.

57
Programming a Modal Dialog

• 1. Use the dialog editor to create a dialog
  resource that contains various controls.
• -The dialog editor updates the project's
  resource script (RC) file to include your new
  dialog resource, and it updates the project's
  resource.h file with corresponding define
  constants.
• 2. Use ClassWizard to create a dialog class that
  is derived from CDialog and attached to the
  resource created in step 1.
• -ClassWizard adds the associated code and header
  file to the Microsoft Visual C project.
• Use ClassWizard to add data members, exchange
  functions, and validation functions to the dialog
  class.
• 4. Use ClassWizard to add message handlers for
  the dialog's buttons and other event-generating
  controls.

58
Programming a Modal Dialog (Contd)

• Write the code for special control initialization
  (in OnInitDialog) and for the message handlers.
  Be sure the CDialog virtual member function OnOK
  is called when the user closes the dialog (unless
  the user cancels the dialog). (Note OnOK is
  called by default.)
• 6. Write the code in your view class to activate
  the dialog. This code consists of a call to your
  dialog class's constructor followed by a call to
  the DoModal dialog class member function. DoModal
  returns only when the user exits the dialog
  window.

59
Programming a Modal Dialog (Contd)

• In the CPP file, the constructor implementation
  looks like this
• CMyDialogCMyDialog(CWnd pParent /NULL/)
  CDialog(CMyDialogIDD, pParent)
• // initialization code here
• The use of enum IDD decouples the CPP file from
  the resource IDs that are defined in the
  project's resource.h

60
The Windows Common Dialogs

• Windows provides a group of standard user
  interface dialogs, and these are supported by the
  MFC library classes.
• All the common dialog classes are derived from a
  common base class, CCommonDialog.
• Class Purpose
• CColorDialog Allows the user to select
  or create a color
• CFileDialog Allows the user to open or
  save a file
• CFindReplaceDialog Allows the user to substitute
  one string for another
• CPageSetupDialog Allows the user to input page
  measurement
• parameters
• CFontDialog Allows the user to select a
  font from a list of
• available fonts
• CPrintDialog Allows the user to set up the
  printer and print a
• document

61
Using the CFileDialog Class Directly

• The following code opens a file that the user has
  selected through the dialog
• CFileDialog dlg(TRUE, "bmp", ".bmp")
• if (dlg.DoModal() IDOK)
• CFile file
• VERIFY(file.Open(dlg.GetPathName(),
  CFilemodeRead))
• The first constructor parameter (TRUE) specifies
  that this object is a "File Open" dialog instead
  of a "File Save" dialog.
• The default file extension is bmp, and .bmp
  appears first in the filename edit box. The
  CFileDialogGetPathName function returns a
  CString object that contains the full pathname of
  the selected file.

62
BITMAPS
63
Bitmaps

• Windows bitmaps are arrays of bits mapped to
  display pixels.
• There are two kinds of Windows bitmaps GDI
  bitmaps and DIBs.
• GDI bitmap objects are represented by the
  Microsoft Foundation Class (MFC) Library version
  6.0

64
Color Bitmaps and Monochrome Bitmaps

• Many color bitmaps are 16-color. A standard VGA
  board has four contiguous color planes, with 1
  corresponding bit from each plane combining to
  represent a pixel.
• The 4-bit color values are set when the bitmap is
  created. With a standard VGA board, bitmap colors
  are limited to the standard 16 colors. Windows
  does not use dithered colors in bitmaps.
• A monochrome bitmap has only one plane. Each
  pixel is represented by a single bit that is
  either off (0) or on (1). The CDCSetTextColor
  function sets the "off" display color, and
  SetBkColor sets the "on" color.
• You can specify these pure colors individually
  with the Windows RGB macro.

65
Code to load a Bitmap

• void OnPaint()
• CBitmap mybm
• CPaintDC d(this)
• mybm.LoadBitmap(IDB_BITMAP1)
• CBrush mybrush
• mybrush.CreatePatternBrush(mybm)
• d.SelectObject(mybrush)
• d.Rectangle(100,100,300,300)

66
GDI Bitmaps and Device-Independent Bitmaps

• GDI Bitmaps
• There are two kinds of Windows bitmaps GDI
  bitmaps and DIBs.
• GDI bitmap objects are represented by the
  Microsoft Foundation Class (MFC) Library version
  6.0 CBitmap class.
• The GDI bitmap object has an associated Windows
  data structure, maintained inside the Windows GDI
  module, that is device-dependent.
• Your program can get a copy of the bitmap data,
  but the bit arrangement depends on the display
  hardware.
• GDI bitmaps can be freely transferred among
  programs on a single computer, but because of
  their device dependency, transferring bitmaps by
  disk or modem doesn't make sense.

67
Device-Independent Bitmaps

• Device-Independent Bitmaps
• DIBs offer many programming advantages over GDI
  bitmaps.
• Since a DIB carries its own color information,
  color palette management is easier.
• DIBs also make it easy to control gray shades
  when printing. Any computer running Windows can
  process DIBs, which are usually stored in BMP
  disk files or as a resource in your program's EXE
  or DLL file.
• The wallpaper background on your monitor is read
  from a BMP file when you start Windows.
• The primary storage format for Microsoft Paint
  is the BMP file, and Visual C uses BMP files
  for toolbar buttons and other images.
• Other graphic interchange formats are available,
  such as TIFF, GIF, and JPEG, but only the DIB
  format is directly supported by the Win32 API.