Base move sentence macro

Combining the above commands, our base move sentence macro is:

We’ll extend this with more features and corrections below.

Use intuitive sentence movement

Now, we adapt the base macro to make it act more intuitively—

"Huh? Intuitive?"

Yeah, uhhh, let's start with that I don't like about the base version.

What is the unintuitive behavior?

If we move the first sentence of a paragraph backward, it will move before the last sentence of the previous paragraph.

The move is technically correct if we count one sentence backward, but it's a little jarring during real editing. The forward and backward movements are also not symmetric. If we follow up by moving the same sentence forward, it becomes the last sentence of the paragraph rather than moving back to where it started.

Include more intuitive movement

We could instead make the first sentence move backward to the last sentence of the previous paragraph? We want the following movement features.

• If the current sentence is the first of the paragraph, move it to the end of the previous paragraph just before the paragraph mark.
• If the current sentence is any other position in the paragraph, move it backward one sentence.
• Moving the last sentence of a paragraph mostly works like any other middle sentence except for needing an extra space correction.

These choices make the sentence movements flow better. When moving backward, the last sentence of the paragraph actually moves like any other middle sentence does, but it will usually not end with a space, so we will need to correct for it.

When moving forward, the last sentence should more intuitively move to the first sentence of the next paragraph, and the first sentence moves like most other middle sentences of the paragraph. The next to the last sentence is another special case we'll consider below.

The original macro inherited the desired sentence behavior based on how the MoveLeft method of the Selection worked around a paragraph mark. In this macro, we need to detect the sentence position and correct the movement based on it because the Move method works a little differently when stepping past a paragraph mark.

Move the first sentence of a paragraph

Since we're modifying the default range movement, we need to know whether the working range spans the first sentence of the paragraph.

How can we detect the first sentence of a paragraph?

To check whether the working sentence range spans the first sentence of a paragraph, we need to know whether it immediately follows a paragraph with no content in between them. In VBA, a paragraph mark is a special character named vbCr as defined in a miscellaneous constants table. The answer is found by testing whether the character just before the sentence range is a paragraph mark character.

We'll ignore the case of the first sentence of the entire document since it is an uncommon use case (trying to move the first sentence backward before nothing?), and the extra validation would clutter the macro.

Detect the first sentence of a paragraph

The character just before the sentence range can be found using the Previous method.

The Previous method returns the Range of the previous document unit. The default unit is a character, which is what we need, so we can omit the Unit option. We need the text for the upcoming comparison not the range, so we further refer to the Text property.

Then we store the text character in a string variable since the variable makes the conditional statement below clearer.

First sentence condition based on the previous character

We want to know whether the previous character is a paragraph mark.

While it looks like an assignment by itself, this condition is evaluated as a Boolean (True or False) value when it's used in a conditional statement. VBA interprets this condition as a Boolean (True or False) value when it's used in a conditional statement.

If-Then-Else conditional statements

We have a special case and a regular case. Both cases are valid, so we need an If-Then-Else statement.

The steps in the first part are run if the SpecialCaseCondition is True. The Else part is optional, but if it is included, any other cases (meaning SpecialCaseCondition was False) use those steps. See our brief introduction to conditional statements in Word VBA for more explanation.

First sentence rough conditional statement

For this macro, it's easier to verify the special case condition and relegate the other paragraph sentences to the Else part.

This works even in the unusual case of a paragraph beginning with spaces because Word automatically includes them as part of the first sentence.

Move to the end of the previous paragraph

The Move command in the base macro above stepped backward by "two" sentences to position the target range before the previous sentence. In this special case, we want to move to the end of the previous paragraph which is literally one character backward in the document. The relevant command is the Move method.

The default step size is by a character, so we can omit the Unit option. We need to move backward by one character, but the first step "moves" to the beginning of the sentence (also paragraph) effectively collapsing the range. We again need a Count value of -2.

Choose the correct move command

In the base macro, we always moved back two sentences, but now we have two different target locations. We need to pick the correct location based on the current sentence location in the paragraph. The special case is handled first leaving the regular case of any other sentence in the paragraph as the default.

