MFC File Processing

Introduction to File Processing

Overview

File processing is the ability to create, store, and/or retrieve the contents of a file from a medium such as a hard drive, a floppy disk, a CD-ROM, or a DVD-ROM, etc. One of the areas in which the MFC excels is file processing. MFC makes it particularly easy to perform most file related operations.

What to Process, When, and Where

Before creating a file, you should first plan your program since applications deal with different types of files. An application that manipulate pictures may need to save only one value for the whole file. Another application used for word processing may also need to save only one value but of a completely different kind. If an application is list-based, it may need to save various values that, when put together, constitute one file.

After deciding what type of file the user would be processing, you would also specify how and/or who would decide when to process a file. For example, if you create a certain application that allows a user to change the internal settings and store them in a file, you can process the file automatically and store it somewhere without asking the user to decide when, where, or how to save the file (some applications use the Registry to take care of this). For example, in tthe bits of data that are arranged in a particular way to produce a usable document. For easy storage, location, and management, the bits are stored on a medium such as a hard disc, a floppy disc, a compact disc, or any valid and support type of storage. When these bits belong to a single but common entity, the group is referred to as a file. For even greater management, files can be stored in a parent object called a directory or a folder. Since a file is a unit of storage and it stores information, it has a size which is the number of bits it contains. To manage it, a file also has a location also called a path that specifies where and/or how the file can be retrieved. Also, for better management, a file has attributes that indicate what can be done on a file or that provide specific information that the programmer or the operating system can use when dealing with the file.

Another way you can deal with this is to let a user decide when to save the file and where to save it. This is usually taken care of by providing the File Dialog to the user.

Archiving

Introduction

Most of the file processing in an MFC application is performed in conjunction with a class called CArchive. The CArchive class serves as a relay between the application and the medium used to either store data or make it available. The CArchive class is an accessory and not an end to itself. As such, it provides its services to the MFC class that needs to perform file transfer.

Although used by MFC, the CArchive class is semi-independent. That is, it is not derived from CObject. It only provides its services to the MFC objects that need archiving. To provide this support, the parent class of MFC objects, CObject, is equipped with a method called Serialize(). The CObject::Serialize() method takes one argument, which is a CArchive reference variable. The syntax of the CObject::Serialize() method is:

virtual void Serialize(CArchive& ar);

This means that the MFC library already provides file processing at a very high level in the library's hierarchy. This also implies that almost every MFC class is ready to save its value(s) from a medium or to retrieve (an) existing value(s) from a medium. This convenience is given at a very low price, as file processing is one of MFC strengths. Based on this, to provide file processing for an object in your application, you can simply override the Serialize() method.

The Process of Archiving

One of the most regular ways you will use the CArchive class consists of storing or retrieving values through a Serialize() method. To do this directly and easily in the class, the CArchive class overloads two operators: << and >>.

To store one or more values, the CArchive class provides the << operator. The values you can store are of MFC, BYTE, short, WORD, int, unsigned int, long, LONG, DWORD, float, or double types. The class also provides an exception handler for each kind. Therefore, the syntaxes for this operator are:

friend CArchive& operator <<( CArchive& ar, const CObject* pOb );
throw( CArchiveException, CFileException );

CArchive& operator <<( BYTE by );
throw( CArchiveException, CFileException );

CArchive& operator <<( WORD w );
throw( CArchiveException, CFileException );

CArchive& operator <<( int i );
throw( CArchiveException, CFileException );

CArchive& operator <<( LONG l );
throw( CArchiveException, CFileException );			

CArchive& operator <<( DWORD dw );
throw( CArchiveException, CFileException );

CArchive& operator <<( float f );
throw( CArchiveException, CFileException );

CArchive& operator <<( double d );
throw( CArchiveException, CFileException );

As you may have realized, one version of the Serialize() member function is called once for both storing and retrieving. Therefore, when using it, you must specify what operation you want to perform. This checking process can be performed by calling the CArchive::IsStoring() Boolean method. Its syntax is:

BOOL IsStoring() const;

This method returns TRUE if you are storing data. If the answer is then TRUE, you can use the << operator to store each necessary value.

As opposed to storing value(s), to retrieve a value, the CArchive class overloads the >> operator. It comes in the following syntaxes:

friend CArchive& operator >>( CArchive& ar, CObject *& pOb );
throw( CArchiveException, CFileException, CMemoryException );

friend CArchive& operator >>( CArchive& ar, const CObject *& pOb );
throw( CArchiveException, CFileException, CMemoryException );

CArchive& operator >>( BYTE& by );
throw( CArchiveException, CFileException );

CArchive& operator >>( WORD& w );
throw( CArchiveException, CFileException );

CArchive& operator >>( int& i );
throw( CArchiveException, CFileException );

CArchive& operator >>( LONG& l );
throw( CArchiveException, CFileException );

