Wednesday July 20th I’ll be joining fellow ShowUI authors James Brundage and Joel “Jaykul” Bennett on the PowerScripting Podcast.

ShowUI is a PowerShell module to help build WPF user interfaces in script. ShowUI makes the complicated world of WPF easy to use in PowerShell. You can use ShowUI to write simple WPF gadgets, quick front ends for your scripts, components, and full applications.

Related

• My  MSDN article: Secrets to Building a WPF Application in Windows PowerShell

• Post: PowerShell, ShowUI and the Twitter API and video tutorial

• More videos on the ShowUI CodePlex page

More updates coming soon.

Updates

This version lets you view multiple Twitter search feeds. Type in a search and press enter and another column is displayed. You can delete a column too.

PowerShell Code

Download it HERE from my repository. Download ShowUI.

Import-Module showui            
            
function Search-Twitter {            
    param (             
        [Parameter(ValueFromPipeline=$true)]            
        $query            
    )            
                
    Begin { $wc = New-Object Net.Webclient }            
                
    Process {            
        $url = "http://search.twitter.com/search.rss?q=$query"            
        ([xml]$wc.downloadstring($url)).rss.channel.item |            
            Select *            
    }            
}            
            
function New-TwitterFeed ($search) {            
            
    $guid = "g" + [guid]::NewGuid() -replace "-",""            
                
    $buttonAttributes = @{            
        Margin = 5            
        HorizontalAlignment = "Right"            
        Height = 25             
        Tag = $guid             
    }            
                
    $labelAttributes = @{            
        FontSize = 20             
        Margin = 5             
        Foreground = "White"            
    }            
                
    Grid -Name $guid -Rows 45, 100* -Tag $search {            
        Grid -Row 0 -Columns 2 {                        
            Label -Column 0 $Search @labelAttributes            
            Button " X " -Column 1 @buttonAttributes -On_Click {            
                $name = "`$$($this.tag)"            
                $targetLayout.Children.Remove(($name|iex))                            
            }            
        }            
                    
        ListBox -Background Black -Row 1 -Margin 5 -DataContext {            
            Search-Twitter $search            
        } -DataBinding @{            
            ItemsSource="."            
        } -ItemTemplate {            
            $tweetTbAttributes = @{            
                FontSize = 12            
                Margin = 5             
                TextWrapping = "wrap"            
                Foreground = "White"            
            }            
                                  
            Grid -Columns 55, 300 {            
                Image     -Name Image  -Column 0 -Margin 6            
                TextBlock -Name Title @tweetTbAttributes -Column 1             
            } | ConvertTo-DataTemplate -binding @{            
                "Image.Source" = "image_link"            
                "Title.Text" = "title"            
            }            
        }            
    }            
}            
            
function ql {$args}            
            
$windowAttributes = @{            
    WindowStartupLocation = "CenterScreen"            
    Width = 1200            
    Height = 600            
    Background = "Black"            
    Title = "PowerShell, ShowUI and the Twitter API"            
}            
            
$scrollViewerAttributes = @{            
    VerticalScrollBarVisibility = "Disabled"            
    HorizontalScrollBarVisibility = "Auto"            
}            
            
$textBboxAttributes = @{            
    Margin = 5             
    Background = "DarkGray "            
    Foreground = "#FFFFFF"             
    FontSize = 14            
}            
            
New-Window @windowAttributes -Show -On_Loaded {            
    $search.focus()            
    ql PowerShell ShowUI dfinke jamesbru  jaykul |             
        ForEach {             
            $targetLayout.Children.Add( (New-TwitterFeed $_ $tabcontrol) )             
        }            
} {            
    Grid -Columns 35*, 75 -Rows 35, 100* {            
            
        TextBox -Name Search -Row 0 -Column 0 @textBboxAttributes            
            
        Button -IsDefault -Row 0 -Column 1 -Margin 5 "_Search" -On_Click {                        
            $targetLayout.Children.Add( (New-TwitterFeed $Search.Text) )            
            $Search.Text = ""            
        }            
            
        ScrollViewer -Row 1 -Column 0 -ColumnSpan 2 @scrollViewerAttributes {            
            UniformGrid -Name targetLayout -Rows 1            
        }            
    }            
}

• A windowless window
• Ticking digital clock
• Moving the window by clicking and dragging even though it doesn’t have a border

The ShowUI Code

Here is the ShowUI code. Note the On_* keys in the hash table. They handle the mouse button events and the windows load event where I register a PowerShell script block that executes every half a second. This updates the time and enables the ticking digital clock.

