c# pdf viewer itextsharp : Reorder pages pdf file control Library platform web page asp.net azure web browser Windows%20Powershell%20in%20Action%202nd%20Edition79-part1537

760
C
H
A
P T E R   1 8
Working with 
COM
18.1  Working with COM in PowerShell  761
18.2  Automating Windows with COM  764
18.3  Working with the WScript.Shell 
class  777
18.4  Using COM to manage 
applications  779
18.5  The WSH ScriptControl 
class  783
18.6  Working with the Windows 
Task Scheduler  786
18.7  Issues with COM 793
18.8  Summary  795
A horse! A horse! My kingdom for a horse! 
—King Richard in William Shakespeare’s 
The Life and Death of King Richard III 
At  the  end of Shakespeare’s Richard  III,  King Richard stands  upon  a plain,  sur-
rounded by foes, crying out for the one thing that he needs to continue on. Sort of 
like the noble sysadmin: “A tool! A tool! My kingdom for a tool!” Okay, perhaps not 
exactly like that, but at times, we do feel set upon from all sides, crying out desper-
ately for something to help us solve our problems. Fortunately, we in the PowerShell 
world do get our horse: a framework called the Component Object Model 
(COM)
which can help us win our battles by giving us access to the necessary facilities.
In this chapter, we’ll cover the important details of working with 
COM
from 
PowerShell. We’ll look at a number of examples that illustrate how 
COM
objects 
work and the sorts of tasks that can be accomplished. You’ll also learn how to lever-
age earlier Windows scripting technologies in PowerShell scripts.
Reorder pages pdf file - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
reordering pdf pages; reorder pages in pdf preview
Reorder pages pdf file - 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 move pages in pdf acrobat; how to move pages around in pdf
W
ORKING
WITH
COM 
IN
P
OWER
S
HELL
761
18.1
W
ORKING
WITH
COM 
IN
P
OWER
S
HELL
COM
is an interface specification describing how to write libraries that can be used 
from multiple languages or environments. Prior to technologies like 
COM
, each pro-
gramming language required its own set of libraries: Basic could only use libraries 
written for Basic, C could only use libraries written for C, and so on. The 
COM
spec-
ification allowed the creation libraries of components that could be accessed from mul-
tiple  languages.  But  beyond  simply  sharing library  code, 
COM
allowed  running 
applications  to  expose automation interfaces  that external programs could use  to 
remotely control them. In this section, we’ll introduce 
COM
and see how to leverage 
COM
classes using PowerShell. 
COM
provides easy (and in some cases trivial) access 
to many Windows features. We’ll work through a number of examples in a variety of 
application scenarios such as scheduling a task using the Windows task scheduler. 
Finally, we’ll complete our 
COM
coverage by examining some of the issues and limi-
tations the PowerShell scripter may encounter.
18.1.1
Creating COM objects
The first thing you need to know if you want to work with 
COM
(or any other object 
system for that matter) is how to create instances of 
COM
objects. As with .
NET 
objects, you use the 
New-Object
cmdlet, but for 
COM
objects, you have to specify 
the 
-ComObject
parameter. This signature is shown in figure18.1.
Notice that, unlike .
NET
objects, 
COM
doesn’t have a way to pass arguments to 
the object’s constructor, making it hard to initialize the object. As a workaround for 
this, in PowerShell v2 (and later), you use the 
-Property
parameter to initialize 
properties on the constructed object before returning it. 
Unique to the 
COM
parameter set is the -
Strict
switch. This switch tells the 
cmdlet to generate an error if a .
NET/COM
Interop
library is loaded. Explaining 
what this means and why it’s important is a bit complicated, so we’ll go through it in 
pieces in the next section.
COM and Interop assemblies
In chapter 3, we talked about how the PowerShell type system uses adaptation to give 
the user a consistent experience with different kinds of objects. 
COM
objects are one 
of these adapted types, but the way the PowerShell adapter works is affected by the
New-Object   [-ComObject] <ProgID>
-Strict -Property <Hashtable>
Cmdlet name
Class identifier for object to create
Indicates that raw COM
object must be returned
Table of key/value pairs used to
initialize instance properties
Figure 18.1 The 
New-Object
parameter set for creating COM objects
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
C# TIFF - Sort TIFF File Pages Order in C#.NET. Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview.
move pages in pdf online; how to rearrange pdf pages reader
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
C# .NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split may choose to only rotate a single page of PDF file or all
pdf rearrange pages; rearrange pages in pdf reader
762
CHAPTER 18
W
ORKING
WITH
COM
presence or absence of a 
COM
Interop
library. In effect, this 
Interop
library is 
.
NET
’s own adaptation layer for 
COM
. The net effect is that the PowerShell 
COM 
adapter will project a different view of a 
COM
object if an 
Interop
library is loaded 
versus when there’s no 
Interop
library. This becomes a problem because, for any 
given 
COM
class on any given machine, there may or may not be an 
Interop
library, 
so you may or may not get the doubly adapted 
COM
object. If you want to be able to 
write scripts that behave consistently everywhere, you need a way to control how the 
adaptation  is  done.  The 
-Strict
parameter allows you to detect this when an 
Interop
library is loaded. Once you know what’s happening, you can decide whether 
you want to fail or continue but along a different code path. This kind of portability 
issue is something to keep in mind when you’re writing a script using 
COM
that you 
plan to deploy on other machines. But for now, let’s move on to our next topic and 
see how to find out which 
COM
classes are available.
18.1.2
Identifying and locating COM classes
In this section, you’ll learn how to identify or name a 
COM
class and find out what 
classes are available on a machine. Officially, all 
COM
classes are identified by a glob-
ally unique 
ID
(GUID)
. The following example uses the .
NET
System.GUID
class to 
show you what a 
GUID
looks like:
PS (1) > [System.Guid]::NewGuid()
Guid 
----
aaae24e3-14ea-4f70-9234-dfc3cbce9fb8
This isn’t a particularly friendly way to identify—well, anything really. So, as far as 
PowerShell is concerned, 
COM
objects are identified by a much more usable name 
called the ProgID. This is a string alias that’s provided when the class is registered on 
the system. Using the 
P
rog
ID
is the most human-friendly way of identifying the 
object. By convention, the 
P
rog
ID
has the form 
<Program>.<Component>.<Version>
which (at least according to the 
MSDN
documentation) should be fewer than 39 
characters in length.
NOTE
Although  this  format  is  the recommended  way  to  create  a 
P
rog
ID
, there’s no real way to enforce it, resulting in some interesting 
interpretations  for  what  each  of  the  elements  means.  Generally,  it 
seems in practice that <Program> is the application suite, toolset, or 
vendor who installed it; <component> is the 
COM
classname; and the 
version number is normally not used in calls, though it may exist in 
even a multipart form. 
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
Sort and Reorder PowerPoint Slides Range with VB amount of robust PPT slides/pages editing methods powerful & profession imaging controls, PDF document, image
how to rearrange pdf pages online; how to reverse page order in pdf
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
Users can use it to reorder TIFF pages in ''' &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
pdf reverse page order; how to reorder pdf pages
W
ORKING
WITH
COM 
IN
P
OWER
S
HELL
763
COM
objects are registered in (where else?) the Registry. This means that you can use 
the Registry provider to search for 
P
rog
ID
s from PowerShell. Here’s a function we’ll 
call 
Get-ProgID
that will do it:
function Get-ProgID 
{
param ($filter = '.')
$ClsIdPath = "REGISTRY::HKey_Classes_Root\clsid\*\progid"
dir $ClsIdPath |
foreach {if ($_.name -match '\\ProgID$') { $_.GetValue("") }} |
where {$_ -match $filter} 
}
This searches through the Registry starting at the root of the classes hierarchy, where 
COM
objects are registered for keys whose paths end in “
P
rog
ID
.” From the keys, you 
retrieve the default property, which contains the name string of the 
P
rog
ID
. You 
check this string against the filter and, if it matches, write it to the output stream. 
Let’s try it out. You want to find the 
P
rog
ID
for Internet Explorer:
PS (1) > Get-ProgID internetexplorer 
InternetExplorer.Application.1
And there it is: 
InternetExplorer.Application.1
. This 
P
rog
ID
follows the rec-
ommended format: the program is 
InternetExplorer
and the component in this 
case is the actual Internet Explorer application. You can use this same pattern to find 
the automation interfaces for other applications. Let’s look for Microsoft Word:
PS (2) > Get-ProgID word.*applica
Word.Application.11
You find the 
P
rog
ID
for Microsoft Word 11. This function works for non-Microsoft 
applications as well. Let’s pick an application that you may have installed on your 
computer—say, Apple’s iTunes media player:
PS (3) > Get-ProgID itunes.*application 
iTunes.Application.1
Again, it follows the naming convention. 
Now let’s look at another way to find 
P
rog
ID
s: through 
WMI
(which is the subject 
of the next chapter). Here’s an alternate function that uses 
WMI
:
function Get-ProgID 
{
param ($filter = '.')
Get-WmiObject Win32_ProgIDSpecification |
where {$_.ProgId -match $filter} |
Select-Object ProgID,Description    
}
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
delete or remove certain page from PDF document file. C# PDF Page Processing: Sort PDF Pages - online C#.NET tutorial page for how to reorder, sort, reorganize
reordering pages in pdf document; change pdf page order
Read PDF in Web Image Viewer| Online Tutorials
for image viewing to read, edit, create or write PDF documents from file or stream in Extract images from PDF documents; Add, reorder pages in PDF
reordering pages in pdf; change pdf page order reader
764
CHAPTER 18
W
ORKING
WITH
COM
Not only is this script simpler, it also provides additional information: a description 
of the class. Let’s look up Microsoft Word again to see this in action:
PS (6) > (Get-ProgID word.application) | select-object –First 1
ProgID                        Description 
------                        -----------
Word.Application.11           Microsoft Word Application
This time you get the 
P
rog
ID
and its description. The downside to this mechanism is 
that it only locates a subset of the registered 
P
rog
ID
s, so the Registry-based script is 
usually the best approach.
Once you have the 
P
rog
ID
, you can use it with 
New-Object
to create instances 
of these objects. Starting the next section, you’ll see some of the things you can do 
using 
COM
.
18.2
A
UTOMATING
W
INDOWS
WITH
COM
The first area where you’ll apply 
COM
will be working with and automating basic 
features and services built into Windows itself. Table 18.1 lists a number of the classes 
that are useful in this area. Note that not all classes are available on all versions of 
Microsoft Windows
For the rest of section 18.2, we’ll focus on the 
Shell.Application
class and 
look at a number of examples demonstrating how to apply this class. The examples
Table 18.1 COM classes for accessing Windows features
Class ProgID
Description
Shell.Application
Provides access to Windows Explorer and its capabilities. 
Allows automation of many shell tasks like opening file 
browser windows; launching documents or the help system; 
finding printers, computers, or files; and so on.
SAPI.SpVoice
Provides access to the Microsoft Speech API. Allows text-to-
speech with the Speak("string") method. 
WMPlayer.OCX
Manipulates the Windows Media Player.
MMC20.Application
Manipulates the Microsoft Management Console application.
Agent.Control
Interface to the Windows Animated Agents framework. Allows 
animated characters to be displayed.
Microsoft.Update.Session
Provides access to the Windows Update Agent (WUA), allow-
ing you to scan, download, and install updates.
Schedule.Service 
Allows you to create and schedule tasks, get a list of running 
tasks, and delete task definitions (see section 18.6 for exam-
ples).
WScript.Shell
Provides access to system information and environment vari-
ables; lets you create shortcuts and work with the Registry 
(see section 18.3 for examples).
VB.NET TIFF: VB.NET Sample Code to Process & Manage TIFF Page
certain TIFF page, and sort & reorder TIFF pages in Process TIFF Pages Independently in VB.NET Code. powerful & profession imaging controls, PDF document, image
rearrange pdf pages; rearrange pages in pdf online
C# Word: How to Create Word Document Viewer in C#.NET Imaging
in C#.NET; Offer mature Word file page manipulation functions (add, delete & reorder pages) in document viewer; Rich options to add
move pages in pdf; how to move pdf pages around
A
UTOMATING
W
INDOWS
WITH
COM
765
start with automating Windows Explorer; then we’ll explore activating a Control 
Panel applet and automating an application by sending keystrokes to it.
18.2.1
Exploring with the Shell.Application class
In this section, you’ll learn how to automate the Windows file browser using the 
Shell.Application
COM
class. Through this class, Windows Explorer provides an 
automation model that allows you to automate a significant number of tasks. 
NOTE
Automation  model in this sense means  that there’s a 
COM 
object interface that lets an external program manipulate some aspects 
of an application.
The first thing you need to do is create an instance of this class:
PS (3) > $shell = New-Object -ComObject Shell.Application
As always in PowerShell, 
COM
objects, like any other object type, can be examined 
using 
Get-Member
. Let’s look at the members on the object you just created:
PS (4) > $shell | Get-Member
TypeName: System.__ComObject#{efd84b2d-4bcf-4298-be25-eb542a5 
9fbda}
Name                 MemberType Definition 
----                 ---------- ----------
AddToRecent          Method     void AddToRecent (Variant, st... 
BrowseForFolder      Method     Folder BrowseForFolder (int, ... 
CanStartStopService  Method     Variant CanStartStopService (... 
CascadeWindows       Method     void CascadeWindows () 
ControlPanelItem     Method     void ControlPanelItem (string) 
EjectPC              Method     void EjectPC ()
Explore              Method     void Explore (Variant) 
ExplorerPolicy       Method     Variant ExplorerPolicy (string) 
FileRun              Method     void FileRun ()
FindComputer         Method     void FindComputer ()
FindFiles            Method     void FindFiles ()
FindPrinter          Method     void FindPrinter (string, str... 
GetSetting           Method     bool GetSetting (int) 
GetSystemInformation Method     Variant GetSystemInformation ... 
Help                 Method     void Help ()
IsRestricted         Method     int IsRestricted (string, str... 
IsServiceRunning     Method     Variant IsServiceRunning (str... 
MinimizeAll          Method     void MinimizeAll ()
NameSpace            Method     Folder NameSpace (Variant)
Open                 Method     void Open (Variant) 
RefreshMenu          Method     void RefreshMenu () 
ServiceStart         Method     Variant ServiceStart (string,... 
ServiceStop          Method     Variant ServiceStop (string, ... 
SetTime              Method     void SetTime ()
ShellExecute         Method     void ShellExecute (string, Va... 
ShowBrowserBar       Method     Variant ShowBrowserBar (strin...
766
CHAPTER 18
W
ORKING
WITH
COM
ShutdownWindows      Method     void ShutdownWindows () 
Suspend              Method     void Suspend () 
TileHorizontally     Method     void TileHorizontally () 
TileVertically       Method     void TileVertically () 
ToggleDesktop        Method     void ToggleDesktop () 
TrayProperties       Method     void TrayProperties () 
UndoMinimizeALL      Method     void UndoMinimizeALL () 
Windows              Method     IDispatch Windows () 
WindowsSecurity      Method     void WindowsSecurity () 
Application          Property   IDispatch Application () {get} 
Parent               Property   IDispatch Parent () {get}
Woo-hoo! Jackpot! Look at all that stuff! Let’s try it out. Start with the 
Explore() 
method, which will launch an Explorer window on the path specified:
PS (10) > $shell.Explore("c:\")
At this point, you should see something like figure 18.2. This method call opened an 
Explorer window at the root of the 
C
: drive.
Here’s a handy function for laptop users who move around a lot. Many laptops 
have docking stations that allow you to easily connect multiple peripherals. This is 
great  except  that  you  need  to  undock  the  laptop  before  heading  to  a  meeting. 
Depending on the laptop, this can be annoying, so here’s a quick one-line function to 
undock a laptop:
function eject { ( New-Object -ComObject Shell.Application ).EjectPC() }
This function gets an instance of the 
Shell.Application
object and then calls the 
EjectPC()
method to undock the laptop.
NOTE
I love this function. I go to way too many meetings.
Figure 18.2  Launching the Windows Explorer on C:\
A
UTOMATING
W
INDOWS
WITH
COM
767
18.2.2
Managing browser windows using COM
Now let’s look at some examples where you actually work with the windows in Win-
dows. The 
Windows()
method on 
Shell.Application
allows you to get a list of the 
Explorer and Internet Explorer windows that are currently open:
PS (16) > ($shell.Windows()).count 
47
So there are 47 windows open in the current session. Let’s see what these 
Window 
objects look like:
PS (17) > $shell.Windows() | Get-Member | Format-Wide Definition
void ClientToWindow (int, int)     void ExecWB (OLECMDID, OLECMDEX... 
Variant GetProperty (string)       void GoBack () 
void GoForward ()                  void GoHome () 
void GoSearch ()                   void Navigate (string, Variant,... 
void Navigate2 (Variant, Varian... void PutProperty (string, Variant) 
OLECMDF QueryStatusWB (OLECMDID)   void Quit () 
void Refresh ()                    void Refresh2 (Variant) 
void ShowBrowserBar (Variant, V... void Stop () 
bool AddressBar () {get} {set}     IDispatch Application () {get} 
bool Busy () {get}                 IDispatch Container () {get} 
IDispatch Document () {get}        string FullName () {get} 
bool FullScreen () {get} {set}     int Height () {get} {set} 
int HWND () {get}                  int Left () {get} {set} 
string LocationName () {get}       string LocationURL () {get} 
bool MenuBar () {get} {set}        string Name () {get} 
bool Offline () {get} {set}        IDispatch Parent () {get} 
string Path () {get}               tagREADYSTATE ReadyState () {get} 
bool RegisterAsBrowser () {get}... bool RegisterAsDropTarget () {g... 
bool Resizable () {get} {set}      bool Silent () {get} {set} 
bool StatusBar () {get} {set}      string StatusText () {get} {set} 
bool TheaterMode () {get} {set}    int ToolBar () {get} {set} 
int Top () {get} {set}             bool TopLevelContainer () {get} 
string Type () {get}               bool Visible () {get} {set} 
int Width () {get} {set} 
Again, you see lots of tantalizing things to play with. Let’s try looking at the first item 
in the collection that was returned:
PS (21) > $shell.Windows()[0]
Unable to index into an object of type System.__ComObject. 
At line:1 char:18 
+ $shell.Windows()[0 <<<< ]
Hmm… you got an error. So what happened here? If you look at the type of the 
object returned by the method, you see that it’s of type 
System.__ComObject
, which 
is the .
NET
wrapper mechanism for accessing 
COM
objects. PowerShell, in turn, 
adapts the wrapped objects. Unfortunately, the adaptation mechanism isn’t perfect 
and this is one of the places where these imperfections show through. The PowerShell 
interpreter doesn’t know how to automatically index on these collections. This doesn’t
768
CHAPTER 18
W
ORKING
WITH
COM
mean that you can’t do it; you just have to work a bit harder. Instead of normal index-
ing syntax, you have to use the 
Item()
parameterized property. Parameterized proper-
ties are similar to methods in that they can take arguments like a method, but they 
can also be assigned to like a property, hence parameterized properties. In this case, 
the 
Item()
property is used for indexing a collection.
Let’s try it again:
PS (18) > $shell.Windows().Item(0)
Application          : System.__ComObject 
Parent               : System.__ComObject 
Container            : 
Document             : mshtml.HTMLDocumentClass 
TopLevelContainer    : True 
Type                 : HTML Document 
Left                 : 354 
Top                  : 80 
Width                : 838 
Height               : 489 
LocationName         : WinRM and WSMAN - Vista Forums 
LocationURL          : http://www.vistax64.com/network-shar
ing/187197-winrm-wsman.html 
Busy                 : False 
Name                 : Windows Internet Explorer 
HWND                 : 591430 
FullName             : C:\Program Files\Internet Explorer\i
explore.exe 
Path                 : C:\Program Files\Internet Explorer\ 
Visible              : True 
StatusBar            : True 
StatusText           :
ToolBar              : 1 
MenuBar              : True 
FullScreen           : False 
ReadyState           : 4 
Offline              : False 
Silent               : False 
RegisterAsBrowser    : False 
RegisterAsDropTarget : True 
TheaterMode          : False 
AddressBar           : True 
Resizable            : True
This output shows you lots of information about this window. You can see that it’s an 
Internet Explorer window along with the title and 
URL
of the page that’s being dis-
played in it. Let’s select just the name and 
URL
properties:
PS (19) > $shell.Windows() | 
>> Select-Object -First 1 locationname,locationurl | Format-List 
>>
LocationName : WinRM and WSMAN - Vista Forums 
LocationURL  : http://www.vistax64.com/network-sharing/187197-winrm-w
sman.html 
A
UTOMATING
W
INDOWS
WITH
COM
769
This is a browser page pointing at a forum with a question about 
WSM
an.
Okay, what else can you do with this object besides look at its properties? Well, 
for one thing, you can change a lot of those properties. For example, let’s turn off all 
the extra widgets that clutter up our browser windows to maximize our screen real 
estate. First, let’s get rid of the menu bar. Examine the current state of the menu bar 
by using
PS (10) > $shell.Windows().Item(0).MenuBar 
True
A browser window with the menu bar turned on is shown in figure 18.3.
You can turn it off by setting the 
MenuBar
property to 
$false
:
PS (19) > $shell.Windows().Item(0).MenuBar = $false
Figure 18.4 shows what the window looks like now. The menu bar is gone and you’ve 
reclaimed that space to view your web pages.
Figure 18.3 This figure shows a browser window where the menu bar is visible. 
Remember where the menu bar shows up, as you’ll hide it next.
Figure 18.4 This is how the browser window looks after running a PowerShell 
command to hide the menu bar. Compare this to the previous figure to verify 
that the menu bar is indeed gone.
Documents you may be interested
Documents you may be interested