We'll correct sentence spacing issues below.

Correct sentence spacing

The goal is for the macro to work in most circumstances without needing to manually catch and correct any mistakes. The writer should just be able to keep working uninterrupted after the sentence moves.

Spacing errors are easy to overlook when creating a macro, but the corrections stretch out longer than the base macro. This is unfortunate given their minor role in the task. Skip to the final macros if you wish, or check out the leveled-up member version that implements it with functions instead.

Define simplifying text variables

The spacing logic will be easier to read if we define a few string variables.

These declarations are not required, but they make the final macro clearer.

Correct spacing after the target position

When we move the last sentence of a paragraph backward, the sentence text at the target location will not include an ending space because the original sentence ended with a paragraph mark instead. We omitted the paragraph mark from the initial sentence range, so we need to add a space after we move it earlier in the paragraph. The catch is the logic needs to be general enough to not add a space at the end of a paragraph.

We'll work with the rTarget range since it spans the moved sentence text.

What are the criteria to add a space after the sentence?

We want to add a space if one is not already present between the two sentences. More specifically, we'll insert the space at the end of the target range but only if that position is not at the end of the paragraph.

Ensure all ending spaces are spanned (just in case)

The beginning of the paragraph allows extra spaces to precede a sentence. If we move the second sentence to that location, the spaces will still be there, but they will then count as part of the moved sentence.

Huh?

Yeah, it's a little awkward, but we may as well catch the oddity by extending the end of the target range over the spaces. The command again uses the MoveEndWhile method as seen in the base macro.

Admittedly, it's an unusual case to handle, but this command provides more of a logical certainty which is worth the handful of microseconds it requires. After this step, we're sure all spaces are included at the end of the range, so we don't accidentally add an extra one.

Get the last character of the sentence

Now, we check whether a space exists between the moved sentence and the sentence that follows it. We get the last character of the range using the Last property of the Characters collection.

The Characters collection contains a list of all character ranges in the sentence range. We get the character text from the Text property.

We store the text character in an appropriately named String variable.

Condition for whether the last character is not a space

We need to check whether this last character is not a space before we add one. The condition simply compares the variable to a space " ".

The not equals <> symbol literally reads "less than or greater than" in the context of numbers, but it's adopted for text with a similar qualitative meaning.

But not at the end of a paragraph

We don't want to insert a space if we've moved the sentence to the end of the previous paragraph. How do we exclude that case?

Ughhh … we also need to check whether the next character after the range is a paragraph mark before adding a space. The Next method works like the Previous method except it gives the next unit range.

The default unit is a character, and the default number of units is 1, so we can omit both options. A gotcha exists if the range is empty (where it will give the second character after the empty range), but we're mostly sure our sentence range contains text.

Not end of paragraph condition

We don’t want to add a space if we’re already at the end of a paragraph, so we don’t want the NextCharacter to be a paragraph mark.

Using the not equal to <> symbol, this condition checks whether next character is not a paragraph mark.

How can we check two conditions?

How do we check whether both conditions are met at the same time? We use an And operator.

With And in between the conditions, both ConditionOne and ConditionTwo must both be True before the compound condition is True.

Compound condition for when to insert a space

Both character conditions above must be True before we add a space inside the conditional statement.

Insert a space after the target range

We add a space after the range using the InsertAfter method.

The InsertAfter command does what it says. It adds the given text within the double quotes to the end of the range, and it extends the range variable over that text. Text is the only option, so the command allows us to omit the Text:= part and just give the added text, but it is clearer to keep it.

InsertAfter only adds plain text, but it inherits any formatting at that location (details may vary depending on the local spacing).

Correct spacing after the moved sentence

Putting the sentence space steps together, the conditional statement to ensure proper sentence spacing is:

When the conditional statement only contains one command, we'll often condense it to one line, but this one is a little too long for that. This set of steps doesn't correct for extra spaces after the sentence. It just ensures at least one space exists between them.

Correct spacing before the target sentence

If the first sentence of a paragraph is moved into the previous paragraph, it is likely the moved sentence will not have a preceding space. We need to check and correct for that case.

