.NET Controls: The Save Dialog Box

When creating an application, if it is a word processor, after opening the application, it may display a white empty area in which the user can start typing. If the user is working on a spreadsheet, he or she may start typing numbers and performing calculations. In the same way, a user who is facing a graphics application would start drawing in it. The object that a user would be using is called a document. After working on it for a while, there are some other automatic ideas that come in the mind of a user. One would lead to saving the document. Another would consist of printing it. All these routine operations should be available for the user to use them. This aspect of the application is taken care of by the person who created the application; this is because not every application allows a user to save or to point its documents. If you want these operations to be possible, you must (explicitly) provide them.

To support the various operations of saving a document, opening an existing document, printing a document, setting up printing, etc, Microsoft Windows provides a series of standard dialog boxes that are available almost regardless of the programming environment you are using to develop your application. These common dialog boxes are stored in DLLs that ship with the operating system but they may be provided in a raw format. For this reason, except if programming in Win32, the programming environment you use provides a customized and friendlier technique of adding these dialog boxes to your application. In the same way, the .NET Framework provides its own implementation of these ready-made dialog boxes in a manner that makes it easier to implement them.

To use a standard Windows dialog box, from the Toolbox, click the button that corresponds to the dialog box you want to add and click anywhere on the form. The position of the control on the form has no importance because it is only a representative: it will not appear when the form is running. Once the desired dialog’s icon is on the form, place a button on the form or create a menu item that will be used to call the dialog box.

1. Start Microsoft Visual Studio .NET or Visual C++ .NET and create a new Windows Application
2. In the Toolbox, click MainMenu and click the form
3. On the form, click Type Here, type &File and press the down arrow key
4. Type E&xit
5. In the Properties window, click (Name) and type mnuFileExit
6. On the menu of the form, double-click Exit and type the following:
    

   Close();

7. Execute the application to test it

Most of the applications allow users to open or display an empty document. This indicates that such an application expects the user to create a document. Once a document has been created, a user would usually want to store its contents on a medium (hard drive, floppy disk, etc). Microsoft Windows provides a common dialog box for this purpose: The Save As dialog box:

The primary role of the Save As dialog box is to allow users to store a file on the hard drive of the computer, on a portable medium such as a floppy disk, or on a network drive. To make this efficient and complete, the user must supply two valuable pieces of information: the location and the name of the file. The location of a file is also known as its path.

The name of a file follows the directives of the operating system. On MS DOS and Windows 3.X, it had to be in an 8.3 format. The actual name had to have a maximum of 8 characters with restrictions on the characters that could be used. The user also had to specify three characters after a period. The three characters, known as the file extension, were used by the operating system to classify the file. That was all necessary for those 8-bit and 16-bit operating systems.

Various rules have changed. For example, the names of folders and files on Microsoft Windows >= 95 can have up to 255 characters. The extension of the file is mostly left to the judgment of the programmer but most files are still using extensions. Applications can also be configured to save different types of files; that is, files with different extensions.

To use the Save As dialog box, users usually click an item under the File menu. Here is how it works for most regular applications. The user creates a new file. If the user wants to save the file, he or she can click File . Save. If the file was not previously saved, the application would call the Save As dialog box. If a file is displaying, whether it was saved previously or not, the user can also click File . Save As... which also would call the Save As dialog box.

Two objects are particularly important on the Save As dialog box: The Save In combo box and the File Name edit box or combo box (the File Name box is made of a combo box to make it user-friendly but over all, users hardly use the list side of this combo box). Since Windows 95, the user does not have to specify an extension if the programmer makes it easy. To help with this, the Save As dialog box is equipped with a Save As Type combo box. This combo box allows the user to select one of the extensions. The available extensions have to be created by the programmer so the user can select from a preset list. If the programmer neglects this, the user would have no extension to select from. Although the file can still be saved, the operating system would not associate it with a known type of file. Therefore, if you specify a series of extensions, the user can select one of these and, in the File Name box, he or she can simply type a name for the file.

If the user does not specify an extension, the operating system would associate the extension of the Save As Type combo box. Users of regular commercial applications, such as word processors, spreadsheet programs, or databases, etc, are usually trained not to care about the extensions and let the application deal with that detail. In some other circumstances, the users must pay close attention to the extension they give a file. This is common on web development or graphics design because various file extensions are supported and overall produce the same end result.

