Without any doubt, one of the most basic and common operations in Excel is opening a workbook. Regardless of their level (beginner or advanced), virtually every single Excel user has to constantly open workbooks. In fact:
You've probably opened a countless amount of Excel workbooks yourself.
If you're working with VBA, it's only a matter of time before you need to start creating macros to open Excel workbooks. This Excel tutorial focuses on this basic and common Excel operation:
How to open a workbook using VBA.
I cover this topic by explaining 2 of the most basic macros you can use to open an Excel workbook.
This Excel VBA Open Workbook Tutorial is accompanied by an Excel workbook containing the data and basic structure macros I use. You can get immediate free access to this example workbook by subscribing to the Power Spreadsheets Newsletter.
Both of these macros rely on 1 or both of the following methods:
- The Workbooks.Open method.
- The Application.GetOpenFilename method.
Therefore, the second part of this tutorial analyzes both of these methods and goes through each of their parameters. The purpose of this section is to help you get some basic awareness of some of the things you can do when using these methods in your macros.
You'll also notice that, in addition to help you open workbooks using VBA, the Application.GetOpenFilename method allows you to specify the paths and names of particular Excel workbooks. You'll likely encounter situations where knowing this can come in handy. The reason for this, as stated by Mr. Excel (Bill Jelen) and Excel expert Tracy Syrstad in Excel 2013 VBA and Macros, is that:
One of the most common client interactions is when you need the client to specify a path and filename.
So let's take a look at the exact topics that I explain in this blog post:
And let's start by taking a look at what is, perhaps, the simplest case of opening an Excel workbook using VBA:
How To Open A Workbook Using VBA: The Basic Case
Within Visual Basic for Applications, the method that opens an Excel workbook is the Workbooks.Open method.
The Workbooks.Open method has 15 optional arguments. Each of these 15 optional arguments allows you determine a different aspect of how the Open method opens an Excel workbook.
Since taking a look at 15 arguments at once can get a little overwhelming, let's start by taking a look at the most basic case: opening an Excel workbook whose name you know. You specify which workbook you want to open by using the Filename argument.
More specifically, the basic VBA statement syntax to open a particular workbook is:
Where “File_Name” is the file name of the workbook that you want to open with VBA. As shown in the example below, when specifying the workbook's file name, you must provide the full path and name of the file. I explain how to make this easier below.
The first sample statement above uses named arguments (Filename:=”File_Name”). For the reasons that I explain here, this is my preferred syntax. However, you can also use the second syntax (simply “File_Name”.
Let's take a look at the Workbooks.Open method in practice:
The following macro (named Open_Workbook_Basic), opens the Excel workbook whose name is “Example – VBA open workbook”. This workbook is saved in the D drive.
As mentioned above, notice that when specifying the filename, you must provide the whole file path, name and extension.
The sample file path above is relatively simple. In particular, there's no need to go through several sub-folders in order to get to the sample workbook. However…
Probably not many people are able to remember the exact file paths, names and extensions for the files in their laptop. And even then, few would want to type the whole thing every time a new Excel workbook is to be opened. In the words of Excel guru John Walkenbach (in Excel 2013 Power Programming with VBA):
(…) this approach is tedious and error-prone because the user must type the filename (with no browsing capability).
Since you want to ensure that your macro receives the correct file name (including the whole path and its extension), you'll usually use slightly more complicated macros than the sample Open_Workbook_Basic Sub procedure displayed above.
Let's take a look at the simplest way to do this: replicating the way Excel usually works when you browse the computer drive in order to find the particular file you want to open.
How To Open A Workbook Using VBA: Get The File Path With The GetOpenFilename Method
You're probably quite familiar with the following dialog box:
This is the Open dialog box. Excel displays this dialog whenever you browse for purposes of finding and selecting a file to open.
Usually, whenever Excel displays the Open dialog box, you simply need to:
- Navigate to the folder containing the Excel workbook you want to open.
- Select the file to be opened and click on the Open button in the lower-right corner of the Open dialog.
The following screenshot shows how the Open dialog looks like if you were to open the workbook named “Example – VBA open workbook” that the Open_Workbook_Basic macro above opens.
You'll probably agree with me that using this method of choosing the particular Excel workbook that you want to open is much easier than remembering the full file path.
Fortunately, you can replicate this way of operating with VBA. More precisely, you do this by using the Application.GetOpenFilename method.
Excel's Application.GetOpenFilename method does 2 things:
- Displays a customizable Open dialog box; and
- Returns the full path/name/extension of the file chosen by the user.
The Application.GetOpenFilename method doesn't open the file chosen by the user. You still need to rely on the Workbooks.Open method explained above for purposes of actually opening the chosen file. As explained by Microsoft MVP Jon Peltier, GetOpenFilename simple provides “a mechanism to ask the user for the names of the files that the calling procedure will process later”.
However, as explained here, the fact that GetOpenFilename doesn't actually open the file makes this a very versatile method. The reason is that this allows you to use this precise same method in cases in which you need to get the path/name/extension of an Excel workbook for purposes other than opening it.
Therefore, in order to open an Excel workbook through the Open dialog box while using VBA, you need to use both of the following methods:
- Item #1: The Application.GetOpenFilename method returns the name of the workbook to be opened.
- Item #2: The Workbooks.Open method actually opens the workbook whose path/name/extension is provided by the Application.GetOpenFilename method.
The Application.GetOpenFilename method has 5 variables. However, just as we did with the Workbooks.Open method, let's take a look at a very basic piece of VBA code that allows you to:
- Browse the available drives for purposes of finding and selecting the Excel workbook you want to open; and
- Actually open the selected file.
In such a case, the syntax of the basic VBA statements that you need is as follows:
Dim my_FileName As Variant
my_FileName = Application.GetOpenFilename(FileFilter:=”Excel Files,*.xl*;*.xm*”)
If my_FileName <> False Then
The following screenshot shows the full VBA code of a sample macro called “Open_Workbook_Dialog”.
This Excel VBA Open Workbook Tutorial is accompanied by an Excel workbook containing the data and basic structure macros I use (including the Open_Workbook_Dialog macro). You can get immediate free access to this example workbook by subscribing to the Power Spreadsheets Newsletter.
Let's take a look at each of the statements that makes part of the Open_Workbook_Dialog macro to understand how it proceeds:
Statement #1: Dim my_FileName As Variant
This particular statement is a variable declaration statement. As explained by Michael Alexander in 101 Ready-To-Use Excel Macros, the purpose of declaring a variable in this macro is to store the file name chosen by the user.
This variable declaration statement can be divided in the following 3 items:
Item #1: Dim Statement
As I explain in this macro tutorial, the Dim statement is the most common way to declare a VBA variable.
Item #2: Variable Name
In this particular case, the name of the variable being declared is “my_FileName”.
Item #3: Data Type
my_FileName is declared as being of the Variant data type.
The reason why this variable is declared as a Variant is because, as explained in Excel VBA Programming for Dummies, the Application.GetOpenFilename method can return different types of data.
Statement #2: my_FileName = Application.GetOpenFilename(FileFilter:=”Excel Files,*.xl*;*.xm*”)
This VBA statement is characterized by the following 2 aspects:
- Makes an assignment to the VBA variable my_FileName; and
- Uses the GetOpenFilename method that I introduce above.
For purposes of carrying out a closer examination of this statement, I divide it in the following 3 items:
Let's take a look at each of them separately:
Item #1: my_FileName =
The first part of the statement follows the general rule in which a value or expression is assigned to a VBA variable, by using the equal sign (=).
In these cases, the equal sign (=) is an assignment operator. Therefore, it doesn't represent an equality.
In the case of the Open_Workbook_Dialog macro, the equal sign (=) is assigning:
- The result of the expression that appears to its right (which I explain in the next section below); to
- The VBA variable that is on the left side (my_FileName).
Let's take a look at the items on the right side of the equal sign:
Item #2: Application.GetOpenFilename
This item is the reference to the Application.GetOpenFilename method. As explained above, this particular method:
- Displays a customizable Open dialog box; and
- Returns the file name chosen by the user (without actually opening it).
If the user selects multiple files (you can determine this by using the MultiSelect argument I explain below, GetOpenFilename returns an array of the file names chosen by the user. This is the case even if the user only selects 1 file.
If the user cancels the Open dialog box (for example, presses the Cancel button), GetOpenFilename returns False.
This leads us to the last item of the statement:
Item #3: (FileFilter:=”Excel Files,*.xl*;*.xm*”)
FileFilter is one of the different parameters of the GetOpenFilename method. As implied by its name, this argument allows you to specify criteria for file-filtering.
It's an optional argument. However, I include it for purposes of specifying file filtering criteria.
If you omit the FileFilter argument when using the GetOpenFilename method, it defaults to all files (*.*).
In the sample VBA code that appears above (and throughout the rest of this Excel tutorial), I use named arguments. However, that's not mandatory. If you don't want to use named arguments, you can use the following statement syntax:
my_FileName = Application.GetOpenFilename(“Excel Files,*.xl*;*.xm*”)
Let's take a look at the characteristics of the FileFilter argument:
Characteristic #1: What Does The FileFilter Argument Do.
As explained above, FileFilter determines what are the criteria used for filtering files when the Open dialog box is displayed.
In more practical terms, the FileFilter argument determines what appears in the Files of type drop-down list box on the lower-right corner of the Open dialog box. As shown in the image below, in the case of the Open_Workbook_Dialog macro there's only one item in the Files of type drop-down list box (Excel Files):
Characteristic #2: Syntax Of The FileFilter Argument.
The appropriate syntax of the FileFilter Argument is determined by the following rules:
- Rule #1: Each individual filter is specified by pairing 2 strings as follows:
Part #1: A descriptive string which, in the words of Excel expert Dick Kusleika, “can be pretty much anything you want”. You can omit this part, although I wouldn't recommend it.
In the case of the sample Open_Workbook_Dialog macro, this is “Excel Files”. Notice (in the image above) how this is the text that actually appears in the Files of the type drop-down list of the Open dialog box.
Part #2: A comma (,) separating part #1 above and part #2 below.
Part #3: As explained by Microsoft, this is the actual MS-DOS wildcard file-type filter specification. In other words, this part determines how the files are filtered, depending on their type.
In the Open_Workbook_Dialog macro, this part is *.xl*;*.xm*.
- Rule #2: As explained at Daily Dose of Excel, the structure of the file types that you use in the filter specification (part #3 above) is generally (i) an asterisk (*), (ii) a dot (.), and (iii) an indication of the file extension using an asterisk (as wildcard, if necessary) and (if necessary) letters. At the most basic level, the way to specify all files is asterisk dot asterisk (*.*).
For example, the Open_Workbook_Dialog macro uses the following 2 file type specifications: *.xl* and *.xm*. Notice how, in both cases: (i) there is an asterisk (*) followed by (ii) a dot (.) and (iii) the first 2 letters of the file extension (xl and xm) followed by an asterisk (*) used as wildcard. Due to the wildcard asterisk, these 2 specifications cover any file extension beginning with .xl (such as .xlsx, .xlsm, .xlsb, .xltx, .xltm, .xls, .xlt, .xlam, .xla and .xlw) or .xm (.xml).
- Rule #3: As shown by the fact that the Open_Workbook_Dialog macro uses 2 file type specifications, you can include 1 or several file types in a particular filter. When including more than 1 file type in a particular filter, you must separate them with a semi-colon (;).
Notice how this is the case in the macro under analysis. More precisely, .xl* and *.xm* are separated by a semi-colon (;) (*.xl*;*.xm*).
- Rule #4: In addition to the possibility of using multiple file-types, you can create more than 1 actual filter. In such a case, you separate the filters using commas (,).
The sample Open_Workbook_Dialog macro above only has one filter. This is determined by the string pairing “Excel Files,*.xl*;*.xm*”. You can, however, separate this single filter into 2 filters (displaying “xl Files” for *.xl* and “xm Files” for *.xm*) as follows:
The way to get these 2 filters is to replace the single string pairing “Excel Files,*.xl*;*.xm*” with the following: “xl Files,*.xl*,xm Files,*.xm*”.
Summary Of Statement #2
The final effect of the whole statement explained above is as follows:
- #1: The Open dialog box is displayed to allow the user to select a file.
- #2: If the user selects a file, its file name is assigned to the variable called my_FileName.
This leads us to the last statement of the Open_Workbook_Dialog macro, which uses the value of the my_FileName variable.
Statement #3: If my_FileName <> False Then Workbooks.Open FileName:=my_FileName
This is an If… Then… Else statement. These type of statements proceed as follows:
- Step #1: Carry out a test to determine whether a particular condition is met.
- Step #2: If the condition is met, a certain group of statements are executed.
If the condition isn't met, the statements aren't executed.
In the case of the Open_Workbook_Dialog macro, the If… Then… Else statement proceeds as follows:
Step #1: Determine Whether The User Has Select a Workbook
Statement #2 (explained above) assigns the file selected by the user to the variable my_FileName. If the user fails to select a file (by, for example, cancelling the operation), my_FileName returns False.
The test carried out by the If… Then… Else statement under analysis checks whether the my_FileName variable has been assigned a particular file path/name/extension by testing the condition “my_FileName <> False”.
In other words, the condition “my_FileName <> False” is met only when the user has chosen a particular workbook in the Open dialog box displayed by the Application.GetOpenFilename method.
If the condition is met, the If…Then… Else statement proceeds to:
Step #2: Open Excel Workbook
The second part of the If… Then… Else statement we're looking at is “Workbooks.Open FileName:=my_FileName”.
You already know what this statement does. It's the Workbooks.Open method described above.
The purpose of the Workbooks.Open method is to open an Excel workbook. In this case, the workbook that is opened is that whose file name has been assigned to the variable my_FileName.
In other words, if the user selects a file when the Open dialog box is displayed, the If… Then… Else statement opens that file.
The Workbooks.Open Method: A Closer Look
As explained at the beginning of this Excel tutorial, Workbooks.Open is the method that you'll generally use to open Excel workbooks using VBA.
We have already seen the basics of the Workbooks.Open method and its most basic use above. However, in that particular case, I mentioned that this method has 15 different parameters. So far, we've only checked one: FileName.
I assume that, if you're reading this, you want to learn about some more advanced cases of opening Excel workbooks using VBA. In order to do this, let's take a closer look at the Workbooks.Open method and its different parameters.
The Workbooks.Open Method: Full Syntax
The full syntax of the Workbooks.Open method in Visual Basic for Applications is as follows:
expression.Open(FileName, UpdateLinks, ReadOnly, Format, Password, WriteResPassword, IgnoreReadOnlyRecommended, Origin, Delimiter,Editable, Notify, Converter, AddToMru, Local, CorruptLoad)
In this case, “expression” stands for a variable representing a Workbook object. In most cases, however, you can simply rely on the syntax used in the sample Open_Workbook_Basic and Open_Workbook_Dialog macros.
In other words, you'll generally replace “expression” with the Workbooks object itself:
All of the parameters of the Workbooks.Open method, which appear within parentheses above, are optional. Let's take a look at them!
Parameters Of The Workbooks.Open Method
The following table introduces the 15 optional parameters of the Workbooks.Open method.
|1||FileName||Name of workbook to be opened.|
|2||UpdateLinks||Way in which external references/links in the file are updated.|
|3||ReadOnly||Determines whether workbook opens in read-only mode.|
|4||Format||Applies when opening a text file.
Determines the delimiter character.
|5||Password||Password required to open protected workbook.|
|6||WriteResPassword||Password required to write in a write-reserved workbook.|
|7||IgnoreReadOnlyRecommended||Applies when a workbook is saved with Read-Only Recommended option enabled.
Determines whether the read-only recommended message is displayed.
|8||Origin||Applies when opening a text file.
Indicates where the file originated.
|9||Delimiter||Applied when opening a text file and the Format parameter above (No. 4) is a custom character.
Specifies what is the custom character to be used as delimiter.
|10||Editable||Applies to: (i) old Excel add-ins (created in Excel 4.0) and (ii) templates.
When applied to an Excel 4.0 add-in, it determines whether add-in is opened as hidden or visible.
If applied to a template, it determines whether template is opened for editing or if a new workbook (based on the template) is created.
|11||Notify||Applies when a file can't be opened in read/write mode.
Determines whether file is added to file notification list or no notification is requested.
|12||Converter||Determines what file converter to try upon opening the file.|
|13||AddToMru||Determines whether file is added to list of recent files.|
|14||Local||Determines whether file is saved against language of Excel (usually local) or VBA (usually US-English).|
|15||CorruptLoad||Determines the processing of the file when opened|
I provide a more detailed description of the parameters in the sections below. The only exception is the FileName argument, which I explain above.
However, let's take a closer look at the other parameters:
Argument #2: UpdateLinks
The UpdateLinks argument is the one you can use if you're interested in determining whether the external references or links within the opened Excel workbook are or aren't updated.
In other words, UpdateLinks determines how those external references or links are updated. The UpdateLinks parameter can take the following 2 values:
- 0: In this case, external references/links aren't updated when the Excel workbook is opened.
- 3: When using this value, the external references/links are updated when the workbook opens.
The following screenshot shows the VBA code of the sample Open_Workbook_Basic macro where the UpdateLinks parameter has been added and is set to 3.
Since the UpdateLinks parameter isn't required, you can omit it. In that case, Excel generally defaults to asking the user how links are updated.
Argument #3: ReadOnly
If you set the ReadOnly argument to True, the Excel workbook is opened in read-only mode.
When this argument is added to the sample Open_Workbook_Basic macro, the VBA code looks as follows:
In this case, the Excel workbook is opened as read-only, meaning that any changes made aren't saved.
When I execute the Open_Workbook_Basic macro, Excel warns me about the opened workbook being read-only. Check out, for example, the screenshot below:
Arguments #4 and#9: Format and Delimiter
The Format argument of the Workbooks.Open method is only relevant when opening text files.
Format determines what the delimiter character is. As explained in the Knowledge Base of Drexel University, the delimiter is what allows you to split a single piece of content into different cells. By choosing the value of the Format argument, you specify what delimiter is used.
The following are the possible Format values and the delimiter each of them represents:
- 1: Tabs.
- 2: Commas.
- 3: Spaces.
- 4: Semicolons.
- 5: Nothing.
- 6: A custom character, which you then specify by using the Delimiter argument.
The Delimiter argument must be a string. Also, the Delimiter is a single character. If you enter a longer string, the first character of the string is used as delimiter.
If you omit the Format argument when opening a text file, Excel uses whatever delimiter is currently being used.
Since the Open_Workbook_Basic macro makes reference to the Excel workbook named “Example – VBA open workbook.xlxs”, the Format argument isn't really useful. However, for illustration purposes, the following screenshot shows the VBA code behind this macro using this argument for purposes of setting spaces as the delimiter.
The following image shows how the VBA code looks like if the Format argument is set to 6 (custom delimiter) and the Delimiter argument is defined as ampersand (&).
Arguments #5 and #6: Password and WriteResPassword
You'd generally use the Password and WriteResPassword arguments when you're working with Excel workbooks that are protected or write-reserved.
Both the Password and WriteResPassword are strings representing a particular password. Their main difference is on what type of protection the Excel workbook being opened has. More precisely:
- Password: Is the password required to open a protected Excel workbook.
- WriteResPassword: Is the password required to write in a write-reserved workbook.
If you're opening an Excel workbook that anyway requires a password and you omit the relevant argument (Password or WriteResPassword, as the case may be), Excel asks the user for the appropriate password.
Let's assume, for illustrative purposes, that the “Example – VBA open workbook.xlsx” opened by the Open_Workbook_Basic macro is protected by the password “VBA open workbook”. The following screenshot displays the VBA code of the macro with the appropriate Password argument:
Argument #7: IgnoreReadOnlyRecommended
Set a particular Excel workbook to be read-only recommended by activating the Read-Only Recommended option when saving the relevant workbook.
The consequence of this is that, when the read-only recommended workbook is opened, Excel displays a message recommending that the workbook is opened as read-only.
If the IgnoreReadOnlyRecommended argument is set to True, Excel doesn't display this particular message when opening the workbook.
The following screenshot displays the VBA code of the of the Open_Workbook_Basic macro with the IgnoreReadOnlyRecommended argument.
Note that, in this particular case, I've deleted the previously added ReadOnly argument. The reason for this is that, if both the ReadOnly and IgnoreReadOnlyRecommended arguments are set to True, Excel simply opens the workbook in read-only mode as required by the ReadOnly argument.
Argument #8: Origin
The Origin argument is only applicable when opening text files. You can use Origin to specify the platform (Microsoft Windows, Mac or MS-DOS) in which the file originated. Indicating the origin of the file allows Excel to map (i) code pages and (ii) Carriage Return/Line Feed properly.
The Origin argument generally takes one of the XlPlatform values, as follows:
- 1: xlMacintosh.
- 2: xlMSDOS.
- 3: xlWindows.
If you omit the Origin argument, Excel uses the operating system of the computer that is opening the file.
The file named “Example – VBA open workbook.xlsx” that is opened by the Open_Workbook_Basic macro isn't a text file. Therefore, I include the Origin argument in the screenshot below (specifying the origin as Microsoft Windows) only for illustrative purposes:
Argument #9 (Delimiter) is explained above.
Argument #10: Editable
The Editable argument applies to the following types of files:
- Microsoft Excel 4.0 add-ins.
You'll probably not work too much with these because it's quite an old format. To give you an idea: Excel 4.0 was released in 1992. Editable doesn't apply to any add-ins that have been created in later versions of Excel.
- Excel templates.
The Editable parameter of the Workbooks.Open method works differently depending on which of the above files you're working with. The general rules are as follows:
When working with Microsoft Excel 4.0 add-ins:
- Setting Editable to True, opens the relevant add-in in a visible window.
- Setting Editable to False (which is the default value), opens the add-in as hidden. Additionally, the add-in can't be unhidden.
When working with a template:
- Setting Editable to True opens the template for editing.
- Setting Editable to False (the default value), opens a new Excel workbook that is based on the relevant template.
The workbook opened by the sample Open_Workbook_Basic property is neither a Microsoft Excel 4.0 add-on nor a template. Therefore, the Editable parameter isn't applicable.
However, for illustrative purposes, the following is an example of how the VBA code to open “Example – VBA open workbook.xlsx” workbooks looks like with the Editable parameter set to True:
Argument #11: Notify
The Notify argument of the Workbooks.Open method applies when you're opening a file that can't be opened in read/write mode. If you set the Notify argument to True, Visual Basic for Applications proceeds as follows whenever it encounters such a file:
- Step #1: The file is opened as read-only and added to the file notification list.
The file notification list stores files that could only be opened in read-only mode.
- Step #2: The status of the file notification list is checked to confirm when the file is available.
In more precise terms, the file notification list is polled.
- Step #3: When the file becomes available, the user is notified about this.
If you omit the Notify argument, or set it to False:
- The file isn't added to the file notification list. In other words, no notification that the file is available is requested or received.
- The attempt to open a file that isn't available simply fails.
The following screenshot shows the VBA code of the sample Open_Workbook_Basic macro with the Notify argument set to True:
Argument #12: Converter
The Converter argument is applicable whenever you want/need to use file converters. More precisely, you use the Converter parameter to specify the file converter that should be used first when Visual Basic for Applications tries to open a file.
In order to know how to specify a particular file converter, you need to understand the Application.FileConverters property. This property returns information about any file converters that are currently installed.
For example, if you use the Application.FileConverters property without specifying its arguments, the property returns an array with information about all the file converters that are installed. The array is organized as follows:
- The number of rows is equal to the number of installed file converters.
Each converter has its own row.
- The number of columns is 3.
The first column displays the long name of the relevant file converter. The second column contains the path of the converter's DLL or code resource. The third column shows the file-extension search string.
When working with the Converter argument, you'll be interested in the row numbers. The reason for this is the way in which you specify the first file converter to use when opening a file:
- The Converter argument is an index.
- Each file converter has such an index.
- The index is the row numbers of the file converters that the Application.FileConverters property (explained above) returns.
There may be situations in which the file converter that you specify with the Converter argument (which is tried first) doesn't recognize the file being opened. In such cases, as explained by Microsoft, “all other converters are tried”.
Argument #13: AddToMru
AddToMru determines whether the Excel workbook that is being opened is added to the list of recently used files or not. MRU stands for Most Recently Used.
The most recently used list is the list of files that have been recently opened in Excel. You can generally find it in the Open tab of the Backstage View.
The default value of AddToMru is False. In this case, the workbook isn't added to the list of recently used files.
In order to have the Excel workbook added to the list of recently used files, set AddToMru to True. The image below shows how this looks like in the case of the Open_Workbook_Basic macro:
Argument #14: Local
The Local parameter makes reference to language and localization settings. Therefore, you may encounter/use this argument if the macro you're creating is to be used in an international setting where some computers may have different language settings.
More precisely, Local determines against which language are files saved. There are 2 possible values: True or False. Depending on the value you choose, files are saved as follows:
- True: Files are saved against Excel's language.
This language is generally determined from the control panel settings.
- False: Files are saved against VBA's language.
This language is generally English.
As explained by Microsoft here, there is a relatively obscure exception to this rule. This exception is when the VBA project containing the Workbooks.Open method is an old internationalized XL5/95 project. My guess is that the likelihood of you encountering such a file nowadays is about as high as that of finding the Microsoft Excel 4.0 add-ins which I refer to above.
The following image shows how the Local argument looks like when added to the sample Open_Workbook_Basic macro:
Argument #15: CorruptLoad
This is the final argument of the Workbooks.Open method. CorruptLoad determines how a file that has been corrupted is processed upon opening.
The CorruptLoad argument can take 1 of the following 3 values:
- 0: Represents xlNormalLoad. In this case, the Excel workbook is opened normally.
This is the default value, and applies if you don't specify anything else.
- 1: Stands for xlRepairFile. In such a case, the Excel workbook is opened in repair mode.
In repair mode, Excel tries to recover as much as possible of the workbook being opened.
- 2: Is the value for xlExtractData. When using this processing mode, the workbook is opened in extract data mode.
In extract data mode, Excel “extracts values and formulas from the workbook“. Generally, you use extract data mode when the repair mode fails to recover the data/workbook appropriately.
In the following screenshot, the VBA code of the Open_Workbook_Basic macro includes the CorruptLoad parameter. In this case, CorruptLoad is set to 1 (xlRepairFile).
When executing this macro, Excel opens the “Example – VBA open workbook” file in repair mode and displays the following message:
The first time I read the arguments of the Workbooks.Open method, I was slightly surprised that there was no argument to determine whether macros are enabled or disabled upon opening an Excel workbook using VBA.
Eventually, I found out…
How To Enable Or Disable Macros In An Excel Workbook Opened With VBA
As mentioned here, macros are enabled by default whenever you open a file programmatically.
In order to modify the macro security setting that applies when opening an Excel workbook programmatically, you use the Application.AutomationSecurity property. This property allows you to set the security mode that Excel uses when opening files programmatically.
You can generally set the Application.AutomationSecurity property to any of the following 3 constants:
- 1: Represents msoAutomationSecurityLow which enables all macros.
As mentioned at the beginning of this section, msoAutomationSecurityLow is the default value.
- 2: Stands for msoAutomationSecurityByUI. In this case, the actual security setting is set through the Security dialog box.
- 3: This is called msoAutomationSecurityForceDisable. This security mode disables all macros and doesn't show any alerts.
This restriction doesn't apply to Microsoft Excel 4.0 macros. If you open (programmatically) an Excel workbook containing such type of macros, Excel anyway asks the user if the file should be opened or not. This is the case even if the property is set to msoAutomationSecurityForceDisable.
Generally, as suggested by Microsoft, you may want to reset Application.AutomationSecurity to the default (msoAutomationSecurityLow) after opening the appropriate Excel workbook and before ending the relevant Sub. This reduces the risk of having problems later when a particular solution relies on that default value.
The Application.GetOpenFilename Method: A Closer Look
I introduce and explain the basics of the Application.GetOpenFilename method at the beginning of this Excel tutorial.
The main reason to use the Application.GetOpenFilename method is that it allows your users to select the Excel workbook they want to open without having to remember or type the full path/name/extension. This has 2 main advantages:
- Advantage #1: Generally, using the Application.GetOpenFilename is more user-friendly than simply relying on the Workbooks.Open method.
- Advantage #2: The Application.GetOpenFilename ensures that the FileName parameter of the Workbooks.Open method is correct. In other words, GetOpenFilename pretty much guarantees that the path/name/extension argument used by the Open method is valid.
The Application.GetOpenFilename method has 5 arguments. In the sample Open_Workbooks_Dialog macro I've only used 1 (FileFilter).
In order to see which other settings you can work with, let's take a closer look at the syntax of GetOpenFilename and its 4 other parameters:
The Application.GetOpenFilename Method: Full Syntax
The following is the full syntax of the Application.GetOpenFilename method:
expression.GetOpenFilename(FileFilter, FilterIndex, Title, ButtonText, MultiSelect)
“expression” stands for a variable representing an Application object. In practice, you're like to end up simply using the Application object itself instead of such a variable. Therefore, you're likely to commonly use the following syntax:
This is, for example, the syntax used in the Open_Workbook_Dialog macro, as shown below:
I explain the FileFilter argument of the Application.GetOpenFilename method above. Let's continue to dissect this helpful method by taking a look at the other 4 available parameters:
Parameters Of the Application.GetOpenFilename Method
The following table lists and introduces the 5 parameters of the GetOpenFilename method. All of these arguments are optional.
As explained at dailydoseofexcel.com, the arguments of the Application.GetOpenFilename method generally focus on the possibility of making some minor modifications to the Open dialog.
|1||FileFilter||Determines file filters.|
|2||FilterIndex||Determines the default file filter.|
|3||Title||Determines the title of the (usually called) Open dialog box.|
|4||ButtonText||Applies only when working in the Mac platform.
Determines the text of the button.
|5||MultiSelect||Determines whether the user can select multiple files or not.|
I explain all of these arguments (except FileFilter) in more detail below.
Argument #2: FilterIndex
You determine the file filtering criteria using the FileFilter argument. Since this argument allows you to create several filters, Excel needs a way to determine which the default one is.
Here is where the FilterIndex argument comes in:
It “specifies the index numbers of the default file filtering criteria“.
To understand how the FilterIndex parameter works in practice, take a look at the following Open dialog. Notice that there are 2 filters (xl Files and xm Files) in the Files of type drop-down list box.
This Open dialog box is displayed when the following version of the Open_Workbook_Dialog macro is executed. Notice how the FileFilter parameter sets 2 file-filtering criteria but there's no FilterIndex argument.
When you omit the FilterIndex argument, Excel displays the first filter. In the case above, this filter is xl Files.
Let's assume, however, that you want a different filter to be displayed as default. The following image shows how you can modify the Open_Workbook_Dialog macro to add the FilterIndex argument and select the second filter (xm Files) as the default filter.
The resulting Open dialog box looks as follows. Notice that, now, the default filter is indeed xm Files, even though it continues to be in the second position within the Files of type drop-down list box.
In the image above, you may also notice that the sample Excel workbook named “Example – VBA open workbook.xlsx” doesn't appear as it does in previous screenshots. This is because it has been filtered out by the xm Files filter.
The xm Files filter is used to display only files whose extension begins with the letters “xm”. These are generally files that use the .xml format. In fact, the xm File filter can probably be specified more specifically with the string pair “xm Files,*.xml”.
The FilterIndex argument can only take values between 1 and the number of file filters that you've specified with the FileFilter argument. In the case above, this upper limit is 2.
If you set a value that is larger than the number of filters that actually exist, Excel uses the first file filter. In the case of the Open_Workbook_Dialog macro above, this would happen whenever the FilterIndex parameter has a value equal to or larger than 3. The VBA code for this case appears in the following image:
In this case, the Open dialog box is as follows. Notice how, as expected, the default filter is xl Files (the first filter).
Argument #3: Title
The Title argument of the Application.GetOpenFilename method is kind self-explanatory:
It allows you to determine the title of the dialog box that is usually known as the Open dialog. As you probably expect, if you omit this parameter, the title of the dialog box is “Open”.
The following image shows how the VBA code behind the Open_Workbook_Dialog macro looks like if the Title argument is set to “Example VBA Open Workbook”:
Notice how the new title appears at the top of the (previously Open) dialog box:
Argument #4: ButtonText
The ButtonText only applies in Mac platforms. When used in Windows, the argument is ignored (as explained in Excel VBA Programming for Dummies).
It allows you to determine the text that appears in the action button. This is the button regularly known as the Open button.
The fact that you can't change the text of the Open button when working in Windows may lead to slightly confusing situations:
Imagine, for example, that you're using the GetOpenFilename method for a purpose other than opening an Excel workbook. In such cases, the button will continue to say “Open”, even though the file isn't really opened later.
Argument #5: MultiSelect
The MultiSelect argument of the Application.GetOpenFilename method allows you to determine whether the user can select multiple file names at the same time.
By default, users are only allowed to select a single file. In this case, the value of the MultiSelect parameter is False. If you want to explicitly specify that MultiSelect is False, the VBA code of the Open_Workbook_Dialog macro looks as follows:
If you set MultiSelect to True, users can select several file names. If you set MultiSelect to True, the Application.GetOpenFilename method returns an array with the selected filenames. This is the case even if you select a single file. Therefore, when you enable MultiSelect, you must make the following 2 modifications to the VBA code example that appears above:
- Set the MultiSelect parameter to True.
- Treat the my_FileName variable as an array. This involves, in particular, modifying the way in which you open the workbook(s) whose filenames are returned by the GetOpenFilename method.
If you only set MultiSelect to True (#1 above) but fail to appropriately handle the array that GetOpenFilename returns, VBA is likely to return a Type mismatch error.
2 of the most common operations when working with Excel are:
- Opening Excel workbooks; and
- Specifying file paths and names.
Workbooks.Open and Application.GetOpenFilename are the basic methods that you use for purposes of carrying out these operations with VBA. Therefore, you're likely to use both of these methods quite bit when creating macros and working with Visual Basic for Applications.
Fortunately, if you've read this Excel tutorial, you're knowledgeable enough to use both the Open and GetOpenFilename methods. In addition to knowing what their purpose is, you've seen what each of their parameters is and what they allow you to specify.
Books Referenced In This Excel Tutorial
- Alexander, Michael (2012). 101 Ready-To-Use Excel Macros. Hoboken, NJ: John Wiley & Sons Inc.
- Alexander, Michael (2015). Excel Macros for Dummies. Hoboken, NJ: John Wiley & Sons Inc.
- Jelen, Bill and Syrstad, Tracy (2013). Excel 2013 VBA and Macros. United States of America: Pearson Education, Inc.
- Walkenbach, John (2013). Excel 2013 Power Programming with VBA. Hoboken, NJ: John Wiley & Sons Inc.
- Walkenbach, John (2013). Excel VBA Programming for Dummies. Hoboken, NJ: John Wiley & Sons Inc.