Category Archives: Word

Updating and Sorting the Microsoft Word QuickStyle Gallery with PowerShell

 

Introduction

I’m currently working on my fifth book, this one is for the folks at PACKT Publishing. It’s still in the early stages so I can’t say too much, but if you like SQL Server Reporting Services, you’ll enjoy this book.

All book publishers use their own set of styles in Microsoft Word to allow them to control the layout of the book when it goes to print. There will be special styles for italics, bold, code listings, and more. The techniques here though are applicable to more than just book or magazine publishers.

You’re company may have a limited set of styles it approves for use in internal documents. Perhaps you need to adjust your set of QuickStyles based on what type of document you are authoring. One set for company memos, another for technical documentation, and yet another set of styles for love letters.

Using the PowerShell script in this post can make it easy for you to setup your QuickStyle gallery based on the type of document you are creating.

When working on the book it’s been convenient to clear out the list of built in styles in the QuickStyle gallery, and replace them with the ones I need for my publisher. Doing it manually though is a time consuming process.

Unfortunately I experienced further oddities. Every time I got a chapter back from my editor, my curated list of styles had been replaced. I don’t think it’s anything my editor did deliberately, she’s a really nice lady. I believe it’s some quirk of Word, related to the fact we appear to be on different versions. I knew I couldn’t keep sucking up time adding, removing, and sorting these each time I got a chapter back. I needed a way to automate.

I did some looking online, but couldn’t find a total solution that fit my needs. I found some VBA code for adding and removing styles from the QuickStyle gallery, but nothing on how to sort items in the gallery.

Being the geek I am means I love PowerShell. So I rolled up my sleeves and dove into the Microsoft Word object model. Specifically, I focused in on the Style object.

I’m a firm believer in the adage that you should completely understand any script you cut and paste off the web. So while I’ll place the complete script at the bottom of this post for easy copy / paste, I’ll step through it first to explain the various components.

Before I proceed, one important note: updating the QuickStyle gallery using the code below only updates one specific document. Other existing Word documents, or new documents you create, won’t be affected by this script.

1. Set a variable to hold the file name to update.

$wordFile = 'C:\Book\Chapter02.docx'

I start by setting a variable to hold the file name of the Word document I want to update. At some point I’ll probably turn this into a module and make this a parameter to the main routine, but for today this gets the job done and is easy for people who also want to use the script.

2. Back up the file.

$bakfile = $wordFile + '.bak'
Copy-Item -Path $wordFile -Destination $bakfile -Force

 

The next thing I do is make a backup. First, if something happens I want to be able to go back. Second, you should always backup before doing something like this, so making it built in prevents issues (as well as avoiding nasty comments on this post). Winking smile

3. Load an array with your desired styles.

$myStyles = @( 'Normal [PACKT]',
               'Numbered Bullet [PACKT]',
               'Screen Text [PACKT]',
               'Code In Text [PACKT]',
               'Code Within Bullets [PACKT]',
               'Code listing [PACKT]',
               'Italics [PACKT]',
               'Figure [PACKT]',
               'Chapterref [PACKT]',
               'Bold [PACKT]',
               'Heading 1,Heading 1 [PACKT]',
               'Heading 2,Heading 2 [PACKT]',
               'Heading 3,Heading 3 [PACKT]',
               'Tip [PACKT]',
               'Layout Information [PACKT]',
               'Figure Caption [PACKT]',
               'Part Heading [PACKT]'
             )

Next up, I load a list of the styles I want to place in my QuickStyles. Also, the array should have the styles in the order you wish them in the gallery. This list is specific to the styles I use most frequently on this project. To see the complete list of available styles within your document, open up Word and load your document. On the bottom right of the QuickStyle gallery is a little button that will bring up the style list.

SNAGHTML3fa2582

Once open, you’ll see a list of all the styles available in this document. Here’s the top of the list, scrolling down will reveal a LOT of styles.

image

The names that appear in here are the ones that you’d use in the array. Just type them into the array declaration exactly as they appear in the Styles list.

4. Load up style type enumerations.

# Load up the style type enumerations.
$wdStyleTypeParagraph = 1  # Paragraph style.
$wdStyleTypeCharacter = 2  # Body character style.
$wdStyleTypeTable = 3      # Table style.
$wdStyleTypeList = 4       # List style.

When we set the property to place something in the QuickStyles gallery, we have to be careful as only certain types of styles may appear in the QuickStyles area. We check this using a property of the Style object called Type, which has several enumerations. While I probably could have loaded the enumerations from the class, sometimes simple is good. Since the values for the enumerations were easily found in MSDN, I just replicated them as variables in PowerShell.

