selectpdf c# example : Add url pdf Library SDK component wpf web page mvc WATUsageGuide6-part892

Kapow Compute Units (KCUs)
Add url pdf - insert, remove PDF links in, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
add email link to pdf; add links to pdf
Add url pdf - VB.NET PDF url edit library: insert, remove PDF links in, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
adding links to pdf; add hyperlinks to pdf online
License Keys
Before you can begin using your Kapow Katalyst installation, you must enter your license key(s) into
Management Console as described in Management Console (License Server). You will have received these
keys from Kapow.
There are three different kinds of license key:
Production key
Permits production use of the Kapow Katalyst system.
Non-Production key
Permits use of the Kapow Katalyst system for non-production use like test
and staging.
Developer Seat key
A special kind of non-production key that will allow you to run all the Kapow
Katalyst programs on your own computer as part of the same installation.
There are, however, some performance limitations, as this it intended to be
used only for development or as a trial installation.
A license key (no matter which kind) also describes which Kapow Katalyst features you have, and how
many KCUs you have bought. A Developer Seat key always contains 1 KCU, while the two other kinds
may contain more.
If you have both a Production key and a Non-Production key, you may install them into the same Kapow
Katalyst system (that is, in the same Management Console). You may also choose to set up one system for
each key. In both cases, you will need to set up at least two different clusters (either on the single system
or one cluster on each of the two systems), configured as Production and Non-Production, respectively.
The KCUs in your licenses can then be assigned to these clusters.
In no case should a key be entered into more than one Management Console.
C#: How to Open a File from a URL (HTTP, FTP) in HTML5 Viewer
License and Price. File Formats. PDF. Word. Excel. PowerPoint. Tiff. DNN (Dotnetnuke). Quick to Start. Add a Viewer Control on Open a File from a URL (HTTP, FTP).
pdf hyperlinks; add url to pdf
C#: How to Add HTML5 Document Viewer Control to Your Web Page
addTab(_tabRedact); //add Tab "Sample new UserCommand("pdf"); _userCmdDemoPdf.addCSS( new customStyle({ background: "url('RasterEdge_Resource_Files/images
pdf link to email; clickable links in pdf from word
Design Studio User's Guide
Design Studio is the application for creating robots and types. In Design Studio, you can also debug your
robots and create database tables for types that need to be stored in databases.
Design Studio is an integrated development environment (IDE) for robot development. This means that
Design Studio is all you need for designing robots and types.
Robots are programmed in an easy-to-understand visual programming language with its own syntax
(structure) and semantics (meaning). To support you in the construction of robots, Design Studio provides
you with  powerful programming features  including interactive visual programming,  full  debugging
capabilities, an overview of the program state, and easy access to context-sensitive on-line help.
Design Studio also lets you create the types that are used by robot variables for data extraction and input.
With Design Studio's Type Editor, you are able to design types that are modeled after real-world data. In
the most common case, a type is designed to hold the data that a robot extracts from a data source.
The Guide is structured as follows: First, you are introduced to the essential concepts of Design Studio.
Then you are taken on a tour of the user interface and provided with an overview of the core building
blocks of any robot. With the basics firmly in place, we get to the tutorials that show you how to use Design
Studio to create robots that do something useful. The tutorials get gradually more advanced until, finally,
you are ready to create robots that perform the tasks that you decide. The tutorials are the meat and bone
of this User's Guide and it is important that you master them before proceeding.
The rest of the Guide is divided into various topics ("How To..."). You should skim through them to get
an idea of what they cover. Then you can return later when you need more information or help on one
of the topics.
Before You Read On
Before you proceed, it is recommended that you read the Getting Started section, which will introduce
you to Design Studio and the context it is used in, help you get Kapow Katalyst installed, and take you
through a couple of basic tutorials.
Also, before proceeding, make sure that you fulfill the following reader requirements:
• A basic understanding of what programming is.
• A basic understanding of HTML.
• A basic understanding of JavaScript.
Other Resources
Additional information on Design Studio is available in the reference documentation [../ref/robomaker/
RoboMaker.html], which is easily accessible from the Help menu in Design Studio.
Design Studio Concepts
Design Studio  is  a programming environment for creating  robots and designing  types. Robots  are
created using a special-purpose programming language with its own syntax and semantics. Like other
C# PDF Library SDK to view, edit, convert, process PDF file for C#
editing PDF document hyperlink (url) and quick navigation link in PDF bookmark. C#.NET: Edit PDF Metadata. PDF SDK for .NET allows you to read, add, edit, update
add hyperlink to pdf in preview; add a link to a pdf in preview
C# Image: How to Download Image from URL in C# Project with .NET
Add this imaging library to your C#.NET project jpeg / jpg, or bmp image from a URL to your provide powerful & profession imaging controls, PDF document, tiff
change link in pdf file; pdf links
Design Studio User's Guide
programming environments, Design Studio uses several concepts that you, as a robot designer, must
understand in order to fully comprehend the workings of Design Studio. The purpose of this section to
introduce the most important concepts and it is recommended that you refer back to this section whenever
you encounter a concept you do not understand. Please be aware that you may not understand all the Design
Studio concepts described below right away; they will become clearer as you explore Design Studio and
start creating robots.
The most important concept in Design Studio is a robot. A robot is a program designed to accomplish
some task involving a data source, usually a web site, but it could also be an Excel document or a database.
Typically, one robot is written per task per data source. For example, you would create one robot for
extracting news from, another robot for extracting news from and yet
another robot for extracting product information from an online product catalog.
Basically, a robot can be programmed to do (automatically) everything you can do in a browser, as well as
extract data from a database or an Excel document and combine this with storing data in a database, file, etc.
The Robot State
When a robot is executed, it works on a robot state. The robot state consists mainly of four elements:
• windows
• variables
• cookies
• authentications
The windows element is the currently open windows, each containing a page. This page could be an HTML
page, a spreadsheet, an XML page etc. and we say that the page has a given Page Type depending on
what type of page is loaded into the window and the look of the Page View and the steps you can insert
in your robot will depend on this type. At least one window is always open, and one window is marked
as the current window. The variables element contains the current values of the variables. The cookies
and authentications elements are the HTTP cookies and authentications, respectively, received during
communication with a web server.
A robot is made up of steps. A step is a building block in a robot program. There are four types of steps:
Action steps, Try steps, Group steps and End steps.
A Step
A step works on a robot state and processes it according to the configuration of the step. A step thus has
an input robot state and generates an output robot state. The only exception to this is the End step. End
steps mark the end of a branch in a robot and not as such the end of a robot, i.e. the the robot does not
necessarily stop execution after an end step. End steps are the only steps in a robot that does not have
outgoing connections.
C# PDF insert image Library: insert images into PDF in, ASP
C#.NET PDF SDK - Add Image to PDF Page in C#.NET. How to Insert & Add Image, Picture or Logo on PDF Page Using C#.NET. Add Image to PDF Page Using C#.NET.
add url to pdf; convert excel to pdf with hyperlinks
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Insert Image to PDF. Image: Remove Image from PDF Page. Cut Image in Page. Link: Edit URL. Bookmark: Edit Images. Redact Pages. Annotation & Drawing. Add Sticky Note
add links to pdf document; adding links to pdf document
Design Studio User's Guide
An End Step
Steps may have properties, such as a step name, a list of tag finders, a step action and an error handling.
While Action steps have all these properties, other types of steps only have some of these.
The step name provides a symbolic name for the step, such as "Extract Headline" and "Load Search Page".
In the above robot, the step name is "MyStep".
The finders find the elements (e.g. HTML tags or Excel cells) in the page that the step action (see below)
should work on. Some step actions require a single element, whereas others can handle more than one
element. Some step actions accept no elements at all. There are two kinds of finders: Tag Finders that
finds tag in HTML or XML pages and Range Finders that finds cells in Excel pages.
The step action is the action that the step performs. The action is the "heart and brain" of the step, and it is
the selection of the right step action that is the challenge of robot writing. For example, an Extract action
might extract the text from a tag in an HTML page and store it in a variable. And a Click action might load
the URL residing in an <a>-tag and replace the page of the current window in the robot state with the newly
loaded HTML page. An action usually changes the robot state. For example, the Extract action changes
the variables, and the Click action may change the pages/windows, the cookies and the authentications.
A step can be executed. A step that is executed accepts a robot state as input and, by applying the finders
and step action in turn, produces an output robot state. The output robot state is then passed on to the
following step and becomes its input robot state. Some step actions are termed loop actions (and steps
having such actions are called loop steps). A loop step may generate zero or more output robot states, and
causes the following steps to be executed once for each of them.
Steps can be grouped together in Group Steps. Group steps can be expanded or collapsed. The figure below
shows an example of an expanded Group step with a collapsed Group step inside it. The icons  and  in the
top left corner of Group steps is used to expand or collapse these.
Group Steps
A step is valid if it has been properly configured so that execution can be attempted. For example, if a step
has no action, it is invalid since execution cannot be attempted.
A step definition also specifies error handling for the step, but this is more complex and is described
separately in a following subsection.
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
to PDF. Image: Remove Image from PDF Page. Image Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Redact Pages. Annotation & Drawing. Add Sticky Note
pdf link to email; add links to pdf in preview
VB.NET Image: VB Code to Download and Save Image from Web URL
Apart from image downloading from web URL, RasterEdge .NET Imaging SDK still dedicated to provide powerful & profession imaging controls, PDF document, image
add links in pdf; add hyperlinks to pdf
Design Studio User's Guide
Connections and Execution Flow
Steps can be connected to other steps via connections that affect how execution flows between steps.
Consider the simple robot below:
This robot consists of three steps named "step A", "step B", and "step C". Assuming that no errors occur,
and that each step generates exactly one output robot state, the robot is executed as follows: An initial robot
state will be generated and used as input to step A (being the first step). Step A will produce an output
robot state. This output robot state will be the input robot state of step B. Similarly, step B will produce a
robot state and this will be the input robot state of step C. Once step C has executed and produced an output
robot state, execution completes. In short, the execution of steps can be described as follows: "A, B, C".
Sometimes, a step generates no output robot state when executed. This happens when an error or a test step
causes execution to continue somewhere else in the robot, and it is described in the section on Conditions
and Error Handling.
Steps containing a loop action may process the input state several times, each time outputting a distinct
robot state. Consider the robot below where step B contains a loop action:
Assuming that there are no errors or test steps, that step B outputs three robot states, and that all other steps
output exactly one robot state, then the steps will be executed in the following order: "A, B[1], C, D, B[2],
C, D, B[3], C, D", where B[N] refers to the Nth iteration of the loop action contained in step B. Note that
the output robot states by step B will be different robot states — that is, each iteration will output a new
robot state. Hence, step C will receive a new input robot state each time it is executed.
Videos are not included in the PDF. Please visit open this url in
a browser to see the video.
Video Tutorial on Branches, Robot States and Execution Paths
A step can connect to more than one step. This is called branching. Consider the robot below:
In this robot, step A is followed by a branch point, where the connection splits out in two branches.
One branch consists of step B and step C, and another consists of step D and step E. All of the branches
coming out of a branch point are executed, one after another. Therefore, assuming that no errors or test
steps change the control flow and that each step generates exactly one output robot state, then the robot
above will be executed as follows: A, B, C, D, E. However, it is important to note that step B and step D
will each receive a copy of the same output robot state produced by step A.
Design Studio User's Guide
Branches can merge, and in complicated ways. Consider the following robot:
This robot illustrates how connections can be explicitly ordered. In this robot the branches of step D are
executed in the order specified by the numbers, that is, step E is executed before step C. If an order is not
specified (by numbers), connections are executed top-down. Thus, assuming that there are no test steps,
that no errors occur, and that each step generates exactly one output robot state, the robot is executed as
follows: A, B, C, D, E, C. The first time step C is executed it will receive the output robot state produced
by step B; the second time step C is executed it will receive the output robot state produced by step D.
Sometimes you want to select (i.e. execute) only one of several branches, depending on circumstances.
The following section shows how to do this.
Conditions and Error Handling
A robot may have to use different approaches in different cases. The cases may be distinguished either
based on explicit tests, that is, by evaluation of conditions, or because errors occur and need to be handled.
Conditions change the flow of execution based on the content of the input robot state (e.g. the presence of
a particular tag in an HTML page). Error handling is about changing the flow of execution when particular
errors occur (e.g. some anchor tag is not found on the HTML page as expected and thus cannot be clicked).
Often, however, a situation can be seen both ways: An anchor tag should be clicked if found (this is a
condition), or the robot can just try and click it and handle the error (if it is not found). In some cases, what
is commonly thought of as a condition is too complex to be written up as such, for example a condition
saying "if this particular page can be loaded without error". In such a case, there is nothing to do but try
and load the page and treat any error merely as an indication that the condition failed.
Other errors are signs of genuine problems with the robot or the web site being accessed. For example,
the web site may be down and cause a page loading error, or a tag finder might fail to find a needed tag
due to a dramatic page layout change of an HTML page. To sum up, a particular error may be considered
a failed condition in some circumstances, and a genuine error in other circumstances. The interpretation
depends on the robot.
Because of this blurred boundary between conditional execution and error handling, Design Studio
provides both features in a unified way. For every step, it is configurable what to do in case an error
occurs. Furthermore, steps with a test action (based on a condition of some sort) reuse the same approach,
meaning that if the condition is not met, the (default) action is to do as if an error occurred.
For each step in the robot, you can configure the desired reaction to errors. We will describe two of the
most useful error handling options here; see How to Handle Errors for information on the other options.
The first to be described is closely linked to the Try step.
The Try step is similar to a branch point because it may have several branches going out from it. It differs
from a branch point because branches beyond the first one are executed only if a step on the preceding
branch encounters an error which it then handles by means of the option "Try Next Alternative". Consider
the robot below and assume that each ordinary step is expected to output exactly one robot state:
Design Studio User's Guide
The  icon indicates that step B is configured to handle errors by "Trying Next Alternative".
If step B executes successfully, step execution is as follows: "A, T, B, C". Because the first branch going
out from T executes without error, the second branch is not executed at all.
If, on the other hand, step B encounters an error, then the execution of steps is as follows: "A, T, B, T, D,
E". After the error in step B is handled, execution will not continue at the following step, but instead at
the beginning of the next branch going out from the Try step.
Each branch going out from a Try step represents one possible way to proceed from that point. Steps near
the beginning of each branch probe if execution along the branch is a viable approach (and otherwise effect
a "Try Next Alternative"), while later steps do the actual work when the branch turns out to be the right
one for the case at hand. The probing steps near the beginning of a branch may be either test steps, or just
any kind of steps that — if they encounter an error — indicate that this branch is not the way to proceed.
There may be any number of such branches going out from a Try step.
Readers familiar with ordinary programming languages like Java, JavaScript, C# or similar will note how
the above robot is similar to an "if-then-else" construct: The first branch after the Try step contains the
condition (the "if" part) and the "then" part, while the last branch contains the "else" part. Should there be
more than two branches, then the ones between the first and the last ones are like "else-if" parts.
If the first branch attempts to do some action that may error, the example can also be likened to a "try-catch"
construct: The first branch is the "try" part, while the second branch is like the "catch" part.
Another error handling option, "Skip Following Steps" provides a more compact way of expressing a
common special case, which is exemplified by the following robot. The step that can encounter an error
is the first one on the first branch, and the second branch does nothing:
The effect of this is to simply skip execution of the steps after step B if it encounters an error. The same
effect can be achieved without the Try step by using the error handling option "Skip Following Steps"
(which is the default), in the following way:
Location and Location Code
When an error is handled, it is possible to report it back to the caller of the robot, or to have it logged.
In both cases, a message is included that briefly describes the error, together with a location and location
code for the step that encountered the error.
Design Studio User's Guide
The location of the step that encountered the error is the list of steps (including iteration numbers) one
needs to execute in order to reach that step from the first step. Consider the robot below:
If step C reports an error on the second iteration of step B, then the location is written as: "step A - step
B[2] - step C". Note that the location contains the step names and iteration numbers, separated by hyphens.
Branch points are omitted.
The location code is similar to the location, but the name of each step is replaced by a unique identifier
for that step, thereby avoiding name clashes. For the location example above, the location code may be:
"{a-i1-a}". You can use the location code in Design Studio to go directly to the step that reported the error
(using "Go To Location" in the "Edit" menu).
You should be aware that the iteration number in the location and location code is 0 indexed, so the first
iteration will be "{a-i0-a}
A snippet is a group of steps that can be reused in several robots. A snippet is maintained in a file separate
from the robot. Whenever the contents of a snippet is changed in one robot, it is automatically updated
in other robots that uses the same snippet. A snippet is inserted into a robot using the Snippet step, and
edited in-line. Snippets contents cannot be edited without being inserted into a robot. Watch the video
below or read on to learn more.
Videos are not included in the PDF. Please visit open this url in
a browser to see the video.
A video introduction to the concept of snippets.
The Snippet step inside a robot is in many ways similar to a Group step. However, whereas the steps inside
a Group step are part of the robot, the steps inside a Snippet step are maintained in a separate file and can
be reused in other robots inside the same project. A robot is incomplete and cannot execute if a snippet
that it references is not present in the project.
A groupable selection of steps can easily be converted into a reusable snippet 'Create snippet from selection'
icon after selecting the steps to convert. If only a single group step is selected the 'Convert snippet to
icon will turn that group into a reusable snippet. A snippet can be easily embedded into a robot
by clicking the 'Convert snippet to group' 
icon after selecting a Snippet step.
A snippet can also define a set of variables, that will be included in the set of variables of any robot that
uses the snippet.
A snippet can have a description. This is edited in the Snippet Editor and is shown on every occurrence
of that snippet in robots.
Variables and Types
Two important concepts in Design Studio are those of variables and types. When creating a variable, it
must be chosen which type it should have. There are two kinds of types: complex types and simple types.
complex type defines a set of  attributes. This expresses that each variable of a complex type denotes
Design Studio User's Guide
several (named) values. Note that we generally refer to each attribute, e.g. 'title', of a variable of complex
type, e.g. 'Book', as a separate variable and denote its value using the fully qualified attribute name, i.e.
'Book.title'. Complex types can be created from within Design Studio to fit any need one might have. A
simple type does not define any attributes, but only represents the type of a single value. Thus, a variable
of a simple type contains a single value, for example a text string, and is referred to only by its variable
name, e.g. 'Username'. Simple types are built-in and cannot be edited, nor can they be created.
Every variable can be associated with a default initial value that it retains unless the robot explicitly
reassigns it, which it often will as values are extracted and manipulated during the execution. Most robots
output the values of variables, e.g. by returning them to the caller or inserting them in a database. Robots
might also take input values which are then assigned to specific variables that have been marked as
receiving their values from input. These are simply called input variables.
An important difference between variables of complex and simple types is that variables of simple types
cannot be used as input variables, and their values cannot be outputted. However, they are useful, for
instance, for extracting temporary data or as global counters. Generally, variables of simple types should
be viewed as temporary variables, internal to the robot.
Values from variables of complex types can be outputted in various ways. For example, a robot extracting
news from some web site might output the values of news variables; each news variable would then have
a complex type with attributes such as 'headline', 'bodyText', 'date', 'author', etc., and each outputted news
value then comprises a (possibly) unique (sub-)value for each of the named attributes.
For robots containing input variables, it must be specified as part of the input to the robot to which input
variable a given input value has to be assigned. For example, a shopping robot that orders books at http:// might depend on input values containing user and book information. These might be assigned
to two input variables in the robot called "user" and "bookInfo" of type "User" and "BookInfo". The below
figure shows how a robot accepts input values and generates output values.
The figure shows robot input-output. Input values are assigned to input variables, and the values of some
variables are outputted. Only variables of complex types can be assigned from input or have their values
Libraries and Projects
Robots and types are organized in libraries. A library is a collection of robot definitions, type definitions
and other files needed to execute the contained robots. A library serves as the deployment unit for robots.
This means that a library is how you bundle robots and their required files when you want to distribute
and deploy the robots in a runtime environment, such as RoboServer.
When you are working in Design Studio you are working on at least one robot project, but you may have
many robot projects open in Design Studio at any time. The purpose of a robot project is to develop a
robot library. A robot project contains the robot library that you are developing a given set of robots in,
as well as other files that are useful for your work on the robot library. Files placed in the library may
Documents you may be interested
Documents you may be interested