Assign an easy standard shortcut

Assigning actions to run when a given keyboard shortcut is pressed is called “key binding”. In Microsoft Word, we generally bind shortcuts to our own editing macros or perhaps to standard Word commands. Of course, the purpose is to make them faster and easier to use and make our editing time more productive.

Key binding assignments are a little clunky in Word VBA, so we previously created a slightly more general shortcut assignment macro that interprets most shortcut combinations on a typical computer keyboard using tabulated key constants. However, it would be more convenient if we could also interpret plain text shortcuts in a format like “Control+Shift+A”, and let the macro determine the main key constant. Not that the previous macro is difficult to use, but the improvement saves us from looking up a constant in a table, and the improved simplicity is appealing.

Keyboard shortcuts organization series

The current article is part of a series of mostly member articles to help organize and quickly reassign our keyboard shortcuts:

• Simpler approach to get a keycode for any key combination (lacks error checks), or use the more concise but programmy version to get a keycode for any key combination (includes error checks and allows all four modifier keys on a Mac)
• Function that validates whether isolated keys are allowed for a tentative keyboard shortcut
• Macro assembles the pieces to automatically assign or reset keyboard shortcuts for macros or Word commands. This one is a little more general than the "easy" version below, but it works for any key combination allowed by Word for Windows or Mac including any special keys.

For the easiest shortcut (re)assignments using alphanumeric or function keys, we need two extra utility functions:

• Function that reads a main key from some shortcut text and returns the key constant
• Function that reads a function key from some shortcut text and returns the key constant
• Macro to assign easy shortcuts for alphanumeric or function main keys (this article)

Get the main key from shortcut text

We want to interpret full keyboard shortcuts as plain text like “Control+Shift+A”. This is probably the most common form to write shortcuts where the main key is the last character of the text. A common abbreviation for function keys is “F2”, so another convenient form for some text shortcuts includes combinations like “Command+F2”.

Convenience usually comes with a higher price tag (prep work in this case), so we worked ahead to implement the two utility functions to facilitate this macro (see series note above), but the works pays off with simple shortcut assignments. We also make use of the more general shortcut assignment version to minimize the number of steps in this macro.

A little terminology

A shortcut is the unique combination of keys used to invoke a specific macro or command.

Control, Alt, and Shift are modifier keys in Windows. On a Mac they are Command, Control, Option, and Shift.

The main key is the key we combine with some combination of modifier keys to create a unique shortcut.

A special key is any key other than an alphanumeric one.

Limitations

Assigning keyboard shortcuts to our own editing macros is great, but some limitations exist.

Not all key combinations work

Unfortunately, not all key combinations will work in Word, and valid combinations differ between Windows and Mac. We basically need to test any unusual combinations. See the previous article for more discussion on this topic.

The Function (Globe) key is not accessible for Word shortcuts for Mac, but menu commands may be set up as custom system-level shortcuts.

No parameters or functions (mostly)

We cannot assign a shortcut to any function nor to a macro that has any parameters …

Uhhhh, mostly, please don’t make me talk about—okay fine.

Clunky text parameter … but not really

We can provide a key binding with a single plain text parameter (yeah, just one and no numbers or any other data type), but it is the epitome of clunky programming (bad VBA! No treat for you). Accessing the argument inside the macro is awkward at best, and it gets worse if you need more complicated input.

Ughhh. Just avoid it.

Voice command option (Windows only)

On the positive side, we can sidestep the parameter restriction if we’re willing to invoke our macros using voice commands in Dragon Professional scripting (see other articles here for an introduction) which also uses VBA, but setting everything up requires additional work, and the application is not cheap. It’s quite convenient though. Unfortunately, this application is only available for Windows.

Be careful when using no modifier keys

Secretly, most keys can also be assigned to a shortcut without modifier keys … but this is probably dangerous since it would change how your keyboard works by default inside Word. It’s safest to save isolated keyboard shortcuts for the function keys, unless you’re sure what you’re doing. Similarly assigning a macro to only Shift+SomeKey is also questionable since most keys already have a defined action for this combination.

Macro skeleton

The macro skeleton for this alphanumeric shortcut assignment macro is:

We’ll trivially modify it at the end to create a shortcut for a standard Word command.

Neither macro is a function, so they return no value. The two macros are almost the same, so we’ll focus on the first one until the end.

Parameters

Both parameters are plain text and declared “As String”. The first is the text shortcut which we name Shortcut. Then we need the name of the macro to run when the shortcut is pressed which is stored in the SMacro parameter. In the sibling macro for Word commands, we trivially change the second parameter to SCommand just to be clearer. Each of these variables may be given to the macro as “plain text in double quotes” or via another String variable.

I like to name my text variables starting with an “s” or “S” (capital first letter indicates the macro will not change the value inside), but VBA doesn’t care as long as we don’t use one of its reserved words like Selection or String.

Get the easy key code

We first define our working key variable which we’ll call myKey. It will store a value from the WdKey enumeration table corresponding to the main key identified in the shortcut text.

Since any of the valid key constants for this macro are in the WdKey table, we use a WdKey number type. Also, the two utility functions mentioned below return a WdKey number type, so we might as well be consistent.

VBA enumerations are essentially constant tables with easy-to-read names, but we can do other things like use them as a number type also. Unfortunately, VBA doesn’t restrict any assigned variable values to included constants which half defeats the point.

