view pdf winform c# : Add hyperlink to pdf in software SDK project winforms wpf azure UWP XMerge_sdk0-part1486

XMerge Document Conversion SDK
Title:
XMerge Document Conversion SDK
Revision Number:
v0.1
Date:
March 7, 2002
Authors:
Brian Cameron
Martin Maher
Mike Hayes
Page 1 of 25
Add hyperlink to pdf in - 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
pdf links; add hyperlink pdf
Add hyperlink to pdf in - 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
adding an email link to a pdf; pdf edit hyperlink
Table of Contents
Introduction
.........................................................................................................................................4
Glossary of terms
...........................................................................................................................4
Document Structure
.......................................................................................................................4
Using the XMerge Conversion Framework
.......................................................................................5
Introduction
....................................................................................................................................5
Registry
...........................................................................................................................................5
ConverterFactory
............................................................................................................................5
Convert, Document and ConvertData
...........................................................................................6
Merging
...........................................................................................................................................6
Framework Overview
.........................................................................................................................8
Container Classes
...........................................................................................................................8
Document....................................................................................................................................8
ConvertData................................................................................................................................8
Managing Plugins
...........................................................................................................................9
What is a Plugin?........................................................................................................................9
Plugin Registration...................................................................................................................10
ConvertInfoMgr...................................................................................................................10
ConverterInfo.......................................................................................................................10
ConverterInfoReader...........................................................................................................10
Retrieving Plugins....................................................................................................................10
ConverterFactory.................................................................................................................11
Convert.................................................................................................................................11
Developing a Plugin
..........................................................................................................................12
Overview
......................................................................................................................................12
The Plugin Configuration XML File
...........................................................................................12
Elements of a Plugin Configuration XML File......................................................................12
Root Node............................................................................................................................12
Converter Description.........................................................................................................13
Converter-display-name......................................................................................................13
Converter-description..........................................................................................................13
Converter-vendor.................................................................................................................13
Converter-class-impl...........................................................................................................13
Converter-xslt-serialize.......................................................................................................14
Converter-xslt-deserialize...................................................................................................14
Converter-target...................................................................................................................14
Plugin SPI
.....................................................................................................................................15
PluginFactory...........................................................................................................................16
DocumentSerializerFactory................................................................................................16
DocumentDeserializerFactory............................................................................................16
DocumentMergerFactory....................................................................................................16
Converter SPI...........................................................................................................................17
DocumentSerializer.............................................................................................................17
DocumentDeserializer.........................................................................................................17
Merge SPI
.....................................................................................................................................18
DocumentMergerFactory.........................................................................................................18
Difference Generation..............................................................................................................18
Iterators................................................................................................................................18
ConverterCapabilities..........................................................................................................18
Page 2 of 25
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Change Word hyperlink to PDF hyperlink and bookmark. VB.NET Demo Code for Converting Word to PDF. Add necessary references: RasterEdge.Imaging.Basic.dll.
check links in pdf; add a link to a pdf in acrobat
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
Change Excel hyperlink to PDF hyperlink and bookmark. VB.NET Demo Code for Converting Excel to PDF. Add necessary references: RasterEdge.Imaging.Basic.dll.
add links to pdf in preview; add a link to a pdf in preview
The DiffAlgorithm Interface...............................................................................................19
Generating Differences.......................................................................................................19
Using DiffAlgorithm to Generate Differences..................................................................19
Merge........................................................................................................................................20
The MergeAlgorithm Interface...........................................................................................20
Invoking Merge...................................................................................................................20
Interfaces and Classes involved in a Merge.......................................................................21
Appendices
........................................................................................................................................22
Appendix A : Lossy Conversion
.................................................................................................22
Appendix B : converter.dtd
..........................................................................................................22
Appendix C : Debug and Test Mechanisms
...............................................................................24
Switching on your Debug Properties......................................................................................24
Debug Properties File...............................................................................................................24
Logging methods......................................................................................................................24
Testing your Plugin .................................................................................................................25
Page 3 of 25
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program. Hyperlink Edit. XDoc.PDF for .NET allows C# developers to edit hyperlink of PDF document
add links in pdf; adding links to pdf in preview
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET program. Hyperlink Edit. XDoc.PDF for .NET allows VB.NET developers to edit hyperlink of PDF
add links to pdf file; add email link to pdf
Introduction
StarOffice and OpenOffice are well-known for the wide variety of high-quality filters, in particular for the
Microsoft Office formats.
The XMerge SDK provides a Java-based framework for converting documents between different formats as
well as a growing set of conversion plugins to read and write each format. Currently HTML and the
StarOffice/OpenOffice Text XML document format are provided, other formats will be released shortly.
The goal of the SDK is to provide a convenient Java API for applications that wish to convert between
formats and to support developers who want to integrate support for their document formats into StarOffice
and OpenOffice.
In addition to format conversion, the XMerge SDK provides a framework for merging changes in one
document format (usually a simpler or lower quality format) into an original document (typically in a richer
format). The benefit of merging is that richer styles or content in the original document are retained, but the
edits made to the simpler format can be applied or merged into the original document.
To meet these goals there are two significant interfaces in XMerge:
the Conversion API's, used by applications to use a supported format conversion
the Plugin SPI, which is used by developers who want to add conversion support for a new document
format
Glossary of terms
Format – a document format such as StarWriter, HTML, Microsoft Word
Conversion – a translation from one document format to another
Merging – applying changes made to a simple document format to an original richer document formats
Lossy – a conversion to a simpler document format that loses some layout, style or even content
information
Plugin – a provider or adaptor that supports a specific document format
XMerge Registry – a collection of declarative meta-data about document formats and the supported
capabilities; each format is described by an XML document within each jar file containing a plugin for a
document format
Document Structure
The document is divided into sections for developers with different needs:
Using the XMerge Conversion Framework describes how to write an application that uses the highest-
level API within the XMerge SDK to easily perform format conversion
Framework Overview provides a description of the architecture of the XMerge  conversion framework
Developing a Plugin describes how to implement a document format plugin that integrates into the
XMerge framework
Introduction
Page 4 of 25
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Change Word hyperlink to PDF hyperlink and bookmark. C#.NET Sample Code: Convert Word to PDF in C#.NET Project. Add necessary references:
add hyperlinks pdf file; active links in pdf
.NET PDF Document Viewing, Annotation, Conversion & Processing
Extract hyperlink inside PDF. PDF Write. Insert text, text box into PDF. Edit, delete text from PDF. Insert images into PDF. Edit, remove images from PDF. Add,
add hyperlink in pdf; add links to pdf online
Using the XMerge Conversion Framework
Introduction
A client interacts with three Java interfaces to access conversion and merge utilities provided by the Small
Device framework.
An interface for registering plug-ins that perform conversion and/or merge functionality.
An interface for converting between StarOffice XML format and a small device format.
An interface for merging changes from the small device format back into an original StarOffice XML
document.
These interfaces have been designed to work in a generic fashion, so that the framework is utilized in the
same fashion regardless of the formats and/or plug-ins being used.
Registry
All plug-ins must have an associated converter.xml file that describes its capabilities.  This converter.xml file
is represented in the client by an instance of the ConverterInfo object.  A single converter.xml file may
specify the details for more than one plug-in. 
When a plug-in is provided in a jar file, it is expected that the jar file will contain the converter.xml file in the
META-INF directory.  As a convenience the ConverterInfoReader class has been provided to read in a
given jar file (assuming it contains a META-INF/converter.xml file), and provide a Vector of
ConverterInfo objects.
Once an instance of the ConverterInfo object has been created (via the ConverterInfoReader or
otherwise), it may be registered with the ConverterInfoMgr, which is responsible for keeping track of all
plug-in registration.  The ConverterInfoMgr is a singleton class, so only one instance of it may exist in a
given JVM.
The following logic would be used for registering a specific plug-in.
ConverterInfoReader cir =  new ConverterInfoReader(   
"file:///path_to_jar/myPlugIn.jar",
false);
Enumeration jarInfoEnumeration = cir.getConverterInfoEnumeration();
ConverterInfoMgr.addPlugIn(jarInfoEnumeration);
Example 1: Registering a plugin
ConverterFactory
The ConverterFactory provides an instance of the appropriate Convert class for a particular
conversion.  The desired conversion can be specified in one of two ways:
1. As a "from-mime-type" and "to-mime-type" combination.
2. By specifying the specific ConverterInfo that describes a plug-in.
Using the XMerge Conversion Framework
Page 5 of 25
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
Export PowerPoint hyperlink to PDF. VB.NET Demo Code for Converting PowerPoint to PDF. Add necessary references: RasterEdge.Imaging.Basic.dll.
clickable pdf links; add a link to a pdf
C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF
Export PowerPoint hyperlink to PDF in .NET console application. C#.NET Demo Code: Convert PowerPoint to PDF in C#.NET Application. Add necessary references:
convert doc to pdf with hyperlinks; adding links to pdf document
Convert, Document and ConvertData
The Convert class is capable of converting a document from one specified format to another.   A
Document is how a single file is managed within the framework.  Different plug-ins may use different
implementations of the Document interface to support the needs of the plug-in.  The OfficeDocument
implementation is provided for Documents that use the StarOffice XML format.
The Document.read method is called to set the Document to a specific InputStream.  The
Document.write method is called to write the Document to a client-supplied OutputStream.  The
Convert method provides a getOfficeDocument and getDeviceDocument methods so that the client
can easily access the appropriate Document types to be used for a given conversion.
The ConvertData class is used as the mechanism for passing one or more Document objects in and out
of the Convert class.  This is useful in conversions that can create multiple files.  For example, a word
processing document with an embedded image might be converted to two files, a HTML file and a separate
image file (GIF or JPEG).
The Convert class manages the input ConvertData, so the client only needs to access the
Convert.addInputStream method as many times as is appropriate to add the appropriate number of
input Document objects.
After specifying the input in this fashion, the client calls the Convert.convert method, which returns a
ConvertData object containing the converted Document objects.  The client can iterate over each output
Document within the ConvertData class and write them to user-provided OutputStream object(s).
An example of interacting with the ConvertData and Convert classes follows, omitting needed try/catch
blocks to make the code more readable:
ConverterFactory cf = new ConverterFactory();
Convert conv = cf.getConverter("staroffice/sxw","destination_mime_type");
FileInputStream fis = new FileInputStream("fileToConvert.sxw");
conv.addInputStream(processFile, fis);
ConvertData dataOut = conv.convert();
Enumeration docEnum = dataOut.getDocumentEnumeration();
while (docEnum.hasMoreElements()) {
Document docOut = (Document)docEnum.nextElement();
String fileName = docOut.getFileName();
FileOutputStream fos = new FileOutputStream(fileName);
docOut.write(fos);
fos.flush();
fos.close();
}
Example 2: Using the Framework API to convert a document
Merging
Merge is useful when an OfficeDocument is converted to a Device Document format, and the Device
Document version is modified.  Those changes can be merged back into the original OfficeDocument
with the merger.  The merger is capable of doing this even if the Device format is lossy in comparison to the
OfficeDocument format.
The client accesses the merger from the Convert object via the getDocumentMerger method, which
takes the original OfficeDocument in the constructor.  The client must utilize the
Convert.getOfficeDocument method in order to build this original OfficeDocument.  Before calling
the DocumentMerger.merge method, the client must first convert the device Document to an
Using the XMerge Conversion Framework
Page 6 of 25
OfficeDocument.  The DocumentMerger.merge method is called with the device OfficeDocument as
its argument.  When the DocumentMerger.merge method is called, the merged output is placed in the
original OfficeDocument.
An example of interacting with the DocumentMerger object follows, omitting needed try/catch blocks to
make the code more readable:
String mergeFile = "origDoc.sxw";
FileInputStream mergeIS   = new FileInputStream(mergeFile);
Document mergeDoc  = myConvert.getOfficeDocument(mergeFile, mergeIS);DocumentMerger
merger = myConvert.getDocumentMerger(mergeDoc);
if (merger ! = null) // if merger is not null, merge is supported
{
// dataOut is the device file converted to an OfficeDocument, the
// output of the Convert.convert method.
Enumeration     mergeEnum = dataOut.getDocumentEnumeration();
Document        converted = (Document)mergeEnum.nextElement();
merger.merge(convertedFile);
String fileName = converted.getFileName();
FileOutputStream fos = new FileOutputStream(fileName);
mergeDoc.write(fos);
fos.flush();
fos.close();
}
Example 3: Using DocumentMerger to do a merge
Using the XMerge Conversion Framework
Page 7 of 25
Framework Overview
The Converter framework is that part of the code that allows the client to use a simple interface to build
manage and run conversions and merge(s). It also provides the mechanism by which plugins can be
retrieved by the client. It was written to be as generic as possible to enable third party plugins to be written
quickly and easily.
Document Handling
There are two container classes accessible in the xMerge API. The most basic container is a Document. In
order to support file formats that can have multiple files in one document (e.g. HTML) the xMerge API also
provides a ConvertData class. A ConvertData class consists of a Vector of Document objects and a
String containing the name of the document being stored.  
Document
Document is an interface consisting of the following four methods :
void read(InputStream is)
void write(OutputStream os)
String getName(void)
String getFileName(void)
Most of the implementation work for this interface is done in reading from InputStreams to some internal
representation ( that can be used to convert to some other format )  or writing from this representation to an
OutputStream. The getName method returns the name of the Document excluding the file extension,
getFileName returns the name of the Document including the file extension.
ConvertData
ConvertData is a container class for multiple Document objects. This is especially useful when handling
multiple files which are part of the one document. It can also be used if handling multiple documents. It has
two member variables :
Vector v
String name
The documents are added to the Vector using the addDocument method. The Documents contained in
the vector are accessed using an Enumerator returned from the getDocumentEnumeration method.
Other functions used in this class are :
Framework Overview
Page 8 of 25
Figure 1: Container Class
Organization
Document
name
ConvertData
void reset()
String getName()
String getName()
int getNumDocuments()
The reset method enables reuse of a ConvertData object. getName and setName can be used for
getting and setting the document represented by the ConvertData.getNumDocuments returns the
number of documents contained in ConvertData.
Managing Plugins
The object which provides the ability to register and to retrieve a plugin to enable document conversion and
merger is the ConverterFactory class. It is through this class that Convert objects are returned and
these can be then used to do the conversion using ConvertData's. 
What is a Plugin?
A plugin contains classes that extends the PluginFactory abstract class and optionally one or more of
the following interfaces : DocumentSerializerFactory, DocumentDeserializerFactory and
DocumentMergerFactory. The plugin implements these interfaces depending on the functionality they
want to provide in the plugin implementation.
A plugin also contains an XML Configuration file which describes it's main classes and provides some
information about the plugin. This allows plugins to be dynamically loaded by an application, without having
specific knowledge of the implementation classes for that plugin beforehand.
The plugin capabilities can be discovered using introspection to determine which interfaces the plugin
implements. For instance a plugin that implements the DocumentMergerFactory is capable of performing
merges.
A plugin may implement up to seven interfaces :
DocumentSerializer
DocumentSerializerFactory
DocumentDeserializer
DocumentDeserializerFactory
DocumentMerger
DocumentMergerFactory
Framework Overview
Page 9 of 25
Figure 2Overview of SDK
PluginFactory
The DocumentDeserializer interface describes the deserialize method responsible for converting from
a Device Document to an Office Document. The DocumentSerializer interface describes the serialize
method responsible for converting from an Office Document to a Device Document. The
DocumentMerger interface defines a merge method that is used to merge two Office Documents together.
The equivalent interface Factories return an instance of one of the three interfaces above.
The PluginFactory abstract class defines only two methods (createOfficeDocument and
createDeviceDocument). The PluginFactory implementation however can optionally  implement any
of the three other interfaces (DocumentSerializer, DocumentDeserializer or DocumentMerger).  
Plugin Registration
Each plugin registers itself with the framework by providing an XML document called converter.xml which
describes that particular plugins conversion and/or merge capabilities. This file must be included within each
plugin jar file. The framework accesses this capabilties information using the ConverterInfo class.
functionality is not accessed directly, it is provided to the client by the registry as a ConverterInfo class
which provides a PluginFactory Implementation. In order for the registry to keep track of which
conversions are possible each plugin must provide a converter.xml. The converter.xml is stored in the
plugins jarfile. The ConvertInfoReader is a helper class which is capable of pulling the converter.xml out
of the jarfile so it can be stored in the registry by the ConvertInfoMgr. 
The ConverterInfoMgr as it's name suggest manages a set of ConverterInfo objects. A
ConverterInfo is simply a set  of the attributes described  in the converter.xml.
ConvertInfoMgr
The ConvertInfoMgr is a singleton that adds ConverterInfo objects to a Vector it maintains. It also
has methods to return a ConverterInfo based on the mime types of the original and destination file
formats. This is used by the ConverterFactory to return convert objects which will be described in
Retrieving Plugins
ConverterInfo
The ConverterInfo consists of a set of fields that describe a plugin. These fields are read in from the
converter.xml. It is the Client's responsibility to add jarfiles that contain these converter.xml's although the
client usually does not deal directly with ConverterInfo (see ConverterInfoReader). Apart from
getter's to read the various fields of the ConverterInfo there is also three functions to return instances of
DocumentDeserializer, DocumentSerializer and DocumentMerger. It is these instances that the
Convert class uses to do the requested operation.
ConverterInfoReader
The ConverterInfoReader is a helper class that can be used to read a converter.xml from a jarfile. The
jarfile can be passed in using the ConvertInfoReader constructor along with a boolean flag indicating
whether validation should be done or not. It has a method called getConverterInfoEnumeration that
returns a Enumeration which can be added directly to the ConverterInfoMgr. 
Framework Overview
Page 10 of 25
Documents you may be interested
Documents you may be interested