Learn Powershell | Achieve More

In this article, I will be showing you how to build a table in Word using PowerShell.

First we will go ahead and make the initial object creation and open up Word.

 
$Word = New-Object -ComObject Word.Application
$Word.Visible = $True
$Document = $Word.Documents.Add()
$Selection = $Word.Selection

Now that we have done that, we can start looking at building out a table to use in our document. The first example will look more like a typical table that has the headers on the first row and the rest of the rows will consist of the actual data. Of course, the first thing that I need first is some actual data that I can put into a table.

 
$Volume = Get-WmiObject Win32_Volume

I think listing out all of the volumes on my system should suffice. Now that I have this information, I can now start building out my table. One of the values that I want to document has a specific lookup that I need to quickly build using a hash table.

 
$DriveType = @{
    0x0 = 'Unknown'
    0x1 = 'No Root Directory'
    0x2 = 'Removable Disk'
    0x3 = 'Local Disk'
    0x4 = 'Network Drive'
    0x5 = 'Compact Disk'
    0x6 = 'RAM Disk'
}

I want to ensure that I am at the very end of my current spot in the document so I can put the table after whatever I may have written. I also need to make sure that the object is treated like a collection, otherwise I won’t be able to specify the index, in this case –1 for the last item in the collection.

 
$Range = @($Selection.Paragraphs)[-1].Range

The $Range will be used soon in the construction and placement of the table. Using the $Selection, I will create a new able by using the Tables.Add() method and then saving the output of the method which is the table object that I can then use to begin processing and adding data into the table.

Looking at the parameters really doesn’t help much.

 
$Selection.Tables.add

This is one of those cases where a trip to MSDN will provide more useful information to determine what we can actually use.

Now that is much more useful to us! we can see that we need to specify the Range that was found as well as some parameters for the number of Rows and Columns as well as the behavior of the table and how the items will fit. We don’t actually have to specify the Behaviors, but in this case I will be adding those as well.

As it shows, the rows and columns are pretty much a no-brainer as we can look at how many properties we are using and that will be the Column count and as for the Rows, we will take the number of objects returned and then add 1 to the count which will account for the header row. In this case, I am going to have 6 columns and 5 rows in my table.

Now for my Table and AutoFit behavior, I need to figure out exactly what is available to choose from. Again, I can find this inform on MSDN, but I think this is a great exercise in PowerShell’s ability to easily explore the environment to locate what we are looking for.

 
$AutoFit = [Microsoft.Office.Interop.Word.WdDefaultTableBehavior].Assembly.GetTypes() | 
Where {$_.Name -match 'autofit'}
$AutoFit | Select FullName

$DefaultTable = [Microsoft.Office.Interop.Word.WdDefaultTableBehavior].Assembly.GetTypes() | 
Where {$_.Name -match 'defaulttable'}
$DefaultTable | Select FullName

Perfect! Now to see what values we have to choose from.

 
[Enum]::GetNames($AutoFit)
[Enum]::GetNames($DefaultTable)

For my table, I am going with wdAutoFitContent and wdWord9TableBehavior when I build out my table.

 
$Table = $Selection.Tables.add(
    $Selection.Range,($Volume.Count + 1),6,
    [Microsoft.Office.Interop.Word.WdDefaultTableBehavior]::wdWord9TableBehavior,
    [Microsoft.Office.Interop.Word.WdAutoFitBehavior]::wdAutoFitContent
)

I am next going to pick out the table style that will be used for this specific table. Because I want a focus on the distinction between the header and the data, I am going with Medium Shading 1 – Accent 1 which means that my table goes from this…

…to this:

 
$Table.Style = "Medium Shading 1 - Accent 1" 

Ok, right now this really doesn’t look all that impressive, but it will look nicer once we have finished with the data. And speaking of data, lets start adding the header to this now.

