Navigate or select by punctuation

As writers, we inevitably move around our documents many thousands of times. Improving the efficiency of the navigation and selection process will obviously help us write and edit faster. Word's GoTo dialog is of limited practical use if speed is an important consideration. Document voice control is improving, but it's still clunky at times.

We can't solve all the problems, but we can create some targeted macros to speed up our document navigation. Toward this end, we improve upon a previous set of macros focused on jumping or selecting to common punctuation marks, reducing how often we need to click around with the mouse (which is slower than it seems compared to tapping a keyboard shortcut).

The sibling macro selects all text up to the comma such as with an introductory phrase.

The bulk of the article will present the topic in the context of navigating or selecting to a comma, but the final macros can be trivially modified to work with any punctuation mark.

Simple Versions

If you didn’t see the previous article, the simpler macros are below. Check out that article for additional explanation on any overlapping points. Another article covers creating an empty macro if you are starting from scratch.

Jump between punctuation marks

Move forward to the next or previous comma, respectively, in the document:

Select to punctuation marks

It only takes a small modification of the movement macros to instead select all text up to the punctuation mark. Specifically, we need to modify the Start of End of the Selection rather than just repositioning the insertion point location. Selecting forward or backward in the document, respectively, is done by:

Common traits

VBA ignores any text on a line after a single quote ' character which gives us a way to make human-only comments in our macros.

I’ve created variants for several common punctuation marks like periods, semicolons, and parentheses; but additional enhancements are covered in this article. To be more concrete, we’ll refer to commas for the majority of the article below.

We can modify the Cset character strings (characters at which the command stops the search) in each case to search for other punctuation marks or even include multiple search characters.

I am still astonished at times how a simple one-line macro can be so helpful.

Why bother with more?

Suppose I just used one of the above macros to select all text up to the nearest comma. What happens if I tap the shortcut again?

Nothing.

The basic macro above won’t select any additional text since the macro immediately “finds” the comma and stops the character search. We would need to manually move past the comma (with Shift+Right arrow) before selecting over to the next comma. The same basic problem occurs with the movement macros.

Ughhh.

This doesn’t feel intuitive to me. It's like your VBA pet is happy, wagging its tail and drooling on the floor while saying, "See what a good job I did for you! Here's your stick (comma)!" But you're like, "No, go fetch another stick!"

It feels more intuitive to extend the selection over to the next comma since I already know I'm at this comma. That's what we want to fix. We need to teach our dog the improved trick. The macro should realize we're already at a comma and extend the selection to the next comma something like this:

That’s one of the macro superpowers. If we’re willing to do some work up front, we get exactly what we want. The necessary changes are mostly easy to implement. Unfortunately, we need to avoid a notable gotcha along the way, but that’s why I’m here to help.

What is the Selection?

As a quick review, every macro above uses the Selection (or see our review for more information). It is VBAs representation of the selection we actually see in the document. It can refer to actual spanned document content, or it could refer to an empty selection called an insertion point (the blinking I-bar waiting for you to type). It is partly defined by its Start and End positions indicating the spanned content in the document, but it also contains other data (properties) and actions (methods) we can use to manipulate it. Only one Selection exists per document. We're ignoring block and non-contiguous selections since VBA does not play nice with them.

We often avoid using the Selection in complex macros since any changes to the Selection are (usually) immediately visible on the screen, but these macros are so short, we would likely never notice the rapid changes.

Basic planning

We're working through four related macros in this article. Individually, the details are relatively simple, but they accumulate to the point it can be confusing, so let's plan a bit with the higher-level concepts.

How do we get to the next or previous comma?

While the above macros are simple and a great place to get started, none of them work in this more intuitive manner without modification. What are the necessary steps for the improved macros?

When run, the improved macro needs to do the following:

1. Detect whether a comma already exists beside the insertion point (i.e., the edit location at the blinking I-bar) or the appropriate side of the selection.
2. If a comma is already present, move past it or extend the selection by one character.
3. Jump or extend the selection over to the following comma (works whether or not a comma was detected first).

Seems simple enough … we don’t always need to write everything out like this (I’m writing an article after all), but thinking through specific steps helps ensure we aren’t missing any obvious or less-than-obvious steps. It also gives us our initial opportunity to catch any potential issues. The steps aren’t difficult, but the specifics can get a little tricky, and they're often trickier than you think at first glance.

What is the previous or next character?

What character are we using to determine whether we skip over a comma? It's mostly obvious, but for completeness, we want these characters for each case:

• No selection → Get the character immediately before or after the insertion point
• Selection → Get the character immediately prior to or after the selection

This choice is where we hit a sticking point with the forward macros. We need a way to detect the selection status and pick the correct comparison character when the macro is run but more on that later.

How do we handle an initial selection?

What do we do with an initial selection? Some variation will exist across the macros, but we would need to do the following based on the initial selection state when the macro is run:

• Go to previous comma → Collapse the selection toward the start and then move
• Go to next comma → Collapse the selection toward the end and then move
• Select to previous comma → Extend the selection backward from the start
• Select to next comma → Extend the selection forward from the end

In the original macros, these actions happen automatically with the respective move until commands, so that saved us some work. However, our enhanced version needs to detect and adjust for the previous or next comma whether or not a selection already exists. This seemingly simple adjustment ends up being a little mess based on how VBA views the Selection.