Richard’s solution has the advantage that he can deploy it and it should work on any windows system that has the latest .NET runtime.

My solution requires the ShowUI module to be installed on the target machine.

The advantages to my solution, IMHO, are no XAML, increased value per line of code and it’s all PowerShell.

Check out both solutions and ShowUI.

Import-Module ShowUI            
            
$windowAttributes = @{            
    WindowStartupLocation = "CenterScreen"            
    SizeToContent = "WidthAndHeight"             
    WindowStyle = "None"            
    Background = "Transparent "            
            
    On_MouseRightButtonDown = { Close-Control}             
    On_MouseLeftButtonDown  = { $_.Handled = $true;$window.DragMove() }            
    On_Loaded = {            
        Register-PowerShellCommand -ScriptBlock {            
            $window.Content.Content = (Get-Date).ToString("T")            
        } -Run -In "0:0:0.5"            
    }            
}            
            
$labelAttributes = @{            
    Content = (Get-Date).ToString("T")            
    FontFamily = "Impact, Arial"            
    FontWeight = 800            
    FontSize = 90             
}            
            
New-Window @windowAttributes -AllowsTransparency -Show  {            
    Label @labelAttributes -Name Clock -Foreground (            
        LinearGradientBrush $(            
            GradientStop -Color Red    -Offset 1            
            GradientStop -Color Orange -Offset 0.85            
            GradientStop -Color Yellow -Offset 0.7            
            GradientStop -Color Green  -Offset 0.55            
            GradientStop -Color Blue   -Offset 0.4            
            GradientStop -Color Indigo -Offset 0.2            
            GradientStop -Color Violet -Offset 0            
        )            
    )            
}

Related Topics

• My “Hello World” video tutorial of ShowUI
• PowerShell, ShowUI and the Twitter API
• Other ShowUI video tutorials from James Brundage, one of the authors of ShowUI

Secrets to Building a WPF Application in Windows PowerShell

Special bonus

Windows PowerShell creator Jeffrey Snover weighs in on the Ad Hoc development model and origin of the language.

Related Topics

• ShowUI: Write-UI –in PowerShell – A PowerShell module to help build WPF user interfaces in script
• My “Hello World” video tutorial of ShowUI
• PowerShell, ShowUI and the Twitter API
• Other ShowUI video tutorials from James Brundage, one of the authors of ShowUI

Thank You

I want to thank Jeffrey Snover, Distinguished Engineer, Lead Architect for Windows Server and father of PowerShell. He eagerly and graciously agreed to write the sidebar for the article and offered great feedback.

Also, thank you to James Brundage, founder and lead developer of Start-Automating, creator of the PowerShell Pack and WPK. He provided excellent insight on my drafts. Hat tip to Joel Bennet, author of PowerBoots.

Finally, thank you to my colleagues who took the time to read and offer suggestions.

ShowUI: Write-UI –in PowerShell

While the article was going through technical and copy editing, the authors of WPK and PowerBoots merged the two frameworks, WPK + PowerBoots => PowerShell ShowUI.

Video Tutorials

I put together a “Hello World” demo of ShowUI. Plus this post PowerShell, ShowUI and the Twitter API.

Definitely check out these other ShowUI video tutorials.

Updated PowerShell Script for the Article

Here is the ShowUI version of the PowerShell script I did in the MSDN article.

Basic Building Blocks

In the video I demo the basic building blocks you’ll reuse over and over. New-Window, New-StackPanel, New-Label, New-Button and more.

Take a look and let me know what questions you’d liked answered. I’ll include them in the next set of video tutorials.

ShowUI is a PowerShell module to help build WPF user interfaces in script. ShowUI makes the complicated world of WPF easy to use in PowerShell. You can use ShowUI to write simple WPF gadgets, quick front ends for your scripts, components, and full applications.

History

Back in 2008 I blogged about Ruby Shoes and the start of a PowerShell version. Shoes is a GUI framework for Ruby. I figured why not a WinForms GUI framework for PowerShell.

Here is the Ruby Shoes example in ShowUI today:

Joel ‘Jaykul’ Bennett figured the same, but using WPF,  leaving a comment on my post about working on something he called PowerBoots.

Meanwhile James Brundage, founder of Start-Automating and former member of the Microsoft PowerShell Team, was working on WPK, that was released as the part of the PowerShell Pack.