Think of the table as a multi-dimensional array and that you have to use coordinates to properly place the data. In this case we are using the $Table.Cell(column,row) property where we have to specify the coordinates within the parenthesis to say where the data going and if we are going to add some custom formatting to that particular cell. Once each column has been completed we simply move onto the next column and perform the same operation until completed and ready for the next row.

 
## Header
$Table.cell(1,1).range.Bold=1
$Table.cell(1,1).range.text = "Drive"
$Table.cell(1,2).range.Bold=1
$Table.cell(1,2).range.text = "DriveType"
$Table.cell(1,3).range.Bold=1
$Table.cell(1,3).range.text = "Label"
$Table.cell(1,4).range.Bold=1
$Table.cell(1,4).range.text = "FileSystem"
$Table.cell(1,5).range.Bold=1
$Table.cell(1,5).range.text = "FreeSpaceGB"
$Table.cell(1,6).range.Bold=1
$Table.cell(1,6).range.text = "CapacityGB"

Starting to look like something a little more useful now. The last piece of this is to add the data. Given that I really don’t know just how much data might be available at the time of this, I am relying on a For() loop to handle this for me.

 
## Values
For ($i=0; $i -lt ($Volume.Count); $i++) {
    $Table.cell(($i+2),1).range.Bold = 0
    $Table.cell(($i+2),1).range.text = $Volume[$i].Name
    $Table.cell(($i+2),2).range.Bold = 0
    $Table.cell(($i+2),2).range.text = $DriveType[[int]$Volume[$i].DriveType]
    $Table.cell(($i+2),3).range.Bold = 0
    $Table.cell(($i+2),3).range.text = $Volume[$i].Label
    $Table.cell(($i+2),4).range.Bold = 0
    $Table.cell(($i+2),4).range.text = $Volume[$i].FileSystem
    $Table.cell(($i+2),5).range.Bold = 0
    $Table.cell(($i+2),5).range.text = [math]::Round($Volume[$i].FreeSpace/1GB,2)
    $Table.cell(($i+2),6).range.Bold = 0
    $Table.cell(($i+2),6).range.text = [math]::Round($Volume[$i].Capacity/1GB,2)
}

Same approach as my header but not only do it increment the columns on each pass, I also have to make sure to increment the rows as well to ensure that the data is accurate. The end result is something like this:

Lastly, I want to make sure I am at the end of this and outside of my table so I can continue adding data or writing if necessary without writing to the table. I also want to add a space after the table for formatting purposes.

 
$Word.Selection.Start= $Document.Content.End
$Selection.TypeParagraph()

If you wanted more of a list type of format, that can also be accomplished using a similar approach. This time we will keep the number of columns to two and use as many rows as we need.

 
$BIOS = Get-WmiObject Win32_Bios

$Range = @($Selection.Paragraphs)[-1].Range
$Table = $Selection.Tables.add(
    $Selection.Range,5,2,
    [Microsoft.Office.Interop.Word.WdDefaultTableBehavior]::wdWord9TableBehavior,
    [Microsoft.Office.Interop.Word.WdAutoFitBehavior]::wdAutoFitContent
)

Another different is that I don’t want to focus on the first row, so a different style will be used.

 
$Table.Style = "Light Shading - Accent 1"

And lastly, we start building out the list table.

 
## Header
$Table.cell(1,1).range.Bold=1
$Table.cell(1,1).range.text = "Manufacturer"
$Table.cell(2,1).range.Bold=1
$Table.cell(2,1).range.text = "Name"
$Table.cell(3,1).range.Bold=1
$Table.cell(3,1).range.text = "Version"
$Table.cell(4,1).range.Bold=1
$Table.cell(4,1).range.text = "Serial Number"
$Table.cell(5,1).range.Bold=1
$Table.cell(5,1).range.text = "BIOS Version"
    
## Data
$Table.cell(1,2).range.Bold = 0
$Table.cell(1,2).range.text = $BIOS.Manufacturer
$Table.cell(2,2).range.Bold = 0
$Table.cell(2,2).range.text = $BIOS.Name
$Table.cell(3,2).range.Bold = 0
$Table.cell(3,2).range.text = $BIOS.Version
$Table.cell(4,2).range.Bold = 0
$Table.cell(4,2).range.text = $BIOS.SerialNumber
$Table.cell(5,2).range.Bold = 0
$Table.cell(5,2).range.text = $BIOS.SMBIOSBIOSVersion