In this script we only use two of them, but for completeness I listed them all should I (or you) ever want to reuse this script as a basis for other Word work with PowerShell.

5. Create a new instance of Word.

$word = New-Object -ComObject Word.Application

The next step is pretty simple. All we do is create a new object of type Microsoft Word, and put a reference to it in the $word variable. Creating the new Word object is akin to opening up Word without a document in it.

6. Make Word visible.

$word.Visible = $true

This next step is optional. By default, when you create a new Word object it is not displayed to the user. If you are applying this to a whole batch of Word documents, I’d omit this step as it will slow down the process. For just one document though it’s not much of an impact. And to be honest, it’s pretty cool to watch Word as it removes then adds the styles.

7. Open the Word document to update.

$doc = $word.Documents.Open($wordFile)

This is probably an obvious step, but we need to load the document we want to update into our Word object. The Open method returns a new variable of type Document (MSDN). The $word variable represents Microsoft Word, the $doc variable represents the specific DOCX file (or DOC) that we want to update.

8. Reset all styles to remove them from the QuickStyles; additionally reset their priority.

foreach ($sty in $doc.Styles)
{
  # Only these two types can be QuickStyles
  if ( ($sty.Type -eq $wdStyleTypeCharacter) -or ($sty.Type -eq $wdStyleTypeParagraph) ) 
    { $sty.QuickStyle = $false }
  
  $sty.Priority = 100
}

This next section is important to understand. The document has a collection of Style objects, stored in the Styles collection. We start by looping over each Style in the document.

Each Style object has a property named QuickStyle, which has a value of true or false. This flag sets whether a style should appear in the QuickStyles gallery (true) or not (false). If you recall from the enumerations section above, there are some styles that cannot be in the QuickStyle area. If we were to attempt to set the QuickStyle property on these, we would get an error (even if setting it to false). Hence the need to check the Type property and only attempt to set the QuickStyle property for those Styles who can appear in the QuickStyle list.

The real challenge in terms of investigation came in ordering the styles within the QuickStyle area. To order them manually, start by clicking the lower right button on the styles dialog.

image

When the Manage Styles window appears, click on the Recommend tab.

image

 

To the left of each style name, you see a number or the word “last”. This number represents the order in which it will recommend styles to you. In other words, the order in which they will appear in the QuickStyles gallery.

With the buttons at the bottom you can rearrange the order in which they appear. Note, it is possible to have multiple styles with the same value. If that happens Word will arrange all styles with the same recommended value alphabetically. The word “last” simply tells Word to put these styles at the very end of the QuickStyles gallery.

It took a lot of research, but I finally figured out the “Recommended” value is contained in a property called “Priority” within the Style object. The word last is represented by the value 100, giving a valid range of 1 to 100 for Priorities.

In the above code I am setting all styles, even the styles built into Word, to 100 which is the equivalent of ‘last’. For my situation this is fine, as I’m only going to be using this specific set of styles in this specific document so I don’t really care about the built in ones. Even if I changed my mind later, all I would need to do is add the built in styles (or any new ones I create) to my array and rerun the script.

At this point then we’ve removed all styles from the QuickStyles gallery, as well as set their priorities to ‘last’. Now it’s time to add the styles we want and order them.

9. Add our desired styles to the QuickStyle gallery and order them.

$priority = 1
foreach ($mySty in $myStyles)
{ 
  # Setting to true will make the style appear in the QuickStyle gallery
  $doc.Styles($mySty).QuickStyle = $true
  # The priority is an integer which determines the sort order within the QS gallery
  $doc.Styles($mySty).Priority = $priority++
}

With this next code, we are going to add our list of styles as well as sort them. It starts by setting the starting point for our Priority (the order) to the value 1, our starting point.

We then enter a foreach loop, where we iterate over each style in the array we assembled back in step 3. Within the loop, we set the QuickStyle property to true. Naturally I’ve only placed style names into the array that are allowed to be in the Style gallery. If you have doubts you could add a check against the Type property, as we did in Step 8, before setting the QuickStyle property.

Note that the Styles collection allows us to address a style by passing in the name of the style. When you assemble the array then, it is important to match the name that appears in Word exactly so it can find it in the array.

Next up is setting the Priority. Again, the Priority is the order in which styles are displayed in the gallery. After assigning the value I use the ++ operator to increase the value for the next iteration of the loop.

