c# pdf viewer itextsharp : How to move pages around in a pdf document software control cloud windows azure winforms class Windows%20Powershell%20in%20Action%202nd%20Edition78-part1536

750
CHAPTER 17
E
XTENDING
YOUR
REACH
WITH
.NET
Fortunately, you have a high-level scripting language you can use to build a library of 
functions to simplify this.
We’ll also look at using smarter layout managers that try to get rid of a lot of the 
manual positioning. In the next section, we’ll introduce a 
winforms
module called 
WPIAForms
that addresses these issues.
17.3.2
Creating a winforms module
There  are  a  lot  of  elements  in  building  a  Windows  Forms  application  that  are 
repeated over and over. If you’re working in an environment such as Visual Studio, 
the environment takes care of generating the boilerplate code. But if you’re building a 
form using Notepad, you need to be a bit more clever to avoid unnecessary work. 
Let’s build a module containing a number of convenience functions that make it eas-
ier to work with WinForms. We’ll call this module 
WPIAForms
. If this module is 
placed somewhere in your module path, then you can use it by including the line
Import-Module WPIAForms
at the beginning of your script. The code for this module is shown in the following 
listing.
Add-Type -Assembly System.Drawing, System.Windows.Forms 
function New-Size      
{
param (
[Parameter(mandatory=$true)] $x,
[Parameter(mandatory=$true)] $y
)
New-Object System.Drawing.Size $x,$y 
}
function New-Control                  
{
param (
[Parameter(mandatory=$true)]
[string]
$ControlName,
[hashtable] $Properties = @{}
)
$private:events = @{}
$private:controls = $null 
foreach ($pn in "Events", "Controls")  
{
if ($v = $Properties.$pn)
{
Set-Variable private:$pn $v
Listing17.3   The WPIAForms.psm1 module
Load required 
assemblies
b
Create Size 
objects
c
Create 
controls
d
Extract events, controls 
from hashtable
e
How to move pages around in a pdf document - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
reorder pdf pages online; reorder pages pdf file
How to move pages around in a pdf document - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
how to rearrange pages in a pdf file; reorder pdf pages in preview
P
OWER
S
HELL
AND
GRAPHICAL
USER
INTERFACES
751
$Properties.Remove($pn)
}
}
$private:control = if ($Properties.Count) {    
New-Object "System.Windows.Forms.$ControlName" `
-Property $Properties }
else {
New-Object "System.Windows.Forms.$ControlName" }
if ($controls) {                             
[void] $control.Controls.AddRange(@(& $controls)) }
foreach ($private:en in $events.keys)     
{
$method = "add_$en"
$control.$method.Invoke($events[$en])
}
if ($control -eq "form") {        
$c.add_Shown({ $this.Activate() }) }
$control                                  
}
The first thing a 
winforms
module should do is make sure that the necessary assem-
blies are loaded 
B
. (Remember that trying to load an assembly multiple times is 
harmless.)
Next you define a convenience function 
c
for creating 
Size
objects. Like many 
helper functions, it simply hides the long type names used to construct the objects.
Then you come to the heart of the module: the 
New-Control
function 
d
. This 
function is used to construct all the controls for your user interface. It takes as argu-
ments the name of the 
winforms
control class to instantiate and a hashtable contain-
ing three types of entries: 
• Simple properties to set on the control
• An Events hashtable specifying which control events you want to handle
• A scriptblock used to create the child controls for this form
The function iterates over the keys in the hashtable 
e
), looking to extract the 
Con-
trols
and 
Events
members because they aren’t simple properties on the object 
you’re creating. The scriptblock in the 
Controls
member will be evaluated and any 
control objects it returns will be added as children of the current control. The 
Events 
member requires more complex processing. It’s also a hashtable but, in this case, the 
keys are the names of control events and the values are the scriptblocks to bind to 
those events.
Once  the  two  special  members  have  been  extracted,  the  function  passes  the 
cleaned-up hashtable to the 
-Property
parameter on 
New-Object
to initialize 
the control. Unfortunately there’s an annoying limitation on 
-Property
: if the value
Construct 
control object
f
Add child 
controls
g
Bind event 
handlers
h
Ensure form 
is visible
i
Return configured 
control
j
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Page: Replace PDF Pages. Page: Move Page Position. Page: Extract, Copy and Users can view PDF document in single page or continue pages. Pan around the document.
rearrange pages in pdf document; move pages in pdf file
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Page: Replace PDF Pages. Page: Move Page Position. Page: Copy, Paste PDF Users can view PDF document in single page or continue pages. Pan around the document.
move pdf pages in preview; pdf change page order acrobat
752
CHAPTER 17
E
XTENDING
YOUR
REACH
WITH
.NET
passed to 
New-Object
is either 
$null
or empty, it will error out. This necessitates 
wrapping the call to 
New-Object
in an 
if
statement so 
-Property
only gets used 
when the hashtable is not empty.
Now that the control object exists, add any child controls that were extracted 
g
and bind any event handlers that were specified 
h
. One additional event handler is 
added to ensure that the window is visible 
i
. Finally, the completely configured 
control object is returned 
j
.
Although there doesn’t seem to be much to this library, it can significantly clarify 
the structure of the application you’re building. Try it out by re-implementing the 
one-button example and see what it looks like. The result is shown in figure 17.9.
The resulting code isn’t actually shorter but the hierarchical structure of the form 
is much more obvious. The top-level form is created using 
New-Control
and sets the 
title to “Hi” and the size of the form to 100 x 60. The 
Controls
member scriptblock 
creates the child controls for the form. In this case you’re adding a 
Button
object and 
again you use 
New-Control
to create the object, set the 
Text
and 
Dock
properties, 
and define the 
Click
event handler. Notice that at no point did you have to write 
any conditional loops—instead of describing how to build the form, you’ve simply 
declared what you want. In effect, you’ve created a simple domain-specific language 
(DSL)
for defining WinForms-based user interfaces.
NOTE
When PowerShell v1 was released, the only way to build a 
GUI 
with PowerShell was through script code. There were no 
GUI
builder 
tools available with support for the PowerShell language at that time. 
Things  have  changed considerably as  PowerShell has  become  more 
popular. By the time v2 was released, there were a number of 
GUI 
builders  on  the  market  that  supported  building  WinForms 
UI
 in 
PowerShell, including 
SAPIEN T
echnologies PrimalForms and iTrip-
oli’s Admin Script Editor (which has an integrated PowerShell forms 
designer). Both of these tools provide sophisticated PowerShell author-
ing environments as well as (or with) the forms designer. 
GUI
builders 
eliminate most of the manual layout and 
UI
construction code.
Figure 17.9 An example using 
the 
WPIAForms
module. Both 
the code and the resulting 
window are shown here.
C# WPF PDF Viewer SDK to view PDF document in C#.NET
Page: Replace PDF Pages. Page: Move Page Position. Page: Extract, Copy PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET Pan around the PDF document
how to reorder pages in pdf; how to change page order in pdf acrobat
VB.NET PDF - View PDF with WPF PDF Viewer for VB.NET
Page: Replace PDF Pages. Page: Move Page Position. Page: Copy, Paste PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET Pan around the PDF document.
how to rearrange pdf pages; how to reorder pdf pages in
P
OWER
S
HELL
AND
GRAPHICAL
USER
INTERFACES
753
Let’s see where you’ve ended up. In the previous example, you invented a rather lim-
ited 
DSL
for building 
GUI
s in a declarative way. Clearly the ability to separate user 
interface structure from the implementation logic is compelling, so it would be nice if, 
rather than inventing your own language, you could use an existing 
GUI
definition 
language. In practice, this  is  exactly what the  Windows Presentation Foundation 
(WPF)
is. Therefore, we’re going to spend some time seeing how 
WPF
can simplify 
building UIs in PowerShell.
17.3.3
PowerShell and Windows Presentation Foundation
In this section, you’ll learn how to use 
WPF
from PowerShell to construct 
GUI
s. 
WPF 
is a modern, markup-based approach to declaratively constructing a user interface, 
much more in tune with the web than the older code-based WinForms approach.
WPF
takes a different approach to constructing a 
GUI
compared to WinForms. 
With 
WPF
the UI is written  declaratively  using  an 
XML
-based markup  language 
called 
XAML
(Extensible Application Markup Language). The approach used in 
WPF 
is similar to the 
DSL
you wrote as well as to the way 
HTML
works: you describe the 
basic  components and  the framework  handles  all of the construction  details.  An 
important aspect of the design of 
WPF
is that the UI description is decoupled from the 
UI
logic. This separation of appearance and behavior aligns with well-established best 
practices for 
UI
design (such as coders write code and design specialists do design).
NOTE
If you want to see what happens when this rule is broken, take 
a look at some of the very early websites that were created. These stand 
as excellent testaments to the fact that, with very few exceptions, pro-
grammers aren’t designers.
In the next section, you’ll see how this all works by building a simple 
GUI
front end 
to  some  PowerShell  commands.  We’ll  only  cover  a  fraction  of  the  features  of 
WPF
—just enough to accomplish our goal of quickly building a simple 
UI
. First 
you’ll have to satisfy a few prerequisites before you can use 
WPF
from PowerShell.
WPF preconditions
Although 
WPF
has been around as long as PowerShell, in PowerShell v1, you weren’t 
able to use 
WPF
without a lot of tricks. This is because 
WPF
can only be called from 
an 
STA
-mode thread (yes, here it is again.) With PowerShell v2 and the 
-sta
param-
eter, this limitation ceases to be an impediment. (And in the ISE, which is a WPF 
application, you always run in 
STA
mode so, by default, everything will just work.)
The other thing you need to do to use 
WPF
in your scripts is to load the 
WPF 
assemblies, 
PresentationCore
and 
PresentationFramework
 using 
Add-Type
With  these  prerequisites out  of the  way, you  can start working  on  our  example 
project.
754
CHAPTER 17
E
XTENDING
YOUR
REACH
WITH
.NET
Building a file search tool
The goal of this exercise is to create a 
GUI
front end to the 
Get-ChildItem
and 
Select-String
cmdlets using 
WPF
. You want novice users to be able to execute a file 
search without having to be experts in PowerShell. A screen shot of the desired 
UI
is 
shown in figure 17.10.
In this form, the user can specify the path to search (defaulting to the current 
directory), the extension of the files to search, and the pattern to use when searching 
the file text. By default, regular expressions will be used in the text search, but an 
option is provided to suppress this. There are also options to indicate that subfolders 
should be searched as well and that only the first match in each file may be returned. 
At the bottom of the dialog box, there are buttons to run or cancel the search. There’s 
also a button that will display the command to be run before executing it—a very 
useful mechanism for learning PowerShell. 
Although this is a very simple dialog box, it would be annoying to implement 
with WinForms
due to all the manual control layout required. In the next section, 
you’ll learn how easily you can describe this form with 
XAML
.
Defining the search form’s appearance
In this section, we’re going to jump right into the user interface markup for the form. 
The 
XAML
text for the interface is shown in the following listing.
<Window                                             
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
Title="PowerSearch: Search Files for String"     
SizeToContent="WidthAndHeight" >                
<DockPanel>
<StackPanel HorizontalAlignment="Left" Orientation="Horizontal"
Width="425" DockPanel.Dock="Top" Margin="10,17,10,17">
<Label Width="100" >Path to search</Label> 
Figure 17.10 A dialog 
box that front-ends 
the PowerShell 
Get-ChildItem
and 
Select-String
cmdlets, allowing users 
to search with Power-
Shell even if they don't 
know the language
Listing17.4   The search.xaml file declaring the file search interface
Create 
top-level
window
Create 
StackPanel
to hold 
controls
Add Label to 
StackPanel
P
OWER
S
HELL
AND
GRAPHICAL
USER
INTERFACES
755
<TextBox Name="Path" Width="300" >Add Row</TextBox>
</StackPanel>
<StackPanel HorizontalAlignment="Left" Orientation="Horizontal"
Width="425" DockPanel.Dock="Top" Margin="10,17,10,17">
<Label Width="70" >File Filter</Label>
<ComboBox Name="FileFilter" Width="100" IsEditable="True">
*.ps1
</ComboBox>
<Label Width="100" >Search Pattern</Label>
<TextBox Name="TextPattern" Width="125" >
function.*[a-z]+
</TextBox>
</StackPanel>
<StackPanel HorizontalAlignment="Left" Orientation="Horizontal"
Width="425" DockPanel.Dock="Top" Margin="10,17,10,17">
<CheckBox Name="UseRegex" Width="150" >
Use Regular Expressions
</CheckBox>
<CheckBox Name="Recurse" Width="150" >
Search Subfolders
</CheckBox>
<CheckBox Name="FirstOnly" Width="150" >
First Match Only
</CheckBox>
</StackPanel>  
<StackPanel HorizontalAlignment="Left" Orientation="Horizontal"
DockPanel.Dock="Top" Margin="75,5,5,5">
<Button Width="100" Name="Run" Margin="5,0,5,0" >
Run Command
</Button>
<Button Width="100" Name="Show" Margin="5,0,5,0" >
Show Command
</Button>
<Button Width="100" Name="Cancel" Margin="5,0,5,0" >
Cancel
</Button>
</StackPanel>  
</DockPanel> 
</Window>
Looking through the 
XAML
code, you see a lot of things that are familiar from the 
WinForms examples: 
Label
controls, 
TextBox
es, 
Button
s, and so on. This means 
that you don’t have to learn a lot of new concepts, just a new way to describe how 
they should be put together. In this UI description, the dialog box is constructed as a 
set of rows of controls. A 
StackPanel
layout control is used to arrange the elements 
in each row and a 
DockPanel
holds all the rows. Let’s look at one of the control dec-
larations in detail. The 
XAML
that declares the Run button looks like this:
<Button Width="100" Name="Run" Margin="5,0,5,0" >               
Run Command 
</Button>
Simply by inspecting the text, you can see that you’re creating a 
Button
control, set-
ting the 
Width
property on that control to 100, and setting the control 
Margin
Add named
TextBox to 
StackPanel
Create another
StackPanel for 
next row
Add ComboBox for 
file filter
Add dialog 
buttons to 
bottom
756
CHAPTER 17
E
XTENDING
YOUR
REACH
WITH
.NET
property with values for left, top, right and bottom margins. Of particular impor-
tance is the 
Name
property that lets you associate a unique name string with the con-
trol. You’ll need this information later when you’re binding actions to the controls.
This 
XAML
document describes what our form will look like but it doesn’t say 
anything about how it behaves. 
NOTE
At this point, the 
XAML
experts in the audience will be shout-
ing that there are, in fact, many elements in 
XAML
that do let you 
describe behaviors (animations, triggers, and such). These features are 
beyond the scope of this exercise, but you’re encouraged explore all the 
things that can be done with 
XAML
. It’s amazing how much you can 
accomplish just using markup.
In the next section, we’ll introduce a PowerShell script that will “light up” your user 
interface.
Specifying the form’s behavior
In the previous section, you described your form’s appearance using 
XAML
markup. 
In this section you’ll learn how to attach your business logic to this markup. 
To display your form, you must load the 
XAML
into the session and use it to cre-
ate an instance of 
System.Windows.Window
. The 
WPF
framework includes utility 
classes to do most of the heavy lifting for this task. Once you have the 
UI
object, you 
just have to attach PowerShell actions to the controls. The following listing shows the 
script that does both of these things for you.
Add-Type -Assembly PresentationCore,PresentationFrameWork
trap { break }
$mode = [System.Threading.Thread]::CurrentThread.ApartmentState 
if ($mode -ne "STA") 
{
$m = "This script can only be run when powershell is " +
"started with the -sta switch."
throw $m 
}
function Add-PSScriptRoot ($file)                     
{
$caller = Get-Variable -Value -Scope 1 MyInvocation
$caller.MyCommand.Definition |
Split-Path -Parent |
Join-Path -Resolve -ChildPath $file 
}
$xamlPath = Add-PSScriptRoot search.xaml
Listing17.5   search.ps1: defining the file search behavior
Load WPF 
assemblies
Compute path 
to XAML file
P
OWER
S
HELL
AND
GRAPHICAL
USER
INTERFACES
757
$stream = [System.IO.StreamReader] $xamlpath     
$form = [System.Windows.Markup.XamlReader]::Load(
$stream.BaseStream) 
$stream.Close()
$Path = $form.FindName("Path")           
$Path.Text = $PWD
$FileFilter = $form.FindName("FileFilter")      
$FileFilter.Text = "*.ps1"
$TextPattern = $form.FindName("TextPattern") 
$Recurse = $form.FindName("Recurse")
$UseRegex = $form.FindName("UseRegex")          
$UseRegex.IsChecked = $true
$FirstOnly = $form.FindName("FirstOnly")
$Run = $form.FindName("Run")             
$Run.add_Click({
$form.DialogResult = $true
$form.Close()
})
$Show = $form.FindName("Show") 
$Show.add_Click({Write-Host (Get-CommandString)})
$Cancel = $form.FindName("Cancel") 
$Cancel.add_Click({$form.Close()})
function Get-CommandString            
{
function fixBool ($val) { '$' + $val }      
"Get-ChildItem $($Path.Text) ``
-Recurse: $(fixBool $Recurse.IsChecked) ``
-Filter '$($FileFilter.Text)' |
Select-String -SimpleMatch: (! $(fixBool $UseRegex.IsChecked)) ``
-Pattern '$($TextPattern.Text)' ``
-List: $(fixBool $FirstOnly.IsChecked)" 
}
if ($form.ShowDialog())              
{
$cmd = Get-CommandString
Invoke-Expression $cmd 
}
As was the case with the contents of the 
XAML
file, there are many elements in this 
script that should be familiar from the WinForms examples. To add an action to a 
button, you use the 
add_Click()
event method just like you did with WinForms. 
You use the 
Text
property on 
TextBox
controls to get and set the contents of those 
controls. Check boxes have an 
IsChecked
property, as was the case with WinForms.
Load XAML that 
constructs UI
Find and set Path 
control to $PWD
Set default file 
filter extension
Set up CheckBox 
controls
Bind button 
Click actions
Build command 
string
Format Booleans so 
"True" becomes $true
Show form 
and wait
758
CHAPTER 17
E
XTENDING
YOUR
REACH
WITH
.NET
The biggest difference here is that, instead of binding actions as you construct the 
form, the 
XAML
loader does all the construction and returns the completed object. 
You then have to find the controls by name to be able to access them. In practice, this 
turns out to be pretty simple. Once you’ve located the control objects, everything else 
is much the same as it was with WinForms. The 
Get-CommandString
function is 
used to generate a string containing the PowerShell command that will perform the 
actual  search.  This  function  uses  the retrieved  control  objects  along  with  string 
expansion to produce a complete command.
Advantages of using WPF
The biggest advantage of using 
WPF
is the separation of 
UI
description from 
UI 
behavior. By not mixing code and markup, each piece becomes simpler and can be 
modified fairly independently. For example, because you’re identifying the controls 
by name, it doesn’t matter where they get moved around in the form; you’ll still get 
the correct control when you ask for it by name.
The other big advantage to this separation of concerns is that you can now use all 
the 
WPF XAML GUI
builders with PowerShell. Unlike WinForms, where the tools 
needed to know PowerShell to work, 
XAML
is 
XAML
so the actual programming 
language (for the most part) doesn’t matter and the 
UI
can be designed indepen-
dently, decoupled from any code. This also means that the 
UI
can be designed by an 
expert 
UI
designer and the code added by an expert scripter. Finally, the higher-level 
nature of the 
WPF
framework means  that more effective PowerShell 
GUI
frame-
works can be created.
PowerShell frameworks for WPF
Inspired by possibilities that arise from the combination of PowerShell and 
WPF/ 
XAML
, the PowerShell community has created a number of higher-level libraries for 
building 
WPF GUI
s in PowerShell. As of this writing there are two good libraries 
available free for download:
• The 
WPK
library written by James Brundage, who was a member of the Power-
Shell team. This library is available at http://code.msdn.microsoft.com/Power-
ShellPack.
• The 
PowerBoots
library, originally written and coordinated by Joel “Jaykul” 
Bennett, who is  a PowerShell 
MVP
. PowerBoots is available on CodePlex at 
http://powerboots.codeplex.com/.
Both of these libraries are packaged as PowerShell modules and provide a multitude 
of useful features. And with that, we’ve finished our tour of .
NET
and what you can 
do with it.
S
UMMARY
759
17.4
S
UMMARY
We introduced a number of areas where PowerShell can be applied thanks to its abil-
ity to access classes in the .
NET F
ramework. When a particular application domain 
may not have adequate coverage through cmdlets, if there’s a .
NET API
for that area, 
the odds are good that PowerShell can be used to script it.
The first part of this chapter focused on expanding our knowledge of .
NET
. We 
covered a variety of areas:
• Basic concepts in .
NET
and the common language runtime 
• How to load assemblies into the PowerShell session using the 
Add-Type
cmdlet 
with the 
-AssemblyName
parameter
• How to represent type names, including generic types, in the PowerShell lan-
guage and how to create instances of these types using the 
New-Object
cmdlet 
• Using the 
Add-Type
cmdlet to create new .
NET
types dynamically in a Power-
Shell session
The next section of the chapter looked at some of the application domains supported 
by .
NET
. These examples included network programming in PowerShell. We looked at
• Retrieving a simple web page in a script using the 
System.Net.WebClient
class
• How to address more complex scenarios with the 
WebClient
class such as using 
PowerShell's built-in 
XML
support to process an 
RSS
feed
• How to build graphical interfaces for PowerShell using Windows Forms and 
WPF
In the next chapter we’ll continue with our exploration of Windows technologies and 
look at 
COM
and how it expands what you can do with PowerShell.
Documents you may be interested
Documents you may be interested