I was lucky enough to get an early look at both of these excellent frameworks. These two powerhouse PowerShell guys decided to merge them, taking the best of both and kicking it up a notch. Once again, I am lucky enough to be involved, hear the discussions and contribute to the project.

CodePlex Projects

Here are two other WPF/PowerBoots projects I have. I’ll be doing more blogs and updating these projects to ShowUI soon.

• Try PowerShell
• OData PowerShell Explorer

One system I wrote contained:

• 105 PowerShell script files
• 151 functions
• Over 4 KLOCs (read Kay-Locks, meaning 4,000 lines of code). 

Compared to the PowerShell Pack WPK set of scripts having:

• 73 files
• 722 functions
• More than 100 KLOCs

Maybe you keep your scripts in separate directory and each are for a different task.

Select-String – Finds text in strings and files

While Select-String is a useful and must know cmdlet, if searching for a function name you will find that name when it is contained in a comment or random string. Sometimes you don’t want to see that.

Get-Function Finds and Returns Only Function Names

Get-Function searches all PowerShell files from the current directory and returns only function names. Plus, you can provide a partial name and Get-Function will do a match. The following output is the result of running Get-Function in the $PSHOME\Modules\PSDiagnostics directory.

FunctionName                 FileName                     Line
------------                 --------                     ----
Start-Trace                  C:\Windows\System32\Wind...    20
Stop-Trace                   C:\Windows\System32\Wind...    96
Enable-WSManTrace            C:\Windows\System32\Wind...   122
Disable-WSManTrace           C:\Windows\System32\Wind...   152
Enable-PSWSManCombinedTrace  C:\Windows\System32\Wind...   157
Disable-PSWSManCombinedTrace C:\Windows\System32\Wind...   179
Set-LogProperties            C:\Windows\System32\Wind...   184
ConvertTo-Bool               C:\Windows\System32\Wind...   223
Get-LogProperties            C:\Windows\System32\Wind...   235
Enable-PSTrace               C:\Windows\System32\Wind...   262
Disable-PSTrace              C:\Windows\System32\Wind...   269

The Script

Get-Function recursively searches from the current directory (the default that can be overridden), then uses the PowerShell tokenizer (see line 8 ) to select only script statements that are functions and returns the name of that function (see lines 13 and 14). It creates and emits to the pipeline a PSObject that holds the FileName, FunctionName and Line Number. Finally, the where cmdlet is used to filter only the function names you’d like, if provided.

As with other PowerShell output, the results from Get-Function can be saved to a file, piped to Out-GridView or piped to other cmdlets like Group-Object.

Function Get-Function ($pattern, $path="$pwd") {            
             
 $parser  = [System.Management.Automation.PSParser]            
             
 Get-ChildItem $path -Recurse -Include *.ps1, *.psm1 | ForEach {             
             
   $content = [IO.File]::ReadAllText($_.FullName)            
   $tokens  = $parser::Tokenize($content, [ref] $null)            
   $count   = $tokens.Count             
                   
   $(            
       for($idx=0; $idx -lt $count; $idx += 1) {            
            if($tokens[$idx].Content -eq 'function') {            
                $targetToken = $tokens[$idx+1]            
                New-Object PSObject -Property @{            
                   FileName = $_.FullName            
                   FunctionName = $targetToken.Content             
                   Line = $targetToken.StartLine            
                } | Select FunctionName, FileName, Line            
            }            
       }             
   ) | Where {$_.FunctionName -match $pattern}            
 }            
}

My talk was on PowerShell for .NET Developers. Here is a recording I did on that topic for Microsoft Channel 9 geekSpeak.

The attendees were great. Of the 50+, all heard about PowerShell and a few were using it in Production.

The questions went deep too:

• Can you embed PowerShell in a C# app?
• How to Host PowerShell in a WPF Application
• Does it work with OData?
• PowerShell WPK NetFlix Viewer Using Microsoft’s OData
• OData PowerShell Explorer
• Can you automate Excel with PowerShell?
• PowerShell Out-ExcelPivotTable – Quickly Create Pivot Tables in Microsoft Excel
• and more…

Thanks to NYC Code Camp organizers, sponsors and volunteers who put in an amazing effort to make these events happen.

I created his version in PowerShell using the WPK module from the PowerShell Pack. You’ll need to download and install the PowerShell Pack if you want to run the script.

Check out the source below, download it and give it a try.