After working on a Save As dialog box, users can click Save or press Enter, which would validate their entries. To change their mind, regardless of what they did on the Save As dialog box, they can click Cancel or press Esc, which would dismiss the dialog box and ignore what they did (in reality, some actions cannot be ignored, such as creating a new file or folder inside of the Save As dialog box, deleting, cutting, or pasting files, etc; but if the user clicked Cancel or pressed Esc, the new file would not be saved).

To make a Save As dialog box available to your .NET Framework application, on the Toolbox, you can click the SaveFileDialog button and click the form. To programmatically provide this dialog box, you can declare a SaveFileDialog variable and initialize it using the class default constructor as follows:

#pragma once
#using <mscorlib.dll>
#using <System.dll>
#using <System.Windows.Forms.dll>

using namespace System;
using namespace System::Windows::Forms;

public __gc class CExercise : public Form
{
	SaveFileDialog *sfd;
public:
	CExercise(void)
	{
		InitializeComponent();
		sfd = new SaveFileDialog();
	}

private:
	void InitializeComponent()
	{
		this->Text = S"File Processing";
	}
};

The SaveFileDialog class inherits from the FileDialog class from which it gets most of its characteristics and behaviors.

• In the Toolbox, click the SaveFileDialog button and click the form

To make sure that your application can open the allowed types of files, depending on your goals, you should create a list of extensions that you want the users to be able to open. The allowed extensions form a group called a filter. The filter is like a funnel that selects the good items. For a text-based application, you may allow only text files, that is, files with a txt extension. For a rich text-based application, you may allow only Rich Text Format files, which are files with rtf extension. On the other hand, if you are creating an application for web files, you can allow as many file extensions as necessary, such as htm, html, php, asp, etc. As you may realize, text files or web files are all text-based files. This means that if you create a text-based or rich-text based application, you should allow the users to decide whether the file they are trying to open can be "read" by a text-based control. To provide this ability, you can specify an unknown extension specified as All Files.

To create a list of allowable extensions for your FileSaveDialog object, you can use the Filter property from the Properties window. At run time, you can create a list of file extensions as a string. If the Save As dialog box will need only one extension, you can create the string using the following syntax:

Prompt|Extension

The Prompt is a section that defines what the user would see in the Save As Type combo box. An example would be 24-bit Bitmap. Such a string does not let the user know what actual extension the file would use. Therefore, as a courtesy, you can specify, between parentheses, the extension that would be applied if this extension is used. The Prompt can be 24-bit Bitmap (.bmp). In this case, the extension used would be bmp. The asterisk  lets the user know that whatever is provided as the file name would be used in place of the asterisk. The period indicates the separation from the file to its extension. This means that the characters on the left of the period would be the file name, the characters on the right side of the period would be used as the actual file extension.

To specify the extension that the operating system would use to associate to the file, you provide a second part of the string as Extension. In Microsoft Windows, most extensions are made of three characters. Some applications use a 2-letter extensions (for example Perl files have a pl extension) and some others use 4 letters (such as html for some HTML files). This depends on the programmer (or the company that is publishing the application). An example of a string as an extension is:

24-bit Bitmap (.bmp)|.bmp

If you want to provide various extensions to your Save As dialog box, you can separate them with a | symbol. An example would be:

HTML Files (.htm)|.htm|Active Server Pages (.asp)|.asp|Perl Script (.pl)|.pl

If you added a FileSaveDialog control to a form, as mentioned earlier, you can type the filter string in the Filter field of the Properties window. If your programmatically creating the dialog box, you can assign the string to the Filter property. Here is an example:

CExercise(void)
{
	InitializeComponent();

	sfd = new SaveFileDialog();
	sfd.Filter = S"HTML Files (*.htm)|*.htm|"
                                  S"Active Server Pages (*.asp)|*.asp|"
                                  S"Apache Files (*.php)|*.php|"
                                  S"Perl Script (*.pl)|*.pl|"
                                  S"All Files|";
}

This would produce:

A filter organizes its extensions and categories as indexes. The above filter has the following indexes:

Index 1 = HTML Files (.htm)
Index 2 = Active Server Pages (.asp)
Index 3 = Apache Files (.php)
Index 4 = Perl Script (.pl)
Index 5 = All Files;

After creating a filter, when the dialog box comes up, the Save As Type combo box displays the first index of the filter. If you want, instead of displaying the first index by default, you can specify another index. To specify the desired index at design time, change the value of the FilterIndex field in the Properties window. To programmatically specify it, assign a value to the FileSaveDialog.FilterIndex property. Here is an example:

private: System::Void button1_Click(System::Object *  sender, System::EventArgs *  e)
{
	sfd->Filter = S"HTML Files (*.htm)|*.htm|"
		    S"Active Server Pages (*.asp)|*.asp|"
		    S"Apache Files (*.php)|*.php|"
		    S"Perl Script (*.pl)|*.pl|"
		    S"All Files|";

	sfd->FilterIndex = 3;
}

Once you know the types of files that your application will be dealing with, you can make your dialog box friendly by displaying the most likely extension for a document created using your application. For example, if you create a text-based application, users are more likely to create a text file with it. If you create a rich text-based application, users are more likely to create a Rich Text Format file with it. This most likely extension is known as the default extension, it allows the user not to provide an extension in the most likely cases when saving a file. By simply providing a file name and clicking Save, the operating system would associate the file with the default extension. Of course, if you create a filter, the user can specify a desired allowed extension.

To specify the default extension for your FileSaveDialog object, type the desired extension in the DefaultExt field of the Properties window. If you had created a Filter and if you provide a default extension for a FileSaveDialog object, make sure it is one of the file extensions specified in the Filter list. To programmatically specify a default extension, assign it to the DefaultExt property of your FileSaveDialog variable. Here is an example:

CExercise(void)
{
	InitializeComponent();

	sfd = new SaveFileDialog();
	sfd->Filter = S"HTML Files (*.htm)|*.htm|"
                                    S"Active Server Pages (*.asp)|*.asp|"
	                    S"Apache Files (*.php)|*.php|"
	                    S"Perl Script (*.pl)|*.pl|"
	                    S"All Files|";
	sfd->FilterIndex = 3;
	sfd->DefaultExt  = S"htm";
}

Microsoft Windows operating systems, especially since Windows 9X, are configured to have a default folder in which users are most likely to save their files. On Windows 9X, it is C:\My Documents. On Windows NT, it is usually specified by the network administrator. On Windows 2000 and Windows XP, it uses a more customized scenario. These settings are known to the operating system and you will usually not be concerned with them. In some circumstances, if you want to specify the folder in which the users should save their files by default, you can provide it using the InitialDirectory property. This directory usually ends with \My Documents. If you want to find the path to the My Documents for a user, you can call the Environment.GetFolderPath() method and pass it the Personal member of the Environment.SpecialFolder enumerator. The syntax of the GetFolderPath() method is:

public: static String *GetFolderPath(Environment::SpecialFolder folder);

Here is an example:

private: System::Void button1_Click(System::Object *  sender, System::EventArgs *  e)
{
	String *strMyDocuments = Environment::GetFolderPath(Environment::SpecialFolder::Personal);
	this->textBox1->Text = strMyDocuments;
}

Once again, most of the time, you will not be concerned with this issue if you are creating an application for any user.

Probably the most important issue users care about, as far as they are concerned, is a name for the file they are trying to save. Users know that they can set the name of the file in the File Name box. To make this action a little faster, you can provide a default name for a file in case a user does not want to specify a file name. This is done by typing a name in the FileName field of the Properties window. In practicality, the FileName value is the string that displays in the File Name box of the Save As dialog box.

By default, when the Save As dialog box comes up, it displays "Save A" on its title bar. If you want a different caption, set the desired string in the Title field of the Properties window or assign a string to the FileSaveDialog.Title property.

1. Under the form, click the saveFileDialog1 button if necessary
   In the Properties window, click the DefaultExt field and type icf
2. Click Filter and type Ice Cream Files (.icf)|.rtf|Text Files (.txt)|.txt|All Files(.)|
3. Click Title, type Save Current Order As and press Enter
4. On the form, click File and click Type Here
5. Type &Save
6. In the Properties window, click (Name) and type mnuFileSave
7. On the form, double-click the Save menu item
8. Implement the event as follows:
    

   private: System::Void mnuFileSave_Click(System::Object * sender, System::EventArgs * e) { if( this->saveFileDialog1->ShowDialog() == DialogResult::OK ) { MessageBox::Show(String::Concat(S"The Save button was clicked or the Enter key was pressed", S"\nThe file would have been saved as ", this->saveFileDialog1->FileName)); } else MessageBox::Show(S"The Cancel button was clicked or Esc was pressed"); }

9. Execute the application. To test the Save As dialog box, on the main menu of the form, click File . Save 
10. In the File Name box, type No Argument Here
11. Click Save
12. Close the form and return to your programming environment