CArchive& operator >>( DWORD& dw );
throw( CArchiveException, CFileException );

CArchive& operator >>( float& f );
throw( CArchiveException, CFileException );

CArchive& operator >>( double& d );
throw( CArchiveException, CFileException );

This indicates that you can retrieve an MFC object, a BYTE, a short, a WORD, an int, an unsigned int, a long, a LONG, a DWORD, a float, or a double value.

As mentioned above, the Serialize() method is used for both operations. Therefore, when using this method, you should first check what operation is being performed. This can be done by calling the IsLoading() method. Its syntax is:

BOOL IsLoading() const;

This method returns TRUE if you are retrieving a value or some values. If it is true, you can then use the >> operator to retrieve the value(s).

Practical Learning: Introducing File Processing

1. If you want to follow this exercise, create a new MFC Application
2. Name it Palace Ice Cream
3. Change the design of the IDR_MAINFRAME icon as follows:
    
4. Design the dialog box as follows:
    

   Control ID Caption Additional Properties Static Text   First Name:   Edit Box IDC_FIRST_NAME     Static Text   Last Name:   Edit Box IDC_LAST_NAME     Static Text   Address:   Edit Box IDC_ADDRESS     Static Text   City:   Edit Box IDC_CITY     Static Text   State:   Edit Box IDC_STATE   Static Text   ZIP Code:   Edit Box IDC_ZIP_CODE     Static Text   Hourly Salary:   Edit Box IDC_HOURLY_SALARY     Group Box   Employment Status   Radio Button IDC_PART_TIME Part Time Group: True Left Text: True Radio Button IDC_FULL_TIME Full Time Left Text: True Button IDOK     Button IDCANCEL

5. Right-click each control whose ID was specified and click Add Member Variable
6. Using the Add Member Variable Wizard, add the following member variables to the controls:
    

   Identifier	Value Variable
   IDC_FIRST_NAME	CString	m_FirstName
   IDC_LAST_NAME	CString	m_LastName
   IDC_ADDRESS	CString	m_Address
   IDC_CITY	CString	m_City
   IDC_STATE	CString	m_State
   IDC_ZIP_CODE	long	m_ZIPCode
   IDC_HOURLY_SALARY	double	m_HourlySalary
   IDC_PART_TIME	int	m_EmploymentStatus

7. Save everything 

MFC Support of File Processing

Introduction

MFC supports file processing at different levels. There is so much file processing that one of your biggest difficulties would consist of deciding what file processing system you want to use. MFC supports C, C++, Win32, and MFC file processing. Keep in mind that, as we orderly listed the systems, each is backward compatible. That is, C++ supports C and C++ file processing. Win32 supports C, C++ and its own Win32 file processing. MFC supports C, C++, Win32, and its own MFC file processing. Even if you select only one of these categories, some of them have other variances. For example, the C++ language provides more than one way to perform file processing. MFC itself is tremendously wide on this issue.

One of the classes used to perform file processing on MFC applications is CFile. Using this class, to create a file, you can first declare a variable of type CFile using one of its 3 constructors. They are;

CFile( );
CFile( int hFile );
CFile( LPCTSTR lpszFileName, UINT nOpenFlags );

The default constructor is used if you are not ready to specify the information needed to create the file.

The second constructor takes an argument that is a handle to a file created using the Win32's CreateFile() function.

The third constructor is used to create a file by specifying the file name and the flags that specify the operation to perform when saving or opening the file.

Automatic File Processing

Automatic File Processing consists of saving or opening a file with little or no intervention from the user. This technique is used to provide values that should be automatically provided to the user. This technique also allows the user to create or add a new value to a list that is deemed incomplete.

Practical Learning: Using the File Dialog Box

