using pdfdocument c# : Add a link to a pdf file application SDK cloud windows wpf azure class WATUsageGuide37-part880

Clipping Programmer's Guide
369
empty username and empty password), as default credentials cannot be specified in the clip configuration
file together with a class name specifying a User Credentials provider.
The provider returns an object of type UserCredentials. Such an object is created by calling the
constructor with username and password (see the example below).
Example
A trivial example of a User Credentials provider is given below. Here the username “demo” and password
“demo” is passed to the RoboServer — in practice you would retrieve the username and password from
some external source such as a credentials vault or the session.
Table 119. Code Example of a User Credentials Provider
package com.mycompany.myproject;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.kapowtech.robosuite.client.clip.version1.api.
UserCredentials;
import com.kapowtech.robosuite.client.clip.version1.api.
UserCredentialsProvider;
public class MyUserCredentialsProvider
implements UserCredentialsProvider {
public UserCredentials provide(HttpServletRequest request,
HttpServletResponse response,
UserCredentials defaultCredentials)
{
// place your code to fetch username and password here:
final String username = "demo";
final String password = "demo";
return new UserCredentials(username, password);
}
}
User Message Localization Provider
Kapow clipping technology pipes HTML from the clipped page to the consumer (portal or web server).
This means that correct localization and internationalization of the actual content is the responsibility of
the clipped pages, and that your main task is to ensure that the correct user settings are transferred to the
clipped page.
However, a few user messages exist which originate solely from Kapow. Hence, to make your portal truly
international, these user messages need to be localized.
Purpose and Use
The user message localization is useful in multi-language environments, where the messages should
depend on the user or the browser's locale. If you just need to use clipping in a non-English speaking
environment, it is easier to specify the localized texts in Design Studio.
Add a link to a pdf file - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
accessible links in pdf; adding a link to a pdf in preview
Add a link to a pdf file - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
add link to pdf acrobat; clickable pdf links
Clipping Programmer's Guide
370
A User Message Localization provider should provide a localized version of the static Kapow user
messages, which will then be shown in the end-user's browser. Currently two such messages exist: the wait
page text, and the message shown when a popup is blocked (i.e. the same messages that can be modified
in the robot configuration window in Design Studio).
Dynamic user message localization can be specified in two ways. The first way of specifying user message
localization is to use resource bundles. If several languages are involved and localization should be
dependent on the computer's configuration (i.e. dependent on system and browser settings in the standard
Java way), using this fundamental standard Java localization functionality will often be preferred. This is
done by specifying a resource bundle in the deployment descriptor. The second and most general way is
to specify a User Message Localization provider. You specify in the clip configuration file which provider
to use. This can be useful if the localization is dependent on other things (e.g. if localization is user
configurable to ensure that the same language is used no matter where the user logs in).
Clip Configuration File Specification
As we have seen, localization can be specified in three different ways. First, you can specify static localized
texts directly in the clip configuration file. The following example shows how to localize the messages to
a purely Danish system — if you specify the texts in Design Studio (the User’s Browser tab in the Robot
Configuration dialog) the values will be written to the clip configuration file this way.
Table 120. Clip Configuration File with Static Messages
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE clip PUBLIC
"-//Kapow Technologies//DTD Clip Deployment Descriptor 1.3//EN"
"http://www.kapowtech.com/robosuite/rql/dtd/clip-deployment-descriptor_1_3.dtd">
<clip>
<robot-url>library:/my.robot</robot-url>
<robot-library><default/></robot-library>
<robot-server>
<socket-object-protocol host="localhost" port="50000"/>
</robot-server>
<additional-input-objects>
<class-name>com.mycompany.MyInputProvide</class-name>
</additional-input-objects>
<wait-page-text>
<!--Please wait in Danish -->
Vent venligst!
</wait-page-text>
<popups-blocked-text>
<!--Popus blocked in Danish -->
Denne applikation kræver popups.
Slå popup blockere fra og tryk Refresh i din browser.
</popups-blocked-text>
</clip>
The second way is to provide Resource Bundles; this is the standard way of specifying localization in Java,
so we will not go into details here. The localization will be according to the system locale setup (operating
system and browser).
The  clip  configuration  file  given  below  specifies  a  resource  bundle.  In  the
example,  com.mycompany.myproject.MyResourceBundle  is  a  class  extending
java.util.ResourceBundle.
C# PDF Library SDK to view, edit, convert, process PDF file for C#
and quick navigation link in PDF bookmark. C#.NET: Edit PDF Metadata. PDF SDK for .NET allows you to read, add, edit, update, and delete PDF file metadata, like
add links in pdf; add hyperlink pdf file
VB.NET PDF Password Library: add, remove, edit PDF file password
This VB.NET example shows how to add PDF file password with access permission setting. passwordSetting.IsAssemble = True ' Add password to PDF file.
pdf link; add hyperlink to pdf online
Clipping Programmer's Guide
371
Table 121. Clip Configuration File with a Resource Bundle
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE clip PUBLIC
"-//Kapow Technologies//DTD Clip Deployment Descriptor 1.3//EN"
"http://www.kapowtech.com/robosuite/rql/dtd/clip-deployment-descriptor_1_3.dtd">
<clip>
<robot-url>library:/my.robot</robot-url>
<robot-library><default/></robot-library>
<robot-server>
<socket-object-protocol host="localhost" port="50000"/>
</robot-server>
<additional-input-objects>
<class-name>com.mycompany.MyInputProvide</class-name>
</additional-input-objects>
<user-messages>
<resource-bundle>
com.mycompany.myproject.MyResourceBundle
</resource-bundle>
</user-messages>
</clip>
The resource bundle should specify a translation of the texts named
• UserMessageLocalizationProvider.WAIT_PAGE_TEXT_KEY
• UserMessageLocalizationProvider.POPUPS_BLOCKED_KEY
An example of a root resource bundle is given below. Specific locales are specified in the same way.
Table 122. Resource Bundle Root
import java.util.*;
import com.kapowtech.robosuite.client.clip.version1.api.
UserMessageLocalizationProvider;
public class MyResourceBundle extends ListResourceBundle {
private static final Object[][] localization =
new Object[][] {
{UserMessageLocalizationProvider.WAIT_PAGE_TEXT_KEY,
"Please wait."},
{UserMessageLocalizationProvider.POPUPS_BLOCKED_KEY,
"Popups blocked. Please unblock."}
};
protected Object[][] getContents() {
return localization;
}
}
The name of the resource bundle can be specified in Design Studio and will then be written to the clip
configuration file. Note that the user-messages tag can be used together with the wait-page-text
and/or popups-blocked-text tags, which then provide default values.
C# PDF Password Library: add, remove, edit PDF file password in C#
This example shows how to add PDF file password with access permission setting. passwordSetting.IsAssemble = true; // Add password to PDF file.
check links in pdf; add hyperlink to pdf in preview
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Insert Image to PDF. Image: Remove Image from PDF Page. Copy, Paste, Cut Image in Page. Link: Edit URL. Images. Redact Pages. Annotation & Drawing. Add Sticky Note
clickable links in pdf files; add links to pdf in preview
Clipping Programmer's Guide
372
The third way of specifying the localization is to provide a class which performs the localization. The class
name is specified in the standard fashion as illustrated below.
Table 123. Clip Configuration File with a User Message Localization Provider
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE clip PUBLIC
"-//Kapow Technologies//DTD Clip Deployment Descriptor 1.3//EN"
"http://www.kapowtech.com/robosuite/rql/dtd/clip-deployment-descriptor_1_3.dtd">
<clip>
<robot-url>library:/my.robot</robot-url>
<robot-library><default/></robot-library>
<robot-server>
<socket-object-protocol host="localhost" port="50000"/>
</robot-server>
<additional-input-objects>
<class-name>com.mycompany.MyInputProvide</class-name>
</additional-input-objects>
<user-messages>
<class-name>
com.mycompany.myproject.MyMessageLocalizationProvider
</class-name>
</user-messages>
</clip>
As described, the order of the elements in the clip descriptor must follow the order defined in the DTD
(References). The following diagram shows the location of the user-messages element in the order
of these (not all elements may be present):
robot-url,  robot-library,  robot-server,  robot-server-credentials,
portlet, popups-required,  popups-blocked-text, action-header-filter,
portal-cookie-filter, user-credentials, properties, additional-input-
objects,  additional-output-objects, user-messages,  restart-session-
controller, error-handler, wait-page-text, wait-page-style
Implementation
We will not describe how to implement resource bundles here — instead you should consult Sun's
document on localization.
A user message provider must implement the interface
com.kapowtech.robosuite.client.clip.version1.api.
UserMessageLocalizationProvider
This interface has one method:
void modifyMessageMap(HttpServletRequest request,
HttpServletResponse response,
Map messageMap);
This  provider  follows  the  well  known  pattern  from  previous  sections  on  providers  by  taking  an
HttpServletRequest and HttpServletResponse as parameters.
C# PDF insert image Library: insert images into PDF in C#.net, ASP
using RasterEdge.Imaging.Basic; using RasterEdge.XDoc.PDF; Have a try with this sample C#.NET code to add an image to the first page of PDF file.
adding links to pdf document; pdf hyperlinks
VB.NET PDF insert image library: insert images into PDF in vb.net
using RasterEdge.XDoc.PDF; Have a try with this sample VB.NET code to add an image to the first page of PDF file. ' Open a document.
add a link to a pdf file; add links pdf document
Clipping Programmer's Guide
373
The last parameter is a map mapping user message keys (strings) to localized messages. This provider
works by modifying this map. The keys in the map are the same as we saw with resource bundles:
• UserMessageLocalizationProvider.WAIT_PAGE_TEXT_KEY
• UserMessageLocalizationProvider.POPUPS_BLOCKED_KEY
Example
A simple example of a User Message Localization provider is given below.
Table 124. An Example of a User Message Localization Provider
package com.mycompany.myproject;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.kapowtech.robosuite.client.clip.version1.api.
UserMessageLocalizationProvider;
public class MyUserMessageLocalizationProvider
implements UserMessageLocalizationProvider {
public void modifyMessageMap(HttpServletRequest request,
HttpServletResponse response,
Map messageMap) {
Enumeration locales = request.getLocales();
if (locales.hasMoreElements()) {
final Locale locale = (Locale) locales.nextElement();
if (locale.equals(Locale.FRENCH))
messageMap.put(WAIT_PAGE_TEXT_KEY,
"Attendéz si'l vous plait");
}
}
}
In this example the wait text will be in French if the locale is French and the default wait text (as given
in the robot configuration) will be used otherwise.
Distribution Policy Provider
A Distribution Policy provider makes it possible to write your own policy for contacting RoboServers in
an environment with multiple RoboServers.
Purpose and Use
A Distribution Policy determines how clipping sessions should be distributed to the available RoboServers.
This is, in effect, a coarse-grained client-side load balancing policy. The Distribution Policy for a particular
clip is used for all instances of the clip portlet. The policy is normally not shared among different clips
in a portal.
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# of PDF document, including editing PDF url links and quick navigation link in bookmark
add url pdf; add link to pdf
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
Add necessary references: using RasterEdge.XDoc.PDF; Note: When you get the error "Could not load file or assembly 'RasterEdge.Imaging.Basic' or any other
add links to pdf in acrobat; add a link to a pdf
Clipping Programmer's Guide
374
The  DistributionPolicyProvider  interface  allows  you  to  specify  which
DistributionPolicy instance should be used for the clip.
Two different distribution policies are provided by Kapow and can be used without having to use the API:
Round Robin and Random. In both cases, you specify a list of RoboServers in the clip configuration file.
For each session, the servlet will then choose a RoboServer from the list according to the policy specified.
In addition, it will make sure that the RoboServer is available, and otherwise choose another one.
The Round Robin Distribution Policy will choose RoboServers successively from the list of servers, i.e.
when one instance of the portlet has contacted some RoboServer, the next portlet instance will contact the
next in the list etc. When the last RoboServer in the list has been contacted, the next instance will contact
the first in the list.
The Random Distribution Policy will contact a random RoboServer each time a session starts. You should
consult standard text books on the subject for an introduction to scheduling algorithms and their pros and
cons.
In many cases, choosing one of these will be sufficient (Round Robin is the default if you do not modify
the clip configuration file).
Defining your own Distribution Policy can, however, be useful in a number of situations. E.g.:
• It is often convenient to separate the list of available servers from the clip configuration file. This makes
it possible to change the list of servers without having to redeploy. The available servers might be
retrieved from a directory service such as LDAP.
• Round Robin and Random distribution policies are not always optimal: They behave best if the processes
allocated to the different RoboServers result in a similar load. In addition, the implementation of Round
Robin has one state (the next RoboServer to use) for each clip, which means that different clips might
accidentally favor the same RoboServers. An introduction to other scheduling policies is beyond the
scope of this manual.
• You might want to implement  more advanced  fail-over than provided in the default distribution
policies. The default implementation is, however, fairly advanced: If a RoboServer fails, it is marked as
unavailable. Every time a new RoboServer is requested, it is picked from the list of available servers. If
a certain time has elapsed since the last check, the unavailable server is pinged and potentially marked
as available. The time interval is increased every time pinging the server fails. This solution is often
sufficient, but can be tuned to the actual situation (e.g. pinging more often might be efficient in a low
latency-low bandwidth network, and just trying to send the request might be useful in a high latency-
high bandwidth network).
Clip Configuration File Specification
Round Robin and Random distribution policies are set up in the clip configuration file by specifying
a policy tag (one of random-distribution-policy and round-robin-distribution-
policy) in the robot-server tag. These tags both contain a list of RoboServers. The following
example uses random-distribution-policy.
Table 125. Clip Configuration File Specifying Random Distribution Policy
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE clip PUBLIC
"-//Kapow Technologies//DTD Clip Deployment Descriptor 1.3//EN"
"http://www.kapowtech.com/robosuite/rql/dtd/clip-deployment-descriptor_1_3.dtd">
Clipping Programmer's Guide
375
<clip>
<robot-url>library:/my.robot</robot-url>
<robot-library><default/></robot-library>
<robot-server>
<random-distribution-policy>
<socket-object-protocol host="localhost" port="50000"/>
<socket-object-protocol host="localhost" port="50001"/>
</random-distribution-policy>
</robot-server>
<user-credentials>
<class-name>com.mycompany.MyCredentialsProvider</class-name>
</user-credentials>
</clip>
If you want to implement your own Distribution Policy, you should specify a class name instead as shown
below.
Table 126. Clip Configuration File Specifying Random Distribution Policy
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE clip PUBLIC
"-//Kapow Technologies//DTD Clip Deployment Descriptor 1.3//EN"
"http://www.kapowtech.com/robosuite/rql/dtd/clip-deployment-descriptor_1_3.dtd">
<clip>
<robot-url>library:/my.robot</robot-url>
<robot-library><default/></robot-library>
<robot-server>
<class-name>
com.mycompany.myproject.MyDistributionPolicyProvider
</class-name>
</robot-server>
<user-credentials>
<class-name>com.mycompany.MyCredentialsProvider</class-name>
</user-credentials>
</clip>
As described, the order of the elements in the clip descriptor must follow the order defined in the DTD
(References). The following diagram shows the location of the robot-server element in the order of
these (not all elements may be present):
robot-url,  robot-library, robot-server,  robot-server-credentials,
portlet, popups-required,  popups-blocked-text, action-header-filter,
portal-cookie-filter, user-credentials, properties, additional-input-
objects,  additional-output-objects,  user-messages,  restart-session-
controller, error-handler, wait-page-text, wait-page-style
Implementation
Your Distribution Policy provider must implement the interface:
com.kapowtech.robosuite.client.clip.version1.api.
DistributionPolicyProvider
Clipping Programmer's Guide
376
This interface has one method:
DistributionPolicy provide(HttpServletRequest request,
HttpServletResponse response);
The arguments are the usual request and response, and are available to access the context and call servlet
API methods.
The provide method returns a
com.kapowtech.robosuite.api.java.rql.engine.dist.
DistributionPolicy
RQLEngine nextRQLEngine();
List selectAvailableRQLEngines();
The first method is at the core of the Distribution Policy: Whenever a session is started it must return a
new RQLEngine.
The second method returns a list of all available RQLEngines. This will often be a natural part of the
implementation of the DistributionPolicy, but has been made public: It can be used to allow
RQLEngines to multicast special requests to all RoboServers.
All  relevant  state  is  kept  in  the  DistributionPolicy  instance.  For  example,  the
RoundRobinDistributionPolicy keeps track of which server instance was returned last, and also
which servers are known to be unavailable. The DistributionPolicy implementation is accessed
from multiple threads, so it must be thread-safe. In practice, this means that all state must be protected
by a mutual exclusion lock.
Note:It is important that you only create one Distribution Policy inside your provider, and return references
to that instance on subsequent calls. If you return a new instance every time the provider is called, the load
will not be distributed between server, as the RQLEngine returned by the policy will only be used for the
one request, and the policy will then be discarded.
Example
It is important to understand that implementing your own Distribution Policy is a difficult task. To give a
complete and useful example which goes beyond the pre-implemented distribution algorithms is therefore
beyond the scope of this manual. The example given below is therefore not a useful one, and while it is
fully functional, it is less efficient than the built-in Random Distribution Policy. It is, however, sufficiently
complex to illustrate the central concerns that you must address when you implement your own Distribution
Policy.
An example of a Distribution Policy provider is given below. It defines a DistributionPolicy
as  a  final  field (_distributionPolicy)  which  is  returned  every  time the  provide  method  is
called — note that there are no guarantees concerning how often  the  provide  method is called.
The  Distribution  Policy  is  a  MyRandomDistributionPolicy,  which  is  described  in  detail
below.  The  MyRandomDistributionPolicy  is  initialized  with  a  static  list  of  RQLEngines
—  each of these are  created  in  addRoboServer  as a  RemoteRQLEngine communicating  via
SocketBasedObjectRQLProtocol. The method getRoboServers is meant to illustrate that the
list of servers is retrieved from an external source.
The example also presents the implementation of MyRandomDistributionPolicy. The policy
works by choosing a random RQLEngine among the available engines.
Clipping Programmer's Guide
377
The Distribution Policy tries to ensure that only available engines are returned in the nextRQLEngine
and  selectAvailableRQLEngines  methods  (which  implement  the  DistributionPolicy
interface). It does so in a naive (some would say stupid) way, by always pinging all potentially available
servers to see if they are available. This is implemented in updateAvailableEngines, which pings
each server using a special handler (the myPingRQLHandler) which will throw an exception if pinging
errs — hence adding the engine will be skipped and the exception caught and ignored.
Pinging all servers every time is of course highly inefficient, but is included to illustrate the importance
of availability.
Table 127. An Example of a Distribution Policy Provider
package com.mycompany.myproject;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.kapowtech.robosuite.api.java.rql.engine.RQLEngine;
import com.kapowtech.robosuite.api.java.rql.engine.dist.
DistributionPolicy;
import com.kapowtech.robosuite.api.java.rql.engine.remote.
RQLProtocol;
import com.kapowtech.robosuite.api.java.rql.engine.remote.
RemoteRQLEngine;
import com.kapowtech.robosuite.api.java.rql.engine.remote.socket.
SocketBasedObjectRQLProtocol;
import com.kapowtech.robosuite.client.clip.version1.api.
DistributionPolicyProvider;
public class MyDistributionPolicyProvider
implements DistributionPolicyProvider {
private interface RoboServerSpec {
String getHost();
int getPort();
}
private final DistributionPolicy _distributionPolicy
= new MyRandomDistributionPolicy(getEngineList());
public DistributionPolicy provide(HttpServletRequest request,
HttpServletResponse response) {
return _distributionPolicy;
}
private List<RQLEngine> getEngineList() {
List<RQLEngine> engineList = new LinkedList<RQLEngine>();
List<RoboServerSpec> servers = getRoboServers();
for (Iterator<RoboServerSpec> r = servers.iterator();
r.hasNext();) {
addRoboServer(engineList, r.next());
}
Clipping Programmer's Guide
378
return engineList;
}
private void addRoboServer(List<RQLEngine> engineList,
RoboServerSpec host) {
RQLProtocol protocol
= new SocketBasedObjectRQLProtocol(host.getHost(),
host.getPort());
RQLEngine engine = new RemoteRQLEngine(protocol);
engineList.add(engine);
}
private List<RoboServerSpec> getRoboServers() {
//  implementation left to the reader
}
}
Table 128. An Example of a Distribution Policy
package com.mycompany.myproject;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import com.kapowtech.robosuite.api.java.rql.RQLException;
import com.kapowtech.robosuite.api.java.rql.construct.PingRequest;
import com.kapowtech.robosuite.api.java.rql.construct.RQLRequest;
import com.kapowtech.robosuite.api.java.rql.engine.RQLEngine;
import com.kapowtech.robosuite.api.java.rql.engine.RQLHandler;
import com.kapowtech.robosuite.api.java.rql.engine.dist.
DistributionPolicy;
import com.kapowtech.robosuite.api.java.rql.engine.dist.
NoRQLEngineAvailableException;
class MyRandomDistributionPolicy implements DistributionPolicy {
static final RQLRequest _PING_REQUEST = new PingRequest();
static final RQLHandler _PING_HANDLER = new myPingRQLHandler();
private final List<RQLEngine> _engines;
private final List<RQLEngine> _availableEngines
= new LinkedList<RQLEngine>();
private final Random _random = new Random();
public MyRandomDistributionPolicy(List<RQLEngine> engines) {
_engines = engines;
updateAvailableEngines();
}
public RQLEngine nextRQLEngine()
throws NoRQLEngineAvailableException {
updateAvailableEngines();
int noOfEngines = _availableEngines.size();
if (noOfEngines == 0)
throw new NoRQLEngineAvailableException();
return _availableEngines.get(_random.nextInt(noOfEngines));
Documents you may be interested
Documents you may be interested