What are the criteria to add a space before the sentence?

We want to add a space if one does not exist before the moved sentence, but we'll need some extra logic to check for the beginning of the paragraph since that is also possible.

Get the previous character

We need the character just before the target range using the Previous method. We again store the character in a conveniently named String variable.

The default Unit of Previous is a character, and the default Count is one, so we can omit both options. A tiny gotcha would occur if the first sentence of the paragraph begins with spaces, but we'll ignore this fringe case here.

Missing previous space condition

We only add a space if the previous character is not a space.

Beginning of the paragraph condition

If the sentence is moved to the first sentence of the paragraph, we don't want to insert a space. We can also check whether the previous character is not a paragraph mark.

Compound condition to add a prior space

Both conditions must be true before we add a space, so we use an And operator.

Insert the previous space

We can insert plain text before the range using the InsertBefore method.

InsertBefore automatically extends the range backward to include the added text.

Remove the space from the target range

We use the target range later in the macro under the assumption that it only spans the moved sentence range. Most sentences in Word begin with the first non-whitespace character, so Word would not usually consider this inserted space to be part of the moved sentence.

We do not want to interfere with any later logic, so we should probably remove the added space from the target range. We only added a single character, so MoveStart is the simplest method.

MoveStart defaults to moving the Start position of the range forward by a single character which is what we need, so we omit any options.

Correct spacing with previous sentence

Putting the conditions and the commands into a conditional statement, we have:

Delete an empty paragraph (optional)

What if we moved the only sentence in a paragraph leaving it empty?

If you don’t care about occasional empty paragraphs appearing, then there’s nothing to do here. I find it a little unsightly to leave a blank line after the move, so let’s delete it.

What are the criteria for detecting an empty paragraph?

The rSentence working range is already at the potentially empty paragraph since we deleted the original sentence. We’ve already deleted all text and any associated spaces, so we can check for an empty paragraph by looking for consecutive paragraph marks, a vbCr followed by a vbCr, with no text in between them.

Basically, we need to know whether the previous character and the first character of the empty range variable are both paragraph marks.

Assign the empty paragraph test characters

We redefine the previous and next character variables for this new test.

We need the First character of the sentence range since we are sure (given our previous steps) the rSentence range is empty. This gives us the intuitive next character for an empty range.

Range text gotcha with empty ranges

Unfortunately, when the range is empty (no text is spanned), the “next” character in the intuitive sense is actually found using the “first” character of the empty range. This is a little confusing since it’s not actually spanning any text (the Selection behaves a little differently). For our purposes, we just need to pick the correct character.

Compound condition to detect an empty paragraph

Both paragraph mark conditions must be True, so we again need the And operator.

Conditional statement to delete an empty paragraph

Putting this compound condition into a conditional statement, we have:

We simply Delete the paragraph mark character to the right of the empty range which removes the empty paragraph from the document.

Delete extra spaces at the end of the source paragraph

Suppose we move the last sentence (in the sense of order, not the only one) of the source paragraph. After the original text is deleted, the previous sentence will probably leave a space at the end of the paragraph. We need to delete it.

Detect the end of the paragraph

The rSentence working range is already positioned at the end of the paragraph. The original sentence text was deleted earlier, so rSentence is currently empty. A space may or may not be present just to the left of the range with a possible paragraph mark to the right. The catch is we don't want to delete the space if the sentence is somewhere else inside the paragraph.

Before we delete anything, we need to test whether the next character is a paragraph mark or not.

Store the first character after the range

For an empty range, the intuitive next character is identified using First character of the Characters collection.

We store the character in an appropriately named String variable. Using the first character is necessary because the "next" character as VBA sees it using the Next method is actually the second character after an empty range.

First character comparison

Our end-of-paragraph condition checks whether this first character is a paragraph mark character vbCr.

Extend over the extra spaces

If we have a paragraph mark on the right, then we extend the range over all spaces to the left in preparation for deleting them. The relevant command is the MoveStartWhile method.

MoveStartWhile works just like MoveEndWhile from earlier except it moves only the Start position of the Range variable. We assigned a space character " " in double quotes to the Cset option, so this command will only extend the range backward over spaces.

