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 document. If the user wants to save the file, he or she can click FILE -> Save. If the document was not previously saved, the application would call the Save As dialog box. If a document 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 text 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 graphical applications, 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 entry. To change their mind, regardless of what they did on the Save As dialog box, users 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 let you make a Save As dialog box available to your application, the .NET Framework provides a class named SaveFileDialog. Declare a variable of this class and initialize it using the class's default constructor as follows:
let sfd = new SaveFileDialog()
The SaveFileDialog class inherits from the FileDialog class from which it gets most of its characteristics and behaviors:
type SaveFileDialog = class inherit FileDialog end
By default, when the Save As dialog box comes up, it displays "Save As" 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:
member Title : string with get, set
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:
member Filter : string with get, set
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:
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
As mentioned earlier, after creating the dialog box, you can assign the filtering string to the Filter property. Here is an example:
let sfd = new SaveFileDialog() sfd.Filter <- "HTML Files (*.htm)|*.htm|" + "Active Server Pages (*.asp)|*.asp|" + "Apache Files (*.php)|*.php|" + "Perl Script (*.pl)|*.pl|" + "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)
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 property. To programmatically specify it, assign a value to the FileSaveDialog.FilterIndex property. Here is an example:
let sfd = new SaveFileDialog() sfd.Filter <- "HTML Files (*.htm)|*.htm|" + "Active Server Pages (*.asp)|*.asp|" + "Apache Files (*.php)|*.php|" + "Perl Script (*.pl)|*.pl|" + "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 let you specify the default extension for your FileSaveDialog object, its class is equipped withe a property named DefaultExt:
member DefaultExt : string with get, set
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 specify a default extension, assign it to the DefaultExt property of your FileSaveDialog variable. Here is an example:
let sfd = new SaveFileDialog() sfd.Filter <- "HTML Files (*.htm)|*.htm|" + "Active Server Pages (*.asp)|*.asp|" + "Apache Files (*.php)|*.php|" + "Perl Script (*.pl)|*.pl|" + "All Files|" sfd.DefaultExt <- "htm"
Once the OpenFileDialog object is ready, to display it to the user, call its ShowDialog() method. Here is an example:
let sfd = new SaveFileDialog() sfd.Filter <- "HTML Files (*.htm)|*.htm|" + "Active Server Pages (*.asp)|*.asp|" + "Apache Files (*.php)|*.php|" + "Perl Script (*.pl)|*.pl|" + "All Files|" sfd.DefaultExt <- "htm" sfd.ShowDialog() |> ignore
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:
member InitialDirectory : string with get, set
This directory usually ends with \My Documents. If you want to find the path to the My Documents folder for a user, you can call the Environment.GetFolderPath() method and pass it the Personal member of the Environment.SpecialFolder enumerator. The signature of the GetFolderPath() method is:
static member GetFolderPath : folder:Environment.SpecialFolder -> string
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 property:
member FileName : string with get, set
In practicality, the FileName value is the string that displays in the File Name box of the Save As dialog box.