Note that since I have far less than 100 items, I don’t have any error checking for exceeding the 100 mark. If you have more than 100 styles for your QuickStyles you’ll need to modify this code. Although quite frankly if you have more than 100 styles in your QuickStyles, it’s not really that quick and you should probably rethink your editing habits. Winking smile

10. Save your work.

$doc.Save()

As the next to the last step, we’ll have the script go ahead and save the document.

11. Close Word (optional).

$doc.Close()

If you modified this script to work in a big loop so you could batch updates, or perhaps you will just want to apply the fix and go on, you could have the script go ahead and close Word. On the other hand, if after applying the updates to the style gallery you’ll immediately want to start editing, just comment out this last step. 

Summary

A final note to close this out, I’ve tested the script with Word 2016 and PowerShell 5.0. From the documentation in MSDN the same techniques also apply to Word 2013. I’ve not tried it on previous versions of Word, but in theory it should work all the way back to the version in which the QuickStyle gallery was introduced. If you’ve tried it on an older version let us know the results by posting a comment below.

Additionally, while I’ve written this on PowerShell 5.0 I’m not doing anything new or unusual, it should work as far back as PowerShell 3.0.

Below is the script, complete with comments to act as a reminder of the explanations above. Just copy and paste, modify the $wordFile and the $myStyles array, and you should be good to go.

 


The Script

<#-----------------------------------------------------------------------------
  Updating and Sorting the Microsoft Word QuickStyle Gallery, ArcaneCode style!

  Author: Robert C. Cain | @ArcaneCode | arcane@arcanetc.com
          http://arcanecode.com
 
  This script is Copyright (c) 2016 Robert C. Cain. All rights reserved.
  No warranty or guarantee is implied or expressly granted. Use at your own
  risk. 

  This script may not be reproduced in whole or in part without the express
  written consent of the author. 
-----------------------------------------------------------------------------#>

# Set the path / file name of the file you want to update
$wordFile = 'C:\Book\Chapter02.docx'

# Make a backup before we do changes. Note if the BAK exists it will be overwritten
$bakfile = $wordFile + '.bak'
Copy-Item -Path $wordFile -Destination $bakfile -Force

# Create an array of the styles you wish, in the order you want 
# them to appear in the QuickStyle area 
$myStyles = @( 'Normal [PACKT]',
               'Numbered Bullet [PACKT]',
               'Screen Text [PACKT]',
               'Code In Text [PACKT]',
               'Code Within Bullets [PACKT]',
               'Code listing [PACKT]',
               'Italics [PACKT]',
               'Figure [PACKT]',
               'Chapterref [PACKT]',
               'Bold [PACKT]',
               'Heading 1,Heading 1 [PACKT]',
               'Heading 2,Heading 2 [PACKT]',
               'Heading 3,Heading 3 [PACKT]',
               'Tip [PACKT]',
               'Layout Information [PACKT]',
               'Figure Caption [PACKT]',
               'Part Heading [PACKT]'
             )

# Load up the style type enumerations.
$wdStyleTypeParagraph = 1  # Paragraph style.
$wdStyleTypeCharacter = 2  # Body character style.
$wdStyleTypeTable = 3      # Table style.
$wdStyleTypeList = 4       # List style.

# Create a new instance of Word
$word = New-Object -ComObject Word.Application

# This is optional, if set it will display Word and let you watch the fun
$word.Visible = $true

# Open the document you wish to reset the styles for
$doc = $word.Documents.Open($wordFile)

# First, reset all styles to not be Quick Styles, 
# and set the priorty to 100 (which will be 'last' in Word)
foreach ($sty in $doc.Styles)
{
  # Only these two types can be QuickStyles
  if ( ($sty.Type -eq $wdStyleTypeCharacter) -or ($sty.Type -eq $wdStyleTypeParagraph) ) 
    { $sty.QuickStyle = $false }
  
  $sty.Priority = 100
}

# Now set the styles like we want 'em!
$priority = 1
foreach ($mySty in $myStyles)
{ 
  # Setting to true will make the style appear in the QuickStyle gallery
  $doc.Styles($mySty).QuickStyle = $true
  # The priority is an integer which determines the sort order within the QS gallery
  $doc.Styles($mySty).Priority = $priority++
}

# Save the document. 
$doc.Save()

# Close up word (Optional, if you want to start editing 
# right away you can comment this out)
$doc.Close()

I have to give a shout out to the folks at Sapien for their PowerShell Studio tool. It has a great feature, Copy HTML, which takes pieces of PowerShell code, copies it to the clipboard and in the process adds the appropriate HTML tags to do the nice coloring.