In most cases, only one space would linger at the end of the paragraph, but we might as well handle the general case using the MoveStartWhile command to extend over all spaces. It also simplifies this step since the command handles the conditional logic for us.

Delete any extra spaces

The Delete method is simple. If the range spans any content, Delete will remove it from the document much like what happens when we tap the Delete key.

The method has some options, but it's usually used just as a plain ole Delete.

But we have a problem

If no spaces are present, the Delete command will still delete something. Specifically, it would delete the character to the right of the range just like the (forward) Delete key would do.

Ughhh.

We only want to delete extra spaces if they exist, so in addition to checking for a paragraph mark, we need to make sure at least one space exists to the left of the empty sentence range before deleting anything.

Check for an existing space

We need to know if the range had any preceding space before we try to extend over and delete them. We could validate whether the MoveStartWhile command found any spaces, but it gets a little messy.

What then?

We're already validating the paragraph mark character, so the easiest way is to check for a space at the same step before the extension command runs. We again refer to the Previous method to get the character just before the empty sentence range.

The default unit and count for Previous is a single character, so we omit the options. Then we need the text of the character range, so we refer to the Text property.

Compound condition to detect an end of paragraph space

We only delete the spaces if we have a space on the left and a paragraph mark on the right. Since both must be True, we use the And operator again.

The first character variable assumes an empty range.

Delete end of paragraph spaces conditional statement

Inserting the above condition and the range extension command into an If statement, we have:

I wish I could say we're done, but … not quite.

Ughhh.

But we can't quit, or we'll lose that zing of accomplishment when we have a working macro that helps us edit faster.

Correct a “helpful” Word feature

Sometimes Word adjusts spacing for us which may include deleting an extra space or inserting a space Word thinks is missing. This feature is often convenient in everyday writing and editing. We occasionally don’t need to manually insert or remove a space when we paste text, for example, but it can be annoying when creating macros.

Since the sentence range is currently at the end of the paragraph, we should be able to just delete the excess space(s) and be done, but testing shows Word reinserts a space even though it's at the end of the paragraph.

Arghhh.

Word should be a little smarter about reinserting a space since requiring one at the end of the paragraph doesn't make sense. We can, however, add a few extra steps to detect and correct for it despite Word’s attempt to help us.

Redefine the first character

Word will reinsert the space to the right of the range after we delete the others, so we reassign the first character variable based on the current empty sentence range (no reason to create a new variable).

Check for a space again

This time we’re checking whether it’s a space Word reinserted automatically or not.

A simple Delete command deletes the space to the right of the empty range. The conditional statement is simple enough that we can condense it onto one line with the Delete method.

Unfortunately, this needs to go inside the earlier If statement, but the condensed form makes it more readable.

Wouldn’t it be simpler if we always delete the space?

Why not just delete the space every time?

After all, we “know” it’s there, right?

Uhhh … well, kind of, but I can't guarantee that Word will always insert it for everyone that uses this macro.

I'm not sure because it depends on the Use smart cut and paste setting. I prefer to make sure the space is present before trying to delete it. It's probably not a big deal since it would just delete one character, but it only requires a handful of microseconds to check, so why not be sure?

Finally delete the spaces

Here is the result for deleting any excess end of paragraph spaces.

A seemingly simple correction grew into a pile of macro steps.

Delete extra spaces at the end of the target paragraph

With the more intuitive sentence movement mentioned earlier, we required the first sentence of the current paragraph to move backward to the end of the previous paragraph.

Okay …

The moved sentence probably has a trailing space that moves with it. It's now the last sentence of its new paragraph, so we need to delete the trailing space like we did for the source paragraph earlier. This is a good example of how seemingly small changes to one part of a macro affect other parts. Fortunately, we can reuse the previous steps where we deleted extra spaces at the end of the source paragraph.

Reuse the prior solution

Before we copy the steps from above, but we need to change the range variable from the sentence range, rSentence, to the moved sentence range. Other than removing the extra space, we don’t want to disturb the current target range, rTarget, since it spans our desired sentence text at the new location.