If we want to see what items they have in common, click the ‘intersection’ button. result (1 row) john
To see which items are in the list on the left but not in the list on the right? Click ‘left only.’ result (3 rows) paul george ringo
To see the ‘right only’ items click ‘right only.’ result (3 rows) matthew mark luke
To grab all the items press ‘union.’ (You may notice that items from both lists will be repeated accordingly). result (8 rows) john paul george ringo matthew mark luke john
To find the distinct members of the result set, press ‘distinct’ (under the ‘result’) result (7 rows) john paul george ringo matthew mark luke
To sort the results, as you often need to, press the sort button, under the result. result (7 rows) george john luke mark matthew paul ring

The Code

The script uses some interesting aspects of PowerShell. Like the function ql which creates lists, well, quickly. Notice how the correct function is called  (intersection, union etc) using the call operator ‘&’ and the contents of the button that is clicked. Also checkout how splatting simplifies the script when creating the buttons and textboxes.

Import-Module WPK            
            
function ql {$args}            
            
$beatles = (ql john paul george ringo) -join "`r`n"             
$gospels = (ql matthew mark luke john) -join "`r`n"             
            
function intersection ($l, $r) { $l | % { $r -eq $_ } }            
function left-Only    ($l, $r) { $l | % { if(!($r -eq $_)) { $_ } } }            
function right-Only   ($l, $r) { $r | % { if(!($l -eq $_)) { $_ } } }            
function union        ($l, $r) { $l + $r }            
            
function Compare-Lists ($window, $targetButton) {            
    $lhs = ($window | Get-ChildControl Left).Text            
    $rhs = ($window | Get-ChildControl Right).Text            
            
    ($window | Get-ChildControl Results).Text = @(            
        & $targetButton.Content ($lhs -split "`r`n") ($rhs -split "`r`n")            
    ) -join "`r`n"            
}            
            
function PostProcess-List ($window, $targetButton) {            
    $txtBox  = $window | Get-ChildControl Results             
    $left    = $window | Get-ChildControl Left            
    $right   = $window | Get-ChildControl Right            
                
    $results = @($txtBox.Text -split "`r`n")            
                
    switch ( $targetButton.Content ) {            
        "distinct"   { $results = $results | select -Unique }            
        "sort"       { $results = $results | sort }            
        "invert"     { [array]::Reverse($results) }            
        "copy left"  { $left.Text = $txtBox.Text;  return }            
        "copy right" { $right.Text = $txtBox.Text; return }            
    }            
                
    $txtBox.Text = ($results) -join "`r`n"             
}            
            
New-Window -WindowStartupLocation CenterScreen -Width 500 -Height 500 -show {            
    New-Grid -Rows Auto, 300* {            
        $buttonStyle = @{            
            Margin = 4             
            Height = 32             
            VerticalAlignment = "top"            
        }            
                    
        $textBoxStyle = @{            
            Row = 0             
            Margin = 4             
            AcceptsReturn = $true            
            VerticalScrollBarVisibility = "Auto"            
        }            
                    
        New-Grid -Row 0 -Columns 2 -Rows 2 -VerticalAlignment top {            
                        
            New-TextBox -Name Left  -Text $beatles -Column 0 @textBoxStyle            
            New-TextBox -Name Right -Text $gospels -Column 1 @textBoxStyle            
                        
            New-StackPanel -Row 1 -Column 0 -ColumnSpan 2 -Orientation Horizontal {            
                New-Button "union"        @buttonStyle -On_Click { Compare-Lists $window $this }            
                New-Button "left-only"    @buttonStyle -On_Click { Compare-Lists $window $this }            
                New-Button "intersection" @buttonStyle -On_Click { Compare-Lists $window $this }            
                New-Button "right-only"   @buttonStyle -On_Click { Compare-Lists $window $this }            
            }            
        }            
                    
        New-Grid -Row 1 -Rows 1*, 40 -Margin 4 {            
            New-TextBox -Name Results -Row 0 -Margin 4 -MinHeight 275            
            
            New-StackPanel -Row 1 -Column 0 -ColumnSpan 2 -Orientation Horizontal {            
                New-Button "distinct"   @buttonStyle -On_Click { PostProcess-List $window $this }            
                New-Button "sort"       @buttonStyle -On_Click { PostProcess-List $window $this }            
                New-Button "invert"     @buttonStyle -On_Click { PostProcess-List $window $this }            
                New-Button "copy left"  @buttonStyle -On_Click { PostProcess-List $window $this }            
                New-Button "copy right" @buttonStyle -On_Click { PostProcess-List $window $this }            
            }            
        }                    
    }            
}

Download It