view pdf winform c# : Add hyperlink to pdf in SDK application service wpf html .net dnn XMerge_sdk1-part1487

Retrieving Plugins
Once the plugins have been registered the ConverterFactory can be used to return a Convert class by
simply passing in the mime types of the original and destination file formats. This Convert class can then
be used to to do the conversion. 
ConverterFactory
The ConverterFactory is a simple class that is really just a wrapper around the ConvertInfoMgr. It
provides two methods. the canConvert method which takes in two mime types and will return a boolean
indicating if the conversion can be done. The second method getConverter takes in the same two mime-
types and instead of returning a boolean returns a Convert class which can be used to  do the conversion.
There is a second implementation of getConverter which takes in a ConverterInfo and boolean (to
indicate direction) instead of two strings indicating mime types.
Convert
The Convert class is returned from the ConverterFactory. It has a member variable consisting of a
ConverterInfo which contains an instance of the Plugin needed for the conversion indicated in the call to
getConverter in the ConverterFactory. It has an addInputStream which is given a stream and
filename. It will construct a document using the plugin implementation of createDeviceDocument or
createOfficeDocument depending on the direction of the conversion. This document is then added to
the input ConvertData and is passed to the converter implementation. It also has a
getDeviceDocument and getOfficeDocument so documents can be created on the client side. The
clone and reset function were  added to allow reuse of the Convert object.
The most important method is obviously the convert method which will, depending on direction, use the
instance of the plugin implementation contained in the ConverterInfo to call serialize or deserialize. This
will return a ConvertData which can be enumerated over to return documents. The converted document
can then be written to an OutputStream via the Documents write method. 
Framework Overview
Page 11 of 25
Figure 4: Using ConverterInfoMgr to retrieve plugin
Figure 3: Loading plugins from JAR file
jarFile
ConverterInfoReader
ConverterInfoMgr
getConverterInfoEnumeration
Convert
ConvertData
ConvertData
getConverter
(mimeTypeIn, mimeTypeOut)
Destination
Original
ConverterFactory
ConverterInfoMgr 
(singleton)
Constructor
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
add hyperlink to pdf acrobat; adding a link to a 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
clickable links in pdf files; add hyperlink pdf document
Developing a Plugin
The Framework Overview section describes the main interfaces that make up a plugin.
The Plugin Configuration XML File
The Plugin Configuration file is an XML file that describes such things as the name of the PluginFactory
implementation class for a plugin, as well as vendor, version and other descriptive text. 
When implementing a converter, the implementer must provide a Plugin Configuration file for that plugin
which allows the plugin to be self-describing. 
Note that the current framework does not validate the configuration files against the DTD.
A DTD for plugin configuration files is described below and the full text of the DTD appears in Appendix A.
Note that more than one conversion can be described in a Plugin Configuration file. This means that a
plugin can be implemented which contains more than one  implementation.
Note that it is also possible for a converter to convert to multiple target types.
Elements of a Plugin Configuration XML File
The DTD for Plugin Configuration files is relatively short and has only a few mandatory elements.  Many of
the elements and attributes are simply descriptive items for use by client applications. 
Root Node
XML Code :
converters
Description
All converter plugin information files must have this node as their document root.
Status
Required
DTD
<!ELEMENT converters (converter)+>
Developing a Plugin
Page 12 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.
add hyperlinks to pdf; add hyperlink to pdf online
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 acrobat; clickable links in pdf from word
Converter Description
XML Code :
converter
Description
The converter node contains the description of the a conversion/merge made
available within the plugin. A plugin may be able to handle more than one
conversion and merge, therefore there may be more than one converter node.
The type attribute describes the mime type of the office document that this
plugin supports.
The version attribute is an implementer specified version number.
Status
Required
There may be more than one converter node.
DTD
<!ELEMENT converter  (converter-display-name,
converter-description?, 
converter-vendor?, 
converter-class-impl, 
converter-xslt-serialize?, 
converter-xslt-deserialize?, 
converter-target+)>
<!ATTLIST converter type CDATA #REQUIRED>
<!ATTLIST converter version CDATA #REQUIRED>
Converter-display-name
XML Code :
converter-display-name
Description
This is human readable string provided by the plugin implementer that provides
a name for the plugin for listing/inspecting purposes.
Status
Required
DTD
<!ELEMENT converter-display-name (#PCDATA)>
Converter-description
XML Code :
converter-description
Description
This is human readable string provided by the plugin implementer that describes
the plugin.
Status
Optional
DTD
<!ELEMENT converter-description (#PCDATA)>
Converter-vendor
XML Code :
converter-vendor
Description
The name of the individual implementing the converter.
Status
Optional
DTD
<!ELEMENT converter-vendor (#PCDATA)>
Developing a Plugin
Page 13 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
accessible links in pdf; adding hyperlinks to pdf documents
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
adding hyperlinks to pdf; add a link to a pdf file
Converter-class-impl
XML Code :
converter-class-impl
Description
The full name and the class that implements the PluginFactory interface for this
conversion. This class is instantiated in order to get access to convert and
merge functionality.
Status
Required
DTD
<!ELEMENT converter-class-impl (#PCDATA)>
Converter-xslt-serialize
XML Code :
converter-xslt-serialize
Description
For use with any plugin that wants to use the XSLT plugin for transforming
document using XSLT.
This element specifies an URL to and XSLT that is used for serializing office
documents to a lossy format. 
NB : It is assumed that the conversion specified by converter-class-impl will
make use of this XSLT.
Status
Optional
Even if present, this only has meaning for converters that use the XSLT plugin.
DTD
<!ELEMENT converter-xslt-serialize (#PCDATA)>
Converter-xslt-deserialize
XML Code :
converter-xslt-deserialize
Description
For use with any plugin that wants to use the XSLT plugin for transforming
document using XSLT.
This element specifies an URL to and XSLT that is used for deserializing lossy
format documents to office documents.
NB : It is assumed that the conversion specified by converter-class-impl will
make use of this XSLT.
Status
Optional
Even if present, this only has meaning for converters that use the XSLT plugin.
DTD
<!ELEMENT converter-xslt-deserialize (#PCDATA)>
Converter-target
XML Code :
converter-target
Description
The mime-type specified in the type attribute of this node indicates that a
conversion is supported between this type and the type attribute of the
converter node.
Status
Required
There may be more than one target.
DTD
<!ELEMENT converter-target       EMPTY>
<!ATTLIST converter-target type CDATA      #REQUIRED>
Developing a Plugin
Page 14 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 links to pdf acrobat; add links pdf document
.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,
adding hyperlinks to a pdf; add url pdf
Plugin SPI
The Plugin SPI consists of:
Top level Plugin SPI interfaces
Converter SPI
Merge SPI
Developing a Plugin
Page 15 of 25
Figure 5: Plugin SPI Classes
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.
pdf link; pdf email link
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:
pdf link open in new window; change link in pdf file
Figure 5 shows the major interfaces and class hierarchy within the Plugin SPI (though some of the
interfaces of the Merge SPI are not shown).
A plugin implementer can choose the functionality they want to provide by extending the PluginFactory
interface, and then optionally  implementing those interfaces they require from the Merge and Convert SPI
PluginFactory
PluginFactory is an abstract class which provides methods for creating Office and Device documents
from input streams passed to the plugin.  A plugin implementer must extend this class when implementing a
plugin.
DocumentSerializerFactory
This interface provides a method for returning an instance of the DocumentSerializer class.
Implementing this class provides access to a means of writing a given Office document to Device specific
format. 
Users of the plugin can query the PluginFactory implementation class using introspection to see if this
interface is implemented. If it is implemented then a specific Office to device conversion is possible.
DocumentDeserializerFactory
Similar to the DocumentDeserializerFactory, this interface provides a factory method for returning an
instance of the DocumentDeserializer class. Implementing this class provides access to a means of
writing a given device document to a particular Office format. 
Again, users of the plugin should use introspection to query the PluginFactory implementation class to
see if this interface is implemented. If it is implemented then a the user knows that the specific device to
Office document conversion is possible.
DocumentMergerFactory
The factory method of DocumentMergerFactory -  createDocumentMerger() provides access to the
Merger API by returning an instance of a DocumentMerger implementation.
Again, users of the plugin should use introspection to query the PluginFactory implementation class to
see if this interface is implemented. If it is implemented then a the user knows that this plugin supports
merging.
Developing a Plugin
Page 16 of 25
Converter SPI
The Converter provides interfaces which a plugin should implement if it wants to be able to write from Office
format to Device format and vice versa
DocumentSerializer
The DocumentSerializer Interface provide the serialize method for converting an Office document
to a device document. 
A serializer is created by calling the DocumentSerializerFactory method
createDocumentSerializer which takes an instance of the Document class as a parameter. This
Document object is the object to be serialized, so the plugin implementation should keep a reference to this
class.
ConvertData demoSerialize(DocumentSerializerFactory factory, 
Document doc)
{
ser = factory.createDocumentSerilizer(doc);
return ser.serialize();
}
Example 4: Serialization Example
Note that the serialize method must return it's result in a ConvertData object -  this is because a
serialize method call may result in more than one device document being created. See ConvertData
for more details.
DocumentDeserializer
The process for converting from a device format to OpenOffice format is very similar to the previous step. In
this case a 
DocumentDeserializer
is required  which is acquired by calling the
DocumentDeserializerFactory createDocumentDeserializer method and passing a
ConvertData which contains the device documents that are to be serialized.
Document demoDeserialize(DocumentSerializerFactory factory,
ConvertData docs)
{
DocumentDeserializer deser = 
factory.createDocumentDeserializer(docs);
return deser.deserialize();
}
Example 5: Deserialization Example
Calling the 
DocumentDeserializer.deserialize
method causes the data from the device document to be
read from the ConvertData object and converted into a DOM tree which is maintained internally by the
Document
implementation class. Calling 
Document.write
invokes the implementation class to write out the
document as a OpenOffice document.
Developing a Plugin
Page 17 of 25
Merge SPI
The Merge SPI provides interfaces for generating differences between two documents as well as merging
those differences to create a new document. These interfaces include :
DiffAlgorithm
MergeAlgorithm
Iterator
The Merge SPI is designed to merge a rich format XML file with a lossy version of that document which has
been edited. The term lossy is explained below.
Some implementations of these interfaces are provided in the current framework which are suitable for
many of the basic merge tasks. These are discussed later in the document.
DocumentMergerFactory
This class provides a factory method for getting a DocumentMerger instance. The instance returned by
this method implements the DocumentMerger interface and this implementation class handles the details
of the merge itself.
Difference Generation
In the discussion below the term "original document" refers to the original OpenOffice XML document which
has  been parsed into a DOM tree and which is encapsulated in an implementation class of the Converters
Document
interface. The term "modified document" refers to the device format document which has been
deserialized to a DOM tree and is also encapsulated in a converters 
Document
interface.
The difference process makes use of several interfaces discussed below. Several of these classes are also
used in the merge process. Also, note that the output of the difference process forms the input to the merge
process.
Iterators
Both the difference and the merge algorithms make use of the Converter 
Iterator
interface. This permits
the difference and merge algorithms to traverse the input documents and compare their contents in an
implementation independent way.
The 
NodeIterator
class implements the 
Iterator
interfaces. This provides a more DOM specific iterator
which can be extended to create iterators specific to particular document formats. There are currently four
such classes which extend 
NodeIterator
to provide document specific iterators when traversing the DOM
tree of Writer and Calc documents. These are 
CellNodeIterator
ParaNodeIterator
RowIterator and
TextNodeIterator
. If support is required for a converter for, say, OpenOffice Presentation documents,
further iterators would be required to traverse the structure of OpenOffice Presentation documents.
ConverterCapabilities
When you create an instance of a specific iterator, you have to have an instance of an object which
implements the  
ConverterCapabilities
class. 
ConverterCapabilities
specifies which OpenOffice
document tags and attributes are supported in the device document format. The
ConverterCapabilities.canConvertTag
and 
ConverterCapabilities.canConvertAttribute
return
either 
true
of 
false
depending on whether the device document can support the given tag or attribute.
Developing a Plugin
Page 18 of 25
The DiffAlgorithm Interface
Access to any of the difference algorithms is provided by the 
DiffAlgorithm
interface. All difference
generation algorithms should implement this interface.
The 
DiffAlgorithm
interface has one method, 
computeDifferences
 which takes as input two iterators -
one for the original document and one for the modified document - and returns a vector of 
Difference
object. 
The 
Difference
class encapsulates information about where a difference occurs - it reports the type of
difference (add, change or delete) and where the difference arises between the original and the modified
document.
For example, if the difference object holds "2" for original position, "3" for modified position and "change" for
the operation, it means, that the 2nd node of the original iterator has changed into the 3rd node of the
modified iterator, so we have to perform a merge between these 2 nodes. 
Because the difference and merge are two separate steps, it is possible to do multiple passes of difference
generation for two document from different granularity. For example, to merge two Writer based documents,
a paragraph Iterator can be used first to generate differences on a paragraph basis. If there are any
changes in a certain paragraph, a word Iterator can be created from that paragraph content and a word-
level difference generation can then be performed.
A similar process is applied to Spreadsheet documents - difference generation can be performed first at the
worksheet level, then the row level then the sheet level and so on.
The multi-pass approach allows the framework to choose the difference algorithm to apply based on the
content it encounters in the document. So if we encounter a table while performing a difference on a
paragraph of text, we can switch to a more appropriate difference algorithm which works better on tables.
Generating Differences
There are two basic steps required to generate the set of differences. First creates a "difftable" based on the
two iterators. A difftable is an (N × K) matrix where : 
N = A + 1;  A = number of objects (nodes) in original iterator
K = B + 1;  B = number of objects (nodes) in modified iterator
When complete, the matrix specifies the nodes that have remained the same and the nodes that have
changed between the two documents. 
Then generate a vector of 
Difference
objects from this matrix. These objects represent the operations that
have to be performed on the original document, to create a document that is logically equivalent to the
modified document in the device.
To illustrate the process we will look at how this process is applied to the difference generation for a
fictitious device document to SXW merge.
Developing a Plugin
Page 19 of 25
Using DiffAlgorithm to Generate Differences
public Difference [] diff(Document mod, Document orig, 
ConverterCapabilities cc,)
{
SxwDocument wdoc1 = (SxwDocument) orig;
SxwDocument wdoc2 = (SxwDocument) mod;
Document doc1 = wdoc1.getContentDOM();
Document doc2 = wdoc2.getContentDOM();
Iterator i1 = new ParaNodeIterator(cc, doc1.getDocumentElement());
Iterator i2 = new ParaNodeIterator(cc, doc2.getDocumentElement());
DiffAlgorithm diffAlgo = new IteratorLCSAlgorithm();
// find out the paragraph level diffs
Difference[] diffTable = diffAlgo.computeDiffs(i1, i2);
return diffTable;
}
Example 6: Difference Generation
The DOM trees of both documents are retrieved and an appropriate iterator - the ParaNodeIterator class in
this case - is instantiated for each DOM tree.
The iterator takes as a parameter to its constructor an instance of the ConverterCapabilities class for the
specific document type. The 
ConverterCapabilities
specify which OpenOffice  document tags and
attributes are supported on the device document format.
Next, an instance of an appropriate 
DiffAlgorithm
is created, in this case the 
IteratorLCSAlgorithm
,
and the 
Difference
vector is created. This vector forms the input to the merge.
Note that the merge algorithm needs access to the iterators used to generate the differences - they are
an input to the 
applyDifference
method call during merge.
Merge
The merge process works on the principle of taking two DOM trees and iterating over them to create a new
DOM tree that represents the "most-up-to-date" version of the document. Nodes for the new merged DOM
tree are selected based on the differences generated by the difference process as described above.
The present merge API supports a 2 way merge -this is when you modify a document on a device and you
want to merge it back to the original OpenOffice document. 
3-way merges are not currently supported. A 3-way merge is required when both the original document
and the device document have been modified, and the changes from both need to be merged
together.
The MergeAlgorithm Interface
The 
MergeAlgorithm
interface has a single method, 
applyDifference()
which takes as input two iterators
- an iterator for the original document, and an iterator for the modified document -  and the generated
Difference
vector. All merge algorithms should implement this interface. In order to carry out a merge you
need to instantiate an instance of a class that implements the 
MergeAlgorithm
interface and call its
applyDifference()
method.
Invoking Merge
The code fragment below illustrates the 
merge()
method of the class that implements the
DocumentMerger interface for a fictitious device document.
Developing a Plugin
Page 20 of 25
Documents you may be interested
Documents you may be interested