Move and select backward in the document

Working backward and forward in the document are different for this set of macros. Moving or selecting backward is easier, so let's start with that.

Check for a previous comma

We need the previous character to check whether it is a comma. Fortunately, the Selection already has a Previous method.

This gives us the document Range of the previous specified element. We usually need to give a document unit from the WdUnits constants table, but the default is a character which is already what we want, so we can omit it in this macro (it clutters the presentation anyhow).

What is a Range?

See our brief introduction to Ranges in VBA for more information, but concisely stated, a range is a span of document content like an invisible but distinct selection. Much like the Selection, a range is partly defined by Start and End positions in the document, but it also contains a bunch of other properties and methods we can use to manipulate it.

Get the previous character

The trick is we don't want the range of the previous character. We want the plain text in that range, so we refer to its Text property.

This command tells VBA to give us (often stated as “return”) the next chunk of text prior to the Selection in whatever unit was specified. The unit defaults to a single character which is what we already want, so we can leave it out for this macro.

This command returns a plain text character (called a "string" even if it is only one character long), so we could just use it as it, but it reads better if we store it in a separate variable.

The Dim statement tells VBA what variable type to expect, but it is optional in standard VBA. I tend to include it in more complicated macros on this site for completeness. I don't like that the statements make the macros look more like programming, but they will eventually save you from some trouble somewhere down the line.

If we were to refer to the previous character often, this variable would also be a tiny bit more efficient.

Check the character

We need to check whether this stored character is a comma. If you've been following along, this is done in VBA (and programming in general) with a conditional statement something like "If ... Then" (see our brief review for more details). In rough "pseudo-code" this looks something like:

Character check condition?

How do we detect a comma? We literally just need to compare the previous character to a comma as a plain text string ",".

The double quotes are required around the comma to tell VBA we're working with the character. Otherwise, VBA would interpret it as part of a longer command which would cause an error.

This comparison works because a comma "," is just a literal value in VBA much like the number 3 (but there are some differences). PreviousCharacter is storing a single character, and we are using the equals = sign to compare it to a literal comma. That is, we're asking VBA whether they are the same string. For two strings to match, they must be exactly equal, no more, no less, no difference in case, no extra or fewer spaces, etc.

Unfortunately, this notation also looks like we're assigning a comma "," to the PreviousCharacter variable, but VBA interprets it as a True or False (Boolean) condition when used in a conditional statement context.

Move past the character

How do we move over the comma? We literally just move one character left in the document using the Selection's MoveLeft method.

The default step size is a character unit, and the default count is one unit, so we can omit both. Methods like MoveLeft are one of the differences between a Range and the Selection since Ranges do not have several of these specialty move methods.

Remember, the dot "." with VBA "objects" tells VBA to reference the MoveLeft method associated with the Selection. In this case, it means perform the action of moving one character left.

Conditional move step

Combining these steps, we have the more VBA like conditional statement:

Since the command is so short, we can compress the If statement into one line and omit the End If.

I tend to use this compact version when it is clearer, but it is optional.

Move to the previous comma

Now we can get back to the move action in the original macro. The original GotoPreviousComma macro above already jumps to the previous comma using the command:

As a quick review, the MoveUntil method literally collapses any initial selection and moves the insertion point to the nearest character indicated in the character set Cset. We assigned a plain text comma "," to Cset := ",". We need to specify the direction as wdBackward with the Count option (defined in another miscellaneous Word WdConstants table). The Count option tells the command to move backward in the document by as many characters as needed.

Notice we separate the two command options with a comma which is why we needed the double quotes around our text comma when assigning it to Cset.

This step works whether or not a comma was detected earlier. If no is found, nothing happens with this command.

Final go to previous comma macro

Putting the steps together, we get:

Now this improved macro will intuitively step over any adjacent commas allowing us to jump through the document faster. I assigned this macro to Option+, (comma) on a Mac or Alt+, in Windows.

What changes with the select to previous comma version?

The bulk of the go to previous comma macro stays the same, but there are two main changes to make it select document content instead.

Extend the selection backward over the detected comma

We need to change the MoveLeft method to instead move the Start position of the Selection. The command is similar with the MoveStart method, but it's not as pretty.

We need to move backward by one character, so we use the Count option set to negative one as Count := -1. The default move unit is for characters, so we can omit it.

Be sure to properly interpret the meaning of the Count option in different commands. This Count is an actual number of characters to move in the document.

Extend the selection to the previous comma

Instead of using the MoveUntil method as in the original set of macros, we need to move the Start position backward in the document until we encounter a comma. The command is similar with the MoveStartUntil method.

The target character set is again a plain text comma using Cset := "," like we used with the above MoveUntil command. We are still extending the Start position backward in the document, so we use Count := wdBackward.

Since the End position of the Selection does not change, this command effectively extends the selection backward in the document.

Final selection to previous comma macro

Making these two changes in the move macro, we instead get:

The similarity is why we're including all these variations in the same article. I assigned this macro to Alt+Shift+, (comma) in Word for Windows, but the natural corresponding shortcut Option+Shift+, does not work on a Mac since the operating system does not like to recognize that key combination. I've had to try other variations including Option+Control+Shift+, but the asymmetry in the shortcuts is frustrating since it is a little harder to remember.