Copy the current target range

We need to store a temporary copy of the rTarget range in a new variable. We'll call it rEnd. We again refer to the Duplicate property, so we have an independent range variable.

In the macro below, we included the rEnd variable declaration with the source and target range variables to save a step.

Collapse the new end range

The previous steps worked with a collapsed sentence range because we deleted the original sentence. We don't want to delete the target range, so we need to collapse its copied range, rEnd. We'll Collapse the range toward the End position using the Direction option.

Technically, wdCollapseEnd comes from a small table, but only two values are in table.

Modified steps with a copy of the target range

We now have an empty range positioned at the end of the moved sentence text, so we can delete any excess spaces if it is at the end of its paragraph. Aside from the duplication and collapse steps to set it up, we simply modify the earlier steps by swapping out rSentence for rEnd.

This is a why functions exist

The repeated steps illustrate why functions were created and are even available in a "scripting" language like VBA (although it's a genuine programming language). We literally just copied the same steps over and made a trivial change to apply them to a different range. Plus, this macro is stretching out longer than the Golden Gate bridge, so implementing a few functions would also make it more readable. Another member article breaks the macro down into smaller, bite-sized chunks.

Final move sentence macros

Let’s put these changes together into a pair of revised, more intuitive, but annoyingly long macros. If I must choose between brevity or having the macros do what I want. Improved functionality and usability win almost every time.

They're not overly complex, just ungainly, but they provide a good excuse to introduce functions in a follow-up member article. The different spacing corrections can be neatly separated out and would probably apply to other macros later. As a school of hard-knocks example on the utility of functions, these macros serve that secondary purpose well.

Moving sentence backward

Merging the above commands, our macro to move a sentence backward in the document is:

Some spacing corrections can be done out of order, but it's not a free for all.

Moving sentence forward

The move sentence forward version of the macro is a little longer because of an extra sentence case. We also need to adjust the corresponding steps (performed off screen) for moving forward in the document, so the target range movement details are a little different. The rest of the macro is very similar to the backward version.

I assigned my versions of these macros to Option+Shift+Left or Right arrows in Word for Mac or Alt+Shift+Left or Right arrows on Windows. These shortcut combinations aren’t perfect since I’d prefer those key combinations extend the selection by sentences (akin to Command+Shift+Left or Right arrows for words), but it’s the best solution so far for me since I move sentences more than I need to select them.

Comment on comments

Notice the regular comments throughout both macros. They would be even more difficult to follow without the additional explanations.

I generally explain any notable individual steps, chunks of steps, what variables mean, or just what I was thinking at the time if it might not be obvious later. I’ll also note any specific issues I was having such as why something didn’t work or why I chose a particular solution. If a strange step is required, I’ll add a note about why it was included.

You’ll thank yourself for including comments if you ever go back to the macro later. Multiple times, I’ve forgotten what I was thinking or how I was solving a problem at the time, and the comments saved me time fixing or enhancing the macro.

Improvements

This macro needs further improvements, but given the already lengthy macros, they're omitted from the above versions.

More spacing tweaks

As I test the macros, I see a few places where I would prefer my versions further tweak other spacing oddities. Given the fringe nature of the extra corrections, they're omitted in the above macros.

Disable screen updates

With the multiple changes, the macros should probably disable screen updates while running. It sometimes results in a cleaner edit rather than seeing twitchy changes on the screen.

Add an undo record

With multiple possible changes in sequence, we should probably add an Undo record. However, include them with caution because they can cause problems with the undo actions, and they can even occasionally (rarely) confuse Word's cloud syncing.

Allow dialog?

Since I also write novels, I prefer my editing macros naturally handle dialog at a minimum, but the macros are already so long. That is a lesson for another day.

Functions please!

The steps for the sentence range extension, spacing corrections, and deleting an empty paragraph are all respectively the same. The latter commands stretch out until the simple corrections form the bulk of the macro. These spacing adjustments will pop up in other macros, so they beg to be extracted into separate functions. We already created a function to do the sentence selection, and another member version uses the other mentioned functions. We end up with a cleaner macro and several extra tools for our macro toolbox.