$Word.Selection.Start= $Document.Content.End
$Selection.TypeParagraph()

The end result is something that looks like this:

Of course, this can easily start adding to your line count if you plan on having several tables that you want to add in your document and writing code isn’t about who has the most rows.

I wrote a small function that takes an object and can build out a Table or List fairly easily and all it requires is the $Object to be added to the table and the $Selection object. Note that this is one that I use on my personal projects but can be altered to meet your needs. Another thing is that you will need to tailor your object to only have specific properties, otherwise your table/list will be overrun with data.

An example of it in use is here:

 
$Volume = @(Get-WmiObject Win32_Volume  | ForEach {
    [pscustomobject]@{
        Drive = $_.Name
        DriveType = $DriveType[[int]$_.DriveType]
        Label = $_.label
        FileSystem = $_.FileSystem
        "FreeSpace(GB)" = "{0:N2}" -f ($_.FreeSpace /1GB)
        "Capacity(GB)" = "{0:N2}" -f ($_.Capacity/1GB)
    }
})

New-WordTable -Object $Volume -Columns 6 -Rows ($Volume.Count+1) –AsTable

And here:

 
$BIOS = @(Get-WmiObject Win32_Bios | ForEach {
    [pscustomobject] @{
        Manufacturer = $_.Manufacturer
        Name = $_.Name
        Version = $_.Version
        SerialNumber = $_.SerialNumber
        BIOSVersion = $_.SMBIOSBIOSVersion
    }
})

New-WordTable -Object $BIOS -Columns 2 -Rows ($BIOS.PSObject.Properties | Measure-Object).Count -AsList

Source Code

 
Function New-WordTable {
    [cmdletbinding(
        DefaultParameterSetName='Table'
    )]
    Param (
        [parameter()]
        [object]$WordObject,
        [parameter()]
        [object]$Object,
        [parameter()]
        [int]$Columns,
        [parameter()]
        [int]$Rows,
        [parameter(ParameterSetName='Table')]
        [switch]$AsTable,
        [parameter(ParameterSetName='List')]
        [switch]$AsList,
        [parameter()]
        [string]$TableStyle,
        [parameter()]
        [Microsoft.Office.Interop.Word.WdDefaultTableBehavior]$TableBehavior = 'wdWord9TableBehavior',
        [parameter()]
        [Microsoft.Office.Interop.Word.WdAutoFitBehavior]$AutoFitBehavior = 'wdAutoFitContent'
    )
    #Specifying 0 index ensures we get accurate data from a single object
    $Properties = $Object[0].psobject.properties.name
    $Range = @($WordObject.Paragraphs)[-1].Range
    $Table = $WordObject.Tables.add(
    $WordObject.Range,$Rows,$Columns,$TableBehavior, $AutoFitBehavior)

    Switch ($PSCmdlet.ParameterSetName) {
        'Table' {
            If (-NOT $PSBoundParameters.ContainsKey('TableStyle')) {
                $Table.Style = "Medium Shading 1 - Accent 1"
            }
            $c = 1
            $r = 1
            #Build header
            $Properties | ForEach {
                Write-Verbose "Adding $($_)"
                $Table.cell($r,$c).range.Bold=1
                $Table.cell($r,$c).range.text = $_
                $c++
            }  
            $c = 1    
            #Add Data
            For ($i=0; $i -lt (($Object | Measure-Object).Count); $i++) {
                $Properties | ForEach {
                    $Table.cell(($i+2),$c).range.Bold=0
                    $Table.cell(($i+2),$c).range.text = $Object[$i].$_
                    $c++
                }
                $c = 1 
            }                 
        }
        'List' {
            If (-NOT $PSBoundParameters.ContainsKey('TableStyle')) {
                $Table.Style = "Light Shading - Accent 1"
            }
            $c = 1
            $r = 1
            $Properties | ForEach {
                $Table.cell($r,$c).range.Bold=1
                $Table.cell($r,$c).range.text = $_
                $c++
                $Table.cell($r,$c).range.Bold=0
                $Table.cell($r,$c).range.text = $Object.$_
                $c--
                $r++
            }
        }
    }
}