1. Assuming that the user would have typed information about an employee, to automatically save the file, double-click the OK button
2. Accept the suggested name of the event and implement it as follows:
    

   void CPalaceIceCreamDlg::OnOK() { // TODO: Add extra validation here // TODO: Add your control notification handler code here this->UpdateData(); CFile flEmployees; flEmployees.Open("employees.mpl", CFile::modeCreate | CFile::modeWrite); CArchive ar(&flEmployees, CArchive::store); ar << m_FirstName << m_LastName << m_Address << m_City << m_State << m_ZIPCode << m_HourlySalary << m_EmploymentStatus; ar.Close(); flEmployees.Close(); CDialog::OnOK(); }

3. Execute the application and fill the dialog with some information
    
4. Click OK to close the dialog box
5. To automatically load the saved file when the dialog box comes up, generate the WM_CREATE message for the dialog box and implement its OnCreate event as follows:
    

   int CPalaceIceCreamDlg::OnCreate(LPCREATESTRUCT lpCreateStruct) { if (CDialog::OnCreate(lpCreateStruct) == -1) return -1; // TODO: Add your specialized creation code here CFile flEmployees; flEmployees.Open("employees.mpl", CFile::modeRead); CArchive ar(&flEmployees, CArchive::load); ar >> m_FirstName >> m_LastName >> m_Address >> m_City >> m_State >> m_ZIPCode >> m_HourlySalary >> m_EmploymentStatus; ar.Close(); flEmployees.Close(); return 0; }

6. Execute the application
7. Close it and return to MSVC

File Processing Prompt 

The process we used above is used if you don't want the user to participate in saving or opening a file. In many applications, you will leave it up to the user to decide when and where to save a file or when and from where to open a file. This can be done by displaying the File Dialog box.

When a user decides to save or open a file, you can use a CFileDialog variable and call the CFileDialog::GetFileName() method to get the name of the file that the user is dealing with.

Practical Learning: Using the File Dialog Box

Document/View Architecture File Processing

The MFC library provides a more advanced and elaborate system of file processing in the internals of the document/view architecture through the CDocument class. Although this system is not the easiest and is not shared by other programming environments, once you are familiar with it, you may find it convenient.

In the Document/View architecture, a file or its content is displayed in the view while its real estate is managed by the frame. Therefore, while using a document, the user typically uses the view to manipulate the file. The trick for you is when it becomes time to save the file. Since you shouldn't manipulate the document in the document class (?), when it is time to save it, you must "transfer" the values to be saved from the view to the document class. Then let the document class handle the processing of the file. This is valid both for saving and opening the file.

Practical Learning: Processing Files in Document/View

1. Start a new application as Single Document and name it LoanEval
2. Base its view class on CFormView
3. Design the form as follows:
    

   Control ID Caption Additional Properties Group Box   Loan Preparation   Static Text   Prepared By:   Edit Box IDC_PREPARED_BY     Static Text   Prepared For:   Edit Box IDC_PREPARED_FOR     Group Box   Values   Static Text   Principal: Edit Box IDC_PRINCIPAL   Align Text: Right Static Text   Interest: Edit Box IDC_INTEREST_RATE   Align Text: Right Static Text   %   Static Text   Periods:   Edit Box IDC_PERIODS   Align Text: Center Number: True Static Text   Years   Group Box   Compound Frequency   Radio Button IDC_COMPOUND Monthly Group: True Left Text: True Radio Button   Quarterly Left Text: True Radio Button   Semiannually Left Text: True Radio Button   Annually Left Text: True Group Box       Static Text   Interest Earned   Edit Box IDC_INTEREST_TOEARN   Align Text: Right Static Text   Amount Earned   Edit Box IDC_FUTURE_VALUE   Align Text: Right Button IDC_CALCULATE_BTN Calculate Default Button: True Button IDC_RESET_BTN Reset

4. Using the Add Member Variable Wizard, add the following member variables to the controls:
    

   Identifier	Type	Value Variable
   IDC_PREPARED_BY	CString	m_PreparedBy
   IDC_PREPARED_FOR	CString	m_PreparedFor
   IDC_PRINCIPAL	double	m_Principal
   IDC_INTEREST_RATE	double	m_InterestRate
   IDC_PERIODS	UINT	m_Periods
   IDC_COMPOUND	int	m_Compound
   IDC_INTEREST_TOEARN	double	m_InterestToEarn
   IDC_FUTURE_VALUE	double	m_FutureValue

5. Change the design of the IDR_MAINFRAME icon as follows:
    
6. In the header file of the document class, declare a variable for each value that will be used in file processing:
    

   // LoanEvalDoc.h : interface of the CLoanEvalDoc class // ///////////////////////////////////////////////////////////////////////////// . . . class CLoanEvalDoc : public CDocument { protected: // create from serialization only CLoanEvalDoc(); DECLARE_DYNCREATE(CLoanEvalDoc) // Attributes public: CString strEmployee; CString strCustomer; double Principal; double InterestRate; UINT Periods; int Compound; // Operations public: . . . }; . . .

7. To prepare the file for processing, access the Serialize() event of the document and change it as follows:
    

   void CLoanEvalDoc::Serialize(CArchive& ar) { if (ar.IsStoring()) { ar << strEmployee << strCustomer << Principal << InterestRate << Periods << Compound; } else { ar >> strEmployee >> strCustomer >> Principal >> InterestRate >> Periods >> Compound; } }

8. Access the StdAfx.h header file and include the math.h header file:
    

   . . . #define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers #include <afxwin.h> // MFC core and standard components #include <afxext.h> // MFC extensions #include <afxdisp.h> // MFC Automation classes #include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls #ifndef _AFX_NO_AFXCMN_SUPPORT #include <afxcmn.h> // MFC support for Windows Common Controls #endif // _AFX_NO_AFXCMN_SUPPORT #include <math.h> . . .

9. Generate a BN_CLICKED message for the the IDC_CALCULATE_BTN control associated with the view class and accept the suggested name of the function
10. Implement it as follows:
     

    void CLoanEvalView::OnCalculateBtn() { // TODO: Add your control notification handler code here UpdateData(); double InterestToEarn; double FutureValue; int CompoundType; switch( m_Compound ) { case 0: CompoundType = 12; break; case 1: CompoundType = 4; break; case 2: CompoundType = 2; break; case 3: CompoundType = 1; break; } double i = (m_InterestRate / 100) / CompoundType; int n = CompoundType * m_Periods; FutureValue = m_Principal * pow(1 + i, n); InterestToEarn = FutureValue - m_Principal; CWnd *edtInterestToEarn = reinterpret_cast<CEdit *>(GetDlgItem(IDC_INTEREST_TOEARN)); CWnd *edtFutureValue = reinterpret_cast<CEdit *>(GetDlgItem(IDC_FUTURE_VALUE)); char InterestAmount[20], FValue[20]; sprintf(InterestAmount, "%.2f", InterestToEarn); sprintf(FValue, "%.2f", FutureValue); edtInterestToEarn->SetWindowText(InterestAmount); edtFutureValue->SetWindowText(FValue); }

11. Generate a message for the ID_FILE_SAVE menu item associated with the view class and accept the suggested name of the function
12. Implement it as follows:
     

    void CLoanEvalView::OnFileSave() { // TODO: Add your command handler code here this->UpdateData(); CLoanEvalDoc *pDoc = GetDocument(); pDoc->strEmployee = this->m_PreparedBy; pDoc->strCustomer = this->m_PreparedFor; pDoc->Principal = this->m_Principal; pDoc->InterestRate = this->m_InterestRate; pDoc->Periods = this->m_Periods; pDoc->Compound = this->m_Compound; CFile flLoan; char strFilter[] = { "Loan Files (*.onf)|*.onf|Text Files (*.txt)|*.txt|All Files (*.*)|*.*||" }; CFileDialog FileDlg(FALSE, ".bcr", NULL, 0, strFilter); if( FileDlg.DoModal() == IDOK ) { flLoan.Open(FileDlg.GetFileName(), CFile::modeCreate | CFile::modeWrite); CArchive ar(&flLoan, CArchive::store); pDoc->Serialize(ar); ar.Close(); } else return; flLoan.Close(); }

13. Generate a message for the ID_FILE_OPEN menu item associated with the view class and accept the suggested name of the function
14. Implement it as follows:
     

    void CLoanEvalView::OnFileOpen() { // TODO: Add your command handler code here UpdateData(); CLoanEvalDoc *pDoc = GetDocument(); CFile flLoan; char strFilter[] = { "BCR Files (*.onf)|*.onf|Text Files (*.txt)|*.txt|All Files (*.*)|*.*||" }; CFileDialog FileDlg(FALSE, ".bcr", NULL, 0, strFilter); if( FileDlg.DoModal() == IDOK ) { if( flLoan.Open(FileDlg.GetFileName(), CFile::modeRead) == FALSE ) return; CArchive ar(&flLoan, CArchive::load); pDoc->Serialize(ar); m_PreparedBy.Format("%s", pDoc->strEmployee); m_PreparedFor.Format("%s", pDoc->strCustomer); m_Principal = pDoc->Principal; m_InterestRate = pDoc->InterestRate; m_Periods = pDoc->Periods; m_Compound = pDoc->Compound; ar.Close(); } else return; flLoan.Close(); UpdateData(FALSE); }

15. Access the frame's source file to remove the default title and set your own as follows:
     

    // MainFrm.cpp : implementation of the CMainFrame class // . . . ///////////////////////////////////////////////////////////////////////////// // CMainFrame construction/destruction . . . int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) { if (CFrameWnd::OnCreate(lpCreateStruct) == -1) return -1; . . . this->SetWindowText("Loan Evaluation"); this->CenterWindow(); return 0; } BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs) { if( !CFrameWnd::PreCreateWindow(cs) ) return FALSE; cs.style &= ~FWS_ADDTOTITLE; return TRUE; } ///////////////////////////////////////////////////////////////////////////// // CMainFrame diagnostics . . .

16. Execute the application then create and save a record
     
    

MFC File Processing Options

In the above example, we used the CFile class to discuss file processing. MFC provides more extended file processing support than that. In reality, file processing is one of the strengths of MFC. It excels in it by providing the following classes:

FILE: FILE is a C structure used to perform file processing for that language. You can also use it in your MFC applications

CStdioFile: MFC provides the same file processing support as the C language through the CStdioFile class

Win32: The Win32 library provides its own mechanism of file processing through its HANDLE concept. A file is created using the CreateFile() function.