In the overall key binding task, a Long number type would be okay because the key binding add method requires a Long type for its KeyCode option (see previous article if you’re interested). Word VBA automatically converts between Long and WdKey number types anyhow, so the distinction doesn’t matter much. Using WdKey here is more specific which is a tiny bit clearer.

Previous main key functions

We did the prior work to get the key values from shortcut text, so let’s briefly review these functions before we assemble the shortcut assignment macro.

Get an alphanumeric main key

The first utility function reads the last character of some shortcut text and calculates the equivalent WdKey table constant.

The Shortcut must include the alphanumeric key as the last character since that is the typical format. Any prior modifier keys or other characters are ignored.

Get a function key main key

The second main key function looks for a function key abbreviation at the end of the text Shortcut.

This version is only checked if an alphanumeric key above is not found but see below for how we implement this check.

Invalid key value

Each main key function returns a value of wdNoKey from the WdKey table if it cannot find a valid key.

Get the alphanumeric key constant

We first check whether an alphanumeric character is at the end of the Shortcut argument. We store the key result in our key value variable.

Check alphanumeric key constant

A conditional statement to check for a valid main key looks like:

The specific condition for a missing main key in the shortcut text is whether myKey is equal to the wdNoKey constant.

An equals = sign between values results in a True or False (Boolean) condition if it’s used inside a conditional statement.

Get function key constant

If no alphanumeric main key exists, then look for a function key.

Since we only have one relatively short command, we can use the more compact If statement notation to keep it on one line.

Basic error checks

We should always be proactive with catching errors since it will often save us time and trouble later.

Assigning the macro?

Giving an invalid key code to a key binding assignment would cause an error and crash the macro, but we went into some detail about this issue in the previous article when assigning a special key shortcut. That function already handles a few serious shortcut assignment errors, and since we’re using it, we can also defer handling some key code problems to that macro.

However, we should not be entirely neglectful about possible errors here since it’s useful to give a specific error message in this macro about which shortcut assignment caused an error.

Invalid key result

One problem we should check is if both utility functions fail to find a valid main key in the Shortcut text. We already checked the alphanumeric key value before attempting to get a function main key. As a result, we also need to check myKey for a wdNoKey value afterward. If looking for this function main key also fails, we give an error message and exit the macro immediately.

Again, the specific condition is whether myKey has the wdNoKey constant value from the WdKey table.

This is just a logical error at this point in the macro as opposed to a “runtime” error that will crash the macro, so we only need to notify the user and exit the function.

Empty shortcut argument?

We would normally verify the Shortcut text argument (a variable value provided to a macro or command) includes something before using it, but we’re passing it to the utility functions that already have their own error checks on this variable. Thus, we can omit any such extra checks here and use the return value as an indicator of whether either main key was detected. An empty Shortcut variable would have resulted in a value of wdNoKey for myKey anyways.

Empty macro argument?

It is difficult to validate whether a general macro name is present in our library, but an empty macro name is easy to catch and would definitely cause an error when trying to assign it to a shortcut. Technically, this error would already be caught in the more general shortcut assignment macro we call since it already checks for any runtime errors, but it only takes a moment to verify the macro name here.

An empty macro name is literally an empty string “” in double quotes, so we can just check if SMacro is empty using an equals = sign.

Remember an equals sign is a True or False (Boolean) condition when used in an If statement. We just need to include this with the previous error check where we checked for no detected alphanumeric or function main key. Since either condition is a problem, we need an Or operator.

Our revised conditional statement for the error checks is:

Error message

We use the standard VBA MsgBox function to pop up a dialog box with a relevant message. An example error message is:

The function needs a text string for the message. The above uses plain text in double quotes along with string variables, so we “added” (called concatenate for text) them together with plus + signs. VBA interprets we meant to jam the text together into a single string. MsgBox has other options to prettify the dialog box, but we’re just using a plain message for simplicity.

The more detailed we are with error messages, the more useful they are when a problem occurs. Here we’re just telling the user the failed shortcut assignment and the macro name.

Exit macro

We don’t want to attempt to assign a shortcut if there is no main key detected, so we exit the macro (called a “subroutine” or Sub for short) immediately.

Assign shortcut

If we make it to this point in the macro, the main key is valid. The previous special key version of the function is:

Macro parameters

The special key shortcut assignment macro parameters are:

• Modifier keys should be plain text.
• MainKey is a constant either from either the WdKey (mostly) or the VBA KeyCode table.
• Macro name should be plain text which is the literal name of the macro in the VBA project.
• The KeyCategory constant is from the WdKeyCategory enumeration table. Usually, this is wdKeyCategoryMacro or wdKeyCategoryCommand.

The VBA KeyCode table is basically just for the arrow keys, but the other redundant key constants also work. No special keys like arrows are used in the current shortcut assignment macro. Available macros to bind to a shortcut include any stored in your Normal.dot template or the current document.

Our arguments

For our current macro, the respective information is:

• The Shortcut argument includes the modifier keys, so we can just provide that argument. The general shortcut assignment macro will ignore the extra main key information at the end.
• The MainKey variable corresponds to our current main key constant which we determined above and stored the result in the myKey variable.
• The macro name was provided to this shortcut assignment macro as SMacro. We pass it as the third parameter without any modifications.
• The macro category is wdKeyCategoryMacro for this version. The follow-up version to assign standard Word commands will use the wdKeyCategoryCommand.

Make assignment using the previous function

Finally assign the shortcut using our specific argument values.

Again, this function does its own error checking, so some assignment errors may be caught there.