Professional Documents
Culture Documents
TRAINING GUIDE
Version: 5.0.2
For the avoidance of doubt, except as permitted by the license or these terms, you cannot (a) copy, translate, reverse engineer, reverse
assemble, modify, adapt, create derivative works of, decompile, merge, separate, disassemble, determine the source code of or
otherwise reduce to binary code or any other human-perceivable form, the whole or any part of the Training Materials; (b) sublease,
lease, assign, sell, sub-license, rent, export, re-export, encumber, permit concurrent use of or otherwise transfer or grant other rights in
the whole or any part of the Training Materials; or (c) provide or otherwise make available the Training Materials in whole or in part in
any form to any person, without prior written consent from Blue Prism.
All trademarks are hereby acknowledged and are used to the benefit of their respective owners.
Blue Prism is not responsible for the content of external websites referenced by this document.
Blue Prism Limited, Centrix House, Crow Lane East, Newton-le-Willows, WA12 9UY, United Kingdom
Registered in England: Reg. No. 4260035. Tel: +44 870 879 3000. Web: www.blueprism.com
The course will focus exclusively on the object layer of Blue Prism and objects are provided for the trainees to work
on and complete. The course will explore the most common application elements and the most appropriate way of
interfacing with them according to Blue Prism Best Practice.
Finally, the course touches the more advanced topics of font creation, character conflicts, and performance.
The course will be intensive and is for developers of Foundation level who have completed the Introduction to
Surface Automation course and are familiar with the basics of:
Region Editor.
System Font identification.
Tracking elements around the screen.
Controlling a thin client application using mouse clicks and key strokes.
During this course please bear in mind the following tips:
The Identify Font Automatic feature of Region Editor is not guaranteed to always find your font for you. If it
does not identify your font you will need to manually identify the font which may involve some
experimentation. The font in the training application is Arial 9.5.
If Recognize Text in a read stage does not work, the most likely causes will be either your font is not set
correctly, or otherwise your region is not accurate enough. Play around with the size of your region to try
and get your read stage to work.
To check if a dynamic region is correct, you can use a temporary Read stage to read the image of your region
into an Image data item. Once read, you can check the image to see if the region was set correctly.
Be careful to ensure your regions do not include the border lines from edit boxes around your text.
Always remember that the application window must be active for Global clicks to work. Elements you want
to send Global Send Keys text to must have focus by first tabbing into or click in them.
Be careful when debugging your work in Object Studio, as Blue Prism may regain focus rather than the
training application. It is better to run your objects to breakpoints rather than stepping through with the
debugger.
To search for an image within an image, we need to use the Utility Business Object named Utility - Image Search.
This object when searching for images within images will allow a tolerance parameter to be submitted. The
Tolerance input parameter allows for colors within application screens to vary slightly. This adds robustness to the
interface because colors within applications can sometimes change across different Windows desktops.
Set the tolerance to 20. If you find during testing an interface that colors can vary by more than this then increase
the tolerance to 30 or 40.
If you haven’t already done so, import the object from the file C:\Program Files\Blue Prism Limited\Blue Prism
Automate\VBO\ BPA Object - Utility - Image Search.xml.
If the Image Search object is not distributed with your version of Blue Prism it can also be downloaded from the
Blue Prism Portal under resources - > VBOs
Open the object, access Application Modeler, and launch the application.
To demonstrate, we will complete the Login action in the Thin Client Application – Login object.
Application Modeler already contains an element named Login Screen. Use Identify Element to select the login
screen (remember to use the ALT key to switch to Region mode).
Using the Region Editor create regions for User Name, Password, and the Login Button.
Close Region Editor and use Highlight Element to verify the regions.
We need to match the Window Text attribute so let’s use a wildcard instead of a date (see below). You will need to
do this for all regions within the Login Screen.
To set the value of the fields, we must first select the region using the cursor (using Global Mouse Clicks) and then
send the relevant keystrokes to populate the field.
The steps that your flow will need to take to log in using Surface Automation will be:
Set the initial values for two data items in your Login action; one for User name and one for Password (you
can them to be anything so long as they have the same value).
Add a wait stage to wait for the log in window (it is best practice to have wait stages at the start and end of
all your actions).
Activate the log in window so that it has focus. Windows always needs to have focus if you are using any
Global interfaces such as Global Send Keys or Global Mouse Clicks.
Wait a tiny amount of time (for example, 0.1 seconds) to give the Activate time to work. Without waiting
for activate to work your action may not work when running at full speed in control room.
Click in the User Name edit box to give it focus.
Send the User Name by sending keystrokes.
Click in the Password edit box to give it focus.
Send the Password by sending keystrokes.
Click on the Log In button.
Wait for the log in window to have gone.
Exercise 3.1.1 Start Building the Login Action
Use the following instructions to build the Login action including all the above steps:
Add a Navigate stage named Activate to activate the Login Window. Specify the Login Screen element and Activate
Application as the Action (see below).
Add a wait stage, not waiting for any elements, but simply waiting for 0.5 seconds to give the Login Screen time to
become active.
Add a Navigate stage named Select User Name. Specify the User Name element and Global Mouse Click Center as
the Action (see below).
Add a Navigate stage named Set User Name. Specify the Thin Client Application as the element and Global Send
Keys as the action. Set the User Name as the Input parameter for the Global Send Keys action.
The process flow will focus the window, select the User Name field by clicking in the center of it before sending the
current value of the [User Name] data item.
What if there is already text in the edit box you want to send text to?
What if text is being sent to the application by Blue Prism too quickly, causing keys not to be sent
correctly?
What if there is a risk that you could be updating the incorrect account, or entering the incorrect values?
What if Send Keys does not work for your application?
In the following exercises, we will look at how you will solve these potential problems:
For the Login Screen of the training application, when we set the field values we know that the text box will be
blank as the application has just started. However, when using some text boxes, it is necessary to:
A full list of Special Keys can be found in Appendix – Sending Special Keys. You can send multiple special keys by
adding a number at the end of the braces e.g., {DEL 10} will send 20 delete keystrokes.
The example below shows how we send the HOME key followed by 20 Delete keystrokes followed by the User
Name.
Test this by populating the User Name field and then running the Login action.
Tip: You may have to change where you send your Global Click to within the Password edit box so that your
Delete keystrokes are sent to the correct place.
Sometimes Global Send Keys does not work in a reliable and consistent way due to the behavior of the application
or environment you are interfacing with.
Blue Prism users have previously experienced some applications where the Global keystrokes were received with
either missing characters or with characters in a different order to which Blue Prism sent them.
To add robustness to your Global Send Keys, Blue Prism Best Practice recommends adding a 0.1 second keystroke
between each character sent.
The Thin Client Application – Login object that you have been working on has a sub-page action named Send Keys
that has not yet been used. If you look at this sub-page you will see that it contains a loop that sends characters
with a 0.1 second delay between each character.
In its place, put a Page stage that calls the Send Keys action.
Amend your new Page stage to rename it “Set User Name”, and to set the Keys input parameter to be the User
Name data item.
Test your action. You may not notice any difference to the performance of your Login action, but it is now running
using a more robust and reliable method.
In your future “real-world” development it is recommended that you always use keystroke delays when using
Send Keys or Send Key Events.
The default delay of 0.1 seconds has been found to be reliable for the majority of applications, but it may be
increased if your testing finds Send Keys to not be sending keystrokes reliably.
Very rarely, the keystroke delay technique described above may be found to not guarantee that your Surface
Automation Send Key inputs work consistently and reliably. During testing you may find that some characters are
still not sent correctly, or are not inputted into the application in the correct order.
Where an issue still exists with Send Keys not sending keystrokes correctly, you will need to build in a read stage to
read back the text you entered to ensure it is correct.
It is only recommended that this method of validating all text entry is used if a reliability issue has been found
with Send Keys during your testing.
Tip: Think back to the Calculator exercises in the Introduction to Surface Automation
Training. We had to populate the region, identify the font and then use the Recognize Text
action.
Integrity Checks
When using Surface Automation, it is good practice to ensure that you are on the correct screen, in the correct
case or account, and that any high risk inputs, for example: financial transaction updates are entered correctly.
Even where testing has shown that validating text entry, as in the previous exercise, is not required, be mindful of
adding additional reads the risk is deemed high of being in the incorrect account or entering the incorrect value for
an update.
For some applications, including systems presented by Citrix servers, the Send Keys actions that you have used so
far might not work. For these applications, Send Key Events should be used instead.
Send Key Events is a similar interface, but has slightly different syntax when sending control keys. The syntax to use
for Send Key Events is described in 8. Appendix – Send Key Events.
For some elements, especially where large amounts of text needs to be entered, using the Windows Clipboard to
paste text can be a better and faster option than using Send Keys or Send Key events.
In the next exercise, we are going to replace the logic you implemented previously to enter the User Name using
Send Keys, to instead use Send Key Events to paste the User Name.
Add an action stage before to your Set User Name stage. Select the Utility – Environment Business Object
and the Set Clipboard action. Set the Clipboard input parameter to the action to be your User Name data
item.
Your action stage properties should look like the following image:
Add a small wait for 0.25 seconds after your new action stage.
Amend your Set User Name navigate stage. Change the action used in the navigate stage from Global Send
Keys to instead use the Global Send Key Events action.
Your new flow should look like the flow in the following image:
Not all application elements will have the clipboard enabled. If clipboard is disabled in an application then
font recognition is your only option.
Keystrokes are not your only option to use the clipboard. Sometimes menu or context menu options may be
available if the CTRL-C and CTRL-V keyboard shortcuts are not available.
Using the same technique we can read from multiline textboxes. The only difference is we set the Split Lines to
True.
The text in the region is returned to the text data item with carriage returns and line feeds
Exercise 3.4.1
Manually navigate the application so that a Note is open as shown above
Attach the Thin Client Application – Note object.
Complete the Get Note action to wait for a relevant screen element and then read the Note field. Don’t
forget to add your activate navigate stage to focus the View Note window.
Using Clipboard to Read Text
As well as being an option for sending text, using the clipboard to copy text is a good alternative option for reading
text from applications. Especially where character conflicts exist in a Font (see 5.2 Character Conflicts), using the
clipboard to copying text from fields may be the best option.
To use the clipboard to read text from an element, the following steps need to be taken:
Before interacting with application elements, first read an element label and confirm that its value is what we
expect.
If it is, we can assume that the element we want to interact with is in the correct position.
If we can’t read the label from its expected region, then we must search for an image of the label to return
the results of its location. Using these results, we can determine the position of the elements we want to
interact with.
You can either base the location of all your screen elements on their relative position to a single label or
image, or for more dynamic applications, you can base the location of all screen elements to the location of
their own related label.
Let’s determine the position of the User Name - Input element region we created using the User Name label.
Expand the rectangle in the property list to see the exact location of the label.
The screenshot below shows where the X and Y coordinates are taken from:
X Y
Label 124 211
Input Box 254 211
The horizontal (X) start position of the Input Box is 130 pixels to the right of the Label (254-124)
The X, Y, Width and Height attributes in Application Modeler refer to the container and not the region. The regions
attributes are Start X, End X, Start Y, and End Y.
The attribute properties of the User Name – Input include the following:
Remember your values may be slightly different depending on the size and location of your
regions.
The X, Y, Height, Width values of the region we captured in the Region Editor only affect the Start X, Start Y, End X,
End Y attributes in Application Modeler.
To allow our User Name– Input region to move around the screen relative to the position of the label we can make
the Start X and End X coordinates dynamic.
Create an image data item that contains an image of the User Name – Label.
Get the bounds of the container (screen).
Create a dynamic region to return the snapshot of the screen (Remember set the wild card on the Window
text property).
Use the Utility - Image Search to return the location of the label by searching for it within the screen.
Determine and use the correct coordinates in the dynamic attribute values of the navigate stage to set the
user name.
For applications that change often or elements with “floating windows” that cannot be identified as a
window element in Application Modeler, It is best practice to always use label images and dynamic regions to
accurately find field locations.
Some combo boxes allow you to simply type in the value you want. Treat these elements as text boxes.
Option 1 – Searching for the Value by Entering it into the Combo Box
Click the drop-down element of the combo box to expose the selectable values.
Return the list of visible values and their screen positions to Blue Prism
Select the required value if it is visible.
Scroll down the list until the required value appears or the same values appear twice (you’ve reached the
bottom of the list) or until you’ve exceeded a maximum number of retries.
Exercise 3.6.1 Titles
The Thin Client Application supports Options 3 and 4.
Selecting the best method if interfacing with a Combo Box requires experimentation with using the
application manually and experimenting within Object Studio.
Interface with a Combo Box using Option 1. If this isn’t possible, use Option 2, then Option 3, and finally
Option 4
Use field labels where possible to confirm the combo box is the one we wish to interface with.
After setting the value of the Combo Box, always read its value to confirm that it has been set correctly.
When reading the value of a check box, you will need to create a snapshot in Region Editor for each state (checked
and unchecked) for each option (i.e., Male and Female).
In the following example, we want to read the details of an account. This includes the Gender and Verified fields.
We will need to create four elements:
In each element we create a region and capture an element snapshot. This will allow us to determine the Gender
of an account holder and if the account has been verified.
When creating the region zoom in to make sure the region is tight against the element.
The following screenshot shows our Gender Male element and the Element Snapshot
The images we have captured are only valid when the account is locked as all the elements are grayed out. If you
wanted to read the values before saving the account details, you would need to repeat the exercise and capture
the elements when they are not grayed out.
Update the Get Account Details action to read the Gender and Verified fields when the application is
locked.
Update the Get Account Details action to read the Gender and Verified fields when the application is
unlocked.
Update the Add Account Details action to set the Gender and Verified fields. Remember to verify the fields
have been set correctly by reading the field values.
Consider the following screen from our Thin Client Application. We want to return all the data from the table so
that we can determine the correct account is and then select it.
We need to build an object that will accommodate the whole table. If there are too many records to fit in the
window a scroll bar will appear allowing you to scroll down to further records. This functionality will need to be
catered for in our business object.
The screenshot below shows how we have created regions for the columns; Account ID, Last Name, and First
Name.
Notice that we have zoomed into 200%. Defining regions can be a lot easier if you zoom in.
We will make the Start Y and End Y coordinates of each region dynamic in Application Modeler. This will allow us to
move the regions down the column in order to read each cell.
To move the regions down the table, we will need to increment the Start Y and End Y values by a specific number
of pixels. To determine how many pixels we need to move down, manually amend the Y value of the Account ID
region. As you change this value in Region Editor, the region will move down the screenshot; when it is in the
correct position make a note of the Y value before returning it to its original value.
The screenshot below shows the Account ID over the second cell in the column.
The starting position was 291. Hence we need to increase the Start Y and End Y values for the dynamic regions by
22 pixels (313 – 291).
Exercise 3.8.1
In the Thin Client Application - Find Account object, complete the Get Results action to read the results table to a
Blue Prism collection.
Exercise 4.1.2
In the “Thin Client Application – Account Details” object, complete the “Get Account Details” action (remember to
first confirm that you are on the correct screen).
Exercise 4.1.3
In the “Thin Client Application – Account Details” object, complete the “Navigate to Notes” action, the “Navigate to
Find” action, and the “Close” action.
Exercise 4.1.4
In the “Thin Client Application – Notes List” object, complete the “Get Notes” action. This will need to return in a
collection the note details of all notes that meet the input requirements (Date Range, Type).
When identifying system fonts, we have used the Automatic tab that allows Blue Prism to return the best matches.
From this you can select and test the returned fonts to determine the most appropriate.
If no fonts are returned, you can use the Manual tab to return samples from all available system fonts and
manually select one. Alternatively you can create a font (see 5.1.3 Creating a Font).
Qualifying Fonts
Irrespective of whether the font was found automatically or manually, an important part of the interface
configuration is to qualify the font. This means proving all the letters (upper and lower case), numbers and symbols
match correctly. This may not always be possible and workarounds may be required (5.2 Character Conflicts)
To qualify a font:
Read as much text from labels as you can to provide a wide selection of alphanumeric characters and
symbols.
Find an area of the application where you can enter text (e.g., note field or large input box) and read it
within Blue Prism to confirm values.
Creating a Font
Where a font can’t be identified or successfully qualified you can create a font. Consider the following screenshot.
We have navigated the process to the Note screen and entered a range of characters.
Blue Prism separates the distinct values and presents them to you so that you can set the characters. Above each
character is an input box for you to type the character and then click Merge Into Font
Fonts can also be edited in System Manager – System – Fonts as well as in Region Editor.
Font File
Once a font has been qualified, it can be exported to other Blue Prism Resources via a Blue Prism font file. You can
export a font to a font file in System Manager or as part of a Blue Prism Release. This allows your font to be
migrated to other Blue Prism Resources.
The Blue Prism font file can also be edited in a text editor if you need to further fine tune your font by setting space
widths.
For example if when recognizing text you notice that some words are concatenated this may be due to the space
width being too large. In the font file you will find the spacewidth property e.g.,
Adjusting the value here from 4 to 3 may solve the issue in this example. Once edited, you will need to save the file
and import it to Blue Prism via System Manager.
The rules you implement to interpret character conflicts such as this will depend on the context of your character
recognition.
In this instance, you could validate and clean the text using the following Regex rules implemented in a Blue Prism
Code stage:
Code
l at the start of an upper case word probably I
Unclean = Regex.Replace(Unclean, "(\b)l([A-Z]+)(\b)",
"$1I$2$3")
II in a word probably ll
Unclean = Regex.Replace(Unclean, "([a-z,A-Z])II", "$1ll")
A single l is probably an I
Unclean= Regex.Replace(Unclean, "(\b)l(\b)", "$1I$2")
There is no hard and fast logic that can be applied and you will need to thoroughly test any logic you implement.
5.3. Performance
Blue Prism Best Practice suggests that before interacting with an element you first confirm that it is the correct
element by using image recognition to reference nearby elements such as labels. Searching for images within
images as we have learned takes time. If we have 10 fields to complete on a form, searching for labels to confirm
the positioning of elements could increase the time taken to complete the form by as much 300%.
Given that it is unlikely that the form will have changed without Blue Prism being alerted by internal change
control, you may be wondering how such an overhead can be justified. This is the trade-off between quality and
performance and needs to be assessed on a process-by-process, screen-by-screen basis.
Given that you will inevitably have to search for images within the screen especially if you are having to scroll
around an application, there are methods you can use to speed up the search.
Suppose we wanted to find the top information icon on the following screen:
We can use the Find Image action in our Utility – Image Search object to find the following sub-image with the
entire screen as the search area:
The Get Sub-Image action searches from the top left to the bottom right of the screen making vertical sweeps
equal to the width of the sub-image. The search moves the sub-image one pixel at a time then compares each pixel
in the sub-image with relative pixels on the screen.
Knowing this, we can improve search performance using the following techniques:
With the way that Blue Prism searches, you can improve performance by minimizing the amount of background
color around the top and left of your search image. If we crop our image to create the following search image:
Instead of searching the entire screen, you can reduce you search area to where you expect to find the search
image before searching the entire screen.
We can increase performance to its maximum by searching (initially) for the smallest image within the smallest
search area.
In this case we would search for a blue pixel within a search area the height of the screen but one pixel wide.
Using the Utility – Image Search Find Image action, where the Image you are searching for is one blue
color pixel from the Information icon and the dynamic region image you want to search in is a single pixel
wide region of the screen.
or
By using one of the find pixel actions within the Utility – Image Manipulation object that is also
discributed with the Blue Prism product, although these objects do not have a tolerance parameter so are
not as robust.
We are effectivly searching down the red line in the image below and checking the color of each pixel until a blue
one is found.
Using a combination of these techniques will enable you to dramatically improve performance when searching for
images. It is always recommended to reduce your dynamic search area to the area of the screen you know where
your element is most likely to be found rather than searching for it in the entire screen.
• Title (text)
• Gender (text)
• Street (text)
• City (text)
• County (text)
• Postcode (text)
• Verified (flag)
Add Account Start Screen: Log In Screen Inputs:
• User Name (text)
End Screen: Log In Screen (Fail)
• Password (password)
The plus sign (+), caret (^), percent sign (%), tilde (~), and parentheses () have special meanings to SendKeys. To
specify one of these characters, enclose it within braces ({}). For example, to specify the plus sign, use "{+}". To
specify brace characters, use "{{}" and "{}}". Brackets ([ ]) have no special meaning to SendKeys, but you must
enclose them in braces.
To specify characters that aren't displayed when you press a key, such as ENTER or TAB, and keys that represent
actions rather than characters, use the codes in the following table:
Key Code
BACKSPACE {BACKSPACE}, {BS}, or {BKSP}
BREAK {BREAK}
CAPS LOCK {CAPSLOCK}
DEL or DELETE {DELETE} or {DEL}
DOWN ARROW {DOWN}
END {END}
ENTER {ENTER} or ~
ESC {ESC}
HELP {HELP}
HOME {HOME}
INS or INSERT {INSERT} or {INS}
LEFT ARROW {LEFT}
NUM LOCK {NUMLOCK}
PAGE DOWN {PGDN}
PAGE UP {PGUP}
PRINT SCREEN {PRTSC}
RIGHT ARROW {RIGHT}
SCROLL LOCK {SCROLLLOCK}
TAB {TAB}
UP ARROW {UP}
F1 {F1}
F2 {F2}
F3 {F3}
To specify keys combined with any combination of the SHIFT, CTRL, and ALT keys, precede the key code with one or
more of the following codes:
Key Code
SHIFT +
CTRL ^
ALT %
To specify that any combination of SHIFT, CTRL, and ALT should be held down while several other keys are pressed,
enclose the code for those keys in parentheses. For example, to specify to hold down SHIFT while E and C are
pressed, use "+(EC)". To specify to hold down SHIFT while E is pressed, followed by C without SHIFT, use "+EC".
To specify repeating keys, use the form {key number}. You must put a space between key and number. For
example, {LEFT 42} means press the LEFT ARROW key 42 times; {h 10} means press H 10 times.
If Send Keys does not work with your application, Send Key Events should be tried instead (see the next Appendix).
Send Key Events sends all normal characters, e.g., “a”, “9”, just by sending that key in a similar way to Send Keys. A
key down followed by a key up of that keyboard character is sent.
Special keys are enclosed in {braces}. This allows things such as {HOME} and {ALT} to be sent.
The < and > characters are used to modify the NEXT key to be just a key down or key up respectively.
Since "{", "}", "<" and ">" are special characters, to send these characters not as special characters they must be
enclosed in braces themselves, as follows: {{} {}, {<} and {>}
Examples:
"hello{RETURN}" - sends HELLO and presses return.
"<{CTRL}A>{CTRL}" - presses the CTRL key down, then presses A, then releases the CTRL key
"<{ALT}AB>{ALT}" - presses the ALT key down, then presses A, then B, then releases the ALT key - i.e., does ALT-A,
ALT-B
"<{ALT}A>{ALT}B" - presses the ALT key down, then presses A, then releases the ALT key and pressed B - i.e., does
ALT-A, B
"<{CTRL}<{SHIFT}{ESCAPE}>{SHIFT}>{CTRL}" - presses CTRL and Shift, then Esc, then lets go of CTRL and Shift"
Care should always be taken with the syntax of Send Key Events. A down keystroke for special keys must always be
followed by an up keystroke.
Description
A The A key.
B The B key.
C The C key.
D The D key.
D0 The 0 key.
D1 The 1 key.
D2 The 2 key.
D3 The 3 key.
D4 The 4 key.
D5 The 5 key.
D6 The 6 key.
D7 The 7 key.
D8 The 8 key.
D9 The 9 key.
F The F key.
F1 The F1 key.
F2 The F2 key.
F3 The F3 key.
F4 The F4 key.
F5 The F5 key.
F6 The F6 key.
F7 The F7 key.
F9 The F9 key.
G The G key.
H The H key.
HanguelMode The IME Hanguel mode key. (maintained for compatibility; use HangulMode)
I The I key.
J The J key.
K The K key.
L The L key.
M The M key.
N The N key.
O The O key.
OemBackslash The OEM angle bracket or backslash key on the RT 102 key keyboard (Windows 2000 or
later).
OemCloseBrackets The OEM close bracket key on a US standard keyboard (Windows 2000 or later).
Oemcomma The OEM comma key on any country/region keyboard (Windows 2000 or later).
OemMinus The OEM minus key on any country/region keyboard (Windows 2000 or later).
OemOpenBrackets The OEM open bracket key on a US standard keyboard (Windows 2000 or later).
OemPeriod The OEM period key on any country/region keyboard (Windows 2000 or later).
OemPipe The OEM pipe key on a US standard keyboard (Windows 2000 or later).
Oemplus The OEM plus key on any country/region keyboard (Windows 2000 or later).
OemQuestion The OEM question mark key on a US standard keyboard (Windows 2000 or later).
OemQuotes The OEM singled/double quote key on a US standard keyboard (Windows 2000 or later).
OemSemicolon The OEM Semicolon key on a US standard keyboard (Windows 2000 or later).
Oemtilde The OEM tilde key on a US standard keyboard (Windows 2000 or later).
P The P key.
Packet Used to pass Unicode characters as if they were keystrokes. The Packet key value is the low
word of a 32-bit virtual-key value used for non-keyboard input methods.
Q The Q key.
R The R key.
S The S key.
T The T key.
U The U key.
V The V key.
W The W key.
X The X key.
Y The Y key.
Z The Z key.