c# pdf viewer library free : Change page order pdf acrobat application control tool html web page azure online winforms.reportdesigner31-part1643

305 
Padding 
All zeroes 
ShapeFillBrush 
None 
ShapeFillColor 
Transparent 
ShapeLine 
Black, 0.5pt 
Spacing 
All zeroes 
TextAlignHorz 
Yes 
Left 
TextAlignVert 
Yes 
Top 
TextAngle 
TextColor 
Yes 
Black 
TextIndent 
TextPosition 
Normal 
VisitedHyperlinkAttrs 
Yes 
Magenta 
WordWrap 
Yes 
True 
Sub-Properties of Complex Style Properties 
Some of the properties in the table in the Style Properties and Their Default Values topic contain sub-properties 
which can be individually set. For instance, the BackgroundImageAlign property has AlignHorz, AlignVert, and 
several other sub-properties. With the exception of read-only sub-properties (as is the case with fonts, which are 
immutable and whose individual sub-properties cannot be set), each sub-property can be set or inherited 
individually. 
While the sub-properties of a font can not be modified, each of those sub-properties is represented by a separate 
root level property on a style – FontBold, FontItalic, and so on. Each of those properties can be set individually, 
and follows the general style inheritance rules. There is a nuance though that must be taken into consideration: if 
both Font and one of the separate font-related properties (FontBold, FontItalic, and so on.) are set, the result 
depends on the order in which the two properties are set. If the Font is set first, and then a font-related property is 
modified (that is, FontItalic is set to True), that modification affects the result. If, on the other hand, FontItalic is 
set to True first, and then Font is assigned to a non-italic font, the change to FontItalic is lost. 
Calculated Style Properties 
In the 2009 v3 release of Reports for WinForms, support was added for calculated style properties. For each style 
property, a matching string property was been added with the same name with "Expr" appended. For example, the 
BackColorExpr and TextColorExpr properties are matched to the BackColor and TextColor properties, and so on 
for all properties. 
Sub-properties of complex properties (such as ImageAlign, Borders, and so on.)  also have matching expression 
sub-properties. For example, the LeftExpr property is matched to Left property and so on. 
Style Expressions 
The following objects can be used in style expressions: 
RenderObject: the current style's owner render object. 
Document: the current document. 
Page (and other page related objects such as PageNo): the page containing the object (but see note below). 
RenderFragment: the current fragment. 
Aggregates. 
Change page order pdf acrobat - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
pdf rearrange pages online; rearrange pdf pages
Change page order pdf acrobat - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
how to reorder pdf pages in reader; how to move pages in a pdf
306  
Fields, DataBinding: reference the current data source; if the style's owner is within a table, and data 
sources have been specified for both rows and columns, this will reference the data source defined for the 
columns. 
RowNumber: row number in the associated data source. 
ColFields, ColDataBinding: only accessible if the style is used within a table, references the data source 
defined for the columns. 
RowFields, RowDataBinding: only accessible if the style is used within a table, references the data source 
defined for the rows. 
Converted Types 
When a calculated style property value is assigned to the real value that will be used to render the object, the types 
are converted according to the following rules: 
If the target property is numeric (int, float, and so on), the calculated value is converted to the required 
numeric type (converted from string, rounded, and so on) as necessary. 
If the target property is a Unit (for example, spacings), and the expression yields a number, the unit is 
created using the following constructor: new Unit(Document.DefaultUnitType, value). If the expression 
yields a string, that string is parsed using the normal Unit rules. 
In all other cases, an attempt is made to convert the value to the target type using the TypeConverter. 
Finally, if the expression yielded null, the parent style value is used as if the property has not been 
specified on the current style at all (such as the default behavior for unspecified style properties). 
Page References 
The following is an important note related to page references. Style expressions may reference the current page, for 
example: 
ro.Style.BackColor = "iif(PageCount < 3, Color.Red, Color.Blue)"; 
Such expressions cannot be calculated when the document is generated. Thus, during generation such expressions 
are ignored (default values are used), and the values are only calculated when the actual page that contains the 
object is being rendered (for example, for drawing in the preview, exporting and so on). 
As the result, style expressions that depend on pagination AND would affect the layout of the document may yield 
unexpected and undesirable results. For example, if the following expression is used for font size: 
ro.Style.FontSize = "iif(PageCount < 3, 20, 30)"; 
The above expression would be ignored during generation, as the result the rendered text will most probably be too 
large for the calculated object's size and clipping will occur. 
Paragraph Object Styles 
The RenderParagraph object (as all render objects) has the Style property, which can be used to set style properties 
applied to the paragraph as a whole. Individual paragraph objects (ParagraphText and ParagraphImage) also have 
styles, but the set of style properties that are applied to paragraph objects is limited to the following properties: 
BackColor 
Brush (only if it is a solid brush) 
Font (and font-related properties such as FontBold, and so on.) 
HoverHyperlinkAttrs 
TextColor 
TextPosition 
VisitedHyperlinkAttrs 
.NET PDF Document Viewing, Annotation, Conversion & Processing
Convert image files to PDF. File & Page Process. Re-order, rotate PDF pages. PDF Read. Print. Support for all the print modes in Acrobat PDF.
how to move pages in pdf reader; reorder pages in pdf online
VB.NET PDF: How to Create Watermark on PDF Document within
create a watermark to PDF file in order to help or image (such as business's logo) on any desired PDF page. And with our PDF Watermark Creator, users need no
reorder pages pdf file; move pages in pdf reader
307 
Table Styles 
In tables, the number of styles affecting the display of objects increases dramatically. In addition to the normal 
containment (a table, as all other elements of a document, is always contained either within another render object, 
or within the body of the document at the top level), object in tables also belong to at least a cell, a row and a 
column, all of which have their own styles. Additionally, an object can belong to a number of table element 
groups, which complicates the things even more. How styles in tables work is described in more detail in the Styles 
in Tables topic. 
Tables 
Tables are represented by instances of the RenderTable class. To create a table, just invoke its constructor, for 
example like this: 
Visual Basic 
Dim rt1 As New C1.C1Preview.RenderTable() 
C# 
RenderTable rt1 = new RenderTable(); 
C1PrintDocument tables follow the model of Microsoft Excel. Though a newly created table is physically empty 
(that is, it does not take much space in memory), logically it is infinite: you can access any element (cell, row, or 
column) of a table without first adding rows or columns, and writing to that element will logically create all 
elements preceding it. For instance, setting the text of the cell of an empty table at row index 9 and column index 3 
will make the table grow to 10 rows and 4 columns. 
To add content to a table, you must fill the cells with data. This can be done in one of the following ways: 
By setting the cell's RenderObject property to an arbitrary render object. This will insert the specified 
render object into that cell. Any render object can be added to a cell, including another table, thus 
allowing nested tables. 
By setting the cell's Text property to a string. This is actually a handy shortcut to create text-only tables, 
which internally creates a new RenderText object, sets the cell's RenderObject property to that 
RenderText, and sets that object's Text property to the specified string.  
So, for example, the following code snippet will create a table with 10 rows and 4 columns: 
Visual Basic 
Dim rt1 As New C1.C1Preview.RenderTable() 
Dim row As Integer = 0 
Do While (row < 10) 
Dim col As Integer = 0 
Do While (col < 4) 
rt1.Cells(row, col).Text = String.Format( _ 
"Text in cell({0}, {1})", row, col) 
col += 1 
Loop 
row += 1 
Loop 
C# 
RenderTable rt1 = new RenderTable(); 
for (int row = 0; row < 10; ++row) 
for (int col = 0; col < 4; ++col) 
rt1.Cells[row, col].Text = string.Format( 
"Text in cell({0}, {1})", row, col); 
GIF to PDF Converter | Convert GIF to PDF, Convert PDF to GIF
as easy as printing; Support both single-page and batch Drop image to process GIF to PDF image conversion; Provide filter option to change brightness, color and
move pages in pdf file; pdf change page order online
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
It can be used standalone. JPEG to PDF Converter is able to convert image files to PDF directly without the software Adobe Acrobat Reader for conversion.
how to rearrange pdf pages; reorder pdf page
308  
At any time, you can find out the actual current size of a table by querying the values of properties Cols.Count 
(which returns the current number of columns) and Rows.Count (which returns the current number of rows). 
Accessing Cells, Columns and Rows 
As can be seen from the sample code in the Tables topic, all cells in a table are represented by the Cells collection, 
which has the type TableCellCollection. Elements in this collection representing individual cells have the type 
TableCell. To access any cell in a table, the Cells collection can be indexed by the cell's row and column like this: 
Visual Basic 
Dim rt As New C1.C1Preview.RenderTable() 
… 
' get cell at row 10, column 4: 
Dim tc as TableCell = rt.Cells(10, 4) 
C# 
RenderTable rt = new RenderTable(); 
… 
// get cell at row 10, column 4: 
TableCell tc = rt.Cells[10, 4]; 
Table columns are accessed via the Cols collection, which has the type TableColCollection, and contains elements 
of the type TableCol. As with cells, just "touching" a column will create it. For instance, if you set a property of a 
column's Style, that column will be created if it did not exist already.  
Table rows are accessed via the Rows collection, which has the type TableRowCollection, and contains elements 
of the type TableRow. As with cells and columns, just "touching" a row will create it. For instance, if you set the 
Height of a row it (and all rows before it) will be automatically created. 
Please note, though, that all table rows that do not contain cells with some actual content will have a zero height, 
so will not be visible when the table is rendered. 
Table and Column Width, Row Height 
Both rows and columns in C1PrintDocument tables can be auto-sized but the default behavior is different for rows 
and columns. By default, rows have auto-height (calculated based on the content of cells in the row), while 
columns' widths are fixed. The default width of a RenderTable is equal to the width of its parent, and that width is 
shared equally between all columns. So the following code will create a page-wide table, with 3 equally wide 
columns, and 10 rows with the heights that auto-adjust to the height of the cells' content: 
Visual Basic 
Dim rt As New C1.C1Preview.RenderTable() 
rt.Style.GridLines.All = LineDef.Default 
Dim row As Integer = 0 
Do While (row < 10) 
Dim col As Integer = 0 
Do While (col < 3) 
rt.Cells(row, col).Text = String.Format( _ 
"Cell({0},{1})", row, col) 
col += 1 
Loop 
row += 1 
Loop 
doc.Body.Children.Add(rt) 
C# 
RenderTable rt = new RenderTable(); 
rt.Style.GridLines.All = LineDef.Default; 
for (int row = 0; row < 10; ++row) 
for (int col = 0; col < 3; ++col) 
PDF to WORD Converter | Convert PDF to Word, Convert Word to PDF
PDF to Word Converter has accurate output, and PDF to Word Converter doesn't need the support of Adobe Acrobat & Microsoft Word.
how to rearrange pdf pages reader; how to move pages around in a pdf document
TIFF to PDF Converter | Convert TIFF to PDF, Convert PDF to TIFF
doesn't require other third-party such as Adobe Acrobat. a few clicks; Ability to convert PDF documents to and upgrade; Easy to convert multi-page PDF files to
how to move pages around in pdf; reorder pdf pages in preview
309 
rt.Cells[row, col].Text = string.Format( 
"Cell({0}, {1})", row, col); 
doc.Body.Children.Add(rt); 
To make a fully auto-sized table, as compared to the default settings, two things must be done: 
The width of the whole table must be set to Auto (either the string "auto", or the static field Unit.Auto) 
and 
The table's RenderTable.ColumnSizingMode must be set to TableSizingModeEnum.Auto. 
Here's the modified code: 
Visual Basic 
Dim rt As New C1.C1Preview.RenderTable() 
rt.Style.GridLines.All = LineDef.Default 
Dim row As Integer = 0 
Do While (row < 10) 
Dim col As Integer = 0 
Do While (col < 3) 
rt.Cells(row, col).Text = String.Format( _ 
"Cell({0},{1})", row, col) 
col += 1 
Loop 
row += 1 
Loop 
rt.Width = Unit.Auto 
rt.ColumnSizingMode = TableSizingModeEnum.Auto 
doc.Body.Children.Add(rt) 
C# 
RenderTable rt = new RenderTable(); 
rt.Style.GridLines.All = LineDef.Default; 
for (int row = 0; row < 10; ++row) 
for (int col = 0; col < 3; ++col) 
rt.Cells[row, col].Text = string.Format( 
"Cell({0}, {1})", row, col); 
rt.Width = Unit.Auto; 
rt.ColumnSizingMode = TableSizingModeEnum.Auto; 
doc.Body.Children.Add(rt); 
The modified code makes each column of the table only as wide as needed to accommodate all text within cells. 
Groups of Rows and Columns, Headers and Footers 
Element groups are a very powerful feature of tables. Groups allow accessing several elements of a table as a whole 
(for example, the style can be set on a group as if it were a single element). Supported are groups of columns, 
groups of rows, and groups of cells. 
To access a group of rows, use the collection RowGroups (which has the type TableVectorGroupCollection). 
Elements of that collection have the type TableVectorGroup, with some useful properties defined on that type. One 
of the more interesting of those properties is ColumnHeader. That property allows assigning a group of rows to be 
a table header, to be repeated at the top of each new page or page column. A related property is ColumnFooter, 
which allows to assign a group of rows to be a table footer, again repeated either at the end of each page or page 
column.  
The following line of code shows how to assign the first 2 rows of a table to be the table header, repeated after each 
page or column break (rt1 here is a RenderTable object): 
DICOM to PDF Converter | Convert DICOM to PDF, Convert PDF to
Adobe Acrobat or any other print drivers when they use DICOM to PDF Converter. Additionally, high-quality image conversion of DICOM & PDF files in single page
rearrange pdf pages reader; reorder pdf pages reader
BMP to PDF Converter | Convert Bitmap to PDF, Convert PDF to BMP
interface; Powerful image converter for Bitmap and PDF files; No need for Adobe Acrobat Reader & print driver during conversion; Support
how to move pages within a pdf; reorder pages of pdf
310  
Visual Basic 
rt1.RowGroups(0, 2).Header = C1.C1Preview.TableHeaderEnum.Page 
C# 
rt1.RowGroups[0, 2].Header = C1.C1Preview.TableHeaderEnum.Page; 
As seen above, the indexer on the TableVectorGroupCollection class accepts two integers. The first value is the 
index of the first row included in the group (0 in the code example above). The second value is the count of rows in 
the group (2 in the code example above). 
To access a group of columns, the collection ColGroups should be used. It has the same type as the row groups' 
collection (TableVectorGroupCollection), and provides the same functionality. Of particular interest is the ability 
to assign a group of columns to be a vertical table header or footer. C1PrintDocument supports "horizontal" (or 
"extension") pages, which allow wide objects to span several pages horizontally. To allow an object (for example, a 
table) to span several pages horizontally, set its SplitHorzBehavior to a value other than 
SplitBehaviorEnum.Never. If the object's width is wider than the page width, it will be split into several horizontal 
pages. In particular, a wide table can be split in this way. To make a group of columns repeat along the left edge of 
each page, set the group's ColumnHeader property to True. To make a group of columns repeat along the right 
edge of each page, set the group's ColumnFooter property to True. 
Note: Although any group of rows (or columns) of a table can be assigned to be the footer, normally you would 
want to include only the last rows (or columns) of the table into the footer group. This will ensure that the footer 
behaves as a normal footer – that is appears only at the bottom (or right edge) of pages, and also appears at the 
end of the table. (If, for example, you assign the first row of a table to be the footer, it will still appear at the 
beginning of the table, and also will not print at the end of the table.)  
Here is an example of code that creates a table with 100 rows and 10 columns, sets the width of the table to Auto, 
explicitly sets the width of each column to 1 inch, and also assigns horizontal and vertical table headers and 
footers: 
Visual Basic 
' Create and fill the table. 
Dim rt1 As C1.C1Preview.RenderTable = New C1.C1Preview.RenderTable() 
Dim row As Integer = 0 
Dim col As Integer 
Do While (row < 100) 
col = 0 
Do While (col < 6) 
rt1.Cells(row, col).Text = String.Format("Text in cell({0}, {1})", 
row, col) 
col += 1 
Loop 
row += 1 
Loop 
' Set the table and columns' widths. 
rt1.Width = C1.C1Preview.Unit.Auto 
col = 0 
Do While (col < 6) 
rt1.Cols(col).Width = "1in" 
col += 1 
Loop 
' Assign the first 2 rows as the header and set the background. 
rt1.RowGroups(0, 2).PageHeader = True 
rt1.RowGroups(0, 2).Style.BackColor = Color.Red 
' Assign the last 2 rows as the footer and set the background. 
311 
rt1.RowGroups(98, 2).PageFooter = True 
rt1.RowGroups(98, 2).Style.BackColor = Color.Blue 
' Assign the first column as the header. 
rt1.ColGroups(0, 1).PageHeader = True 
rt1.ColGroups(0, 1).Style.BackColor = Color.BlueViolet 
' Assign the last column as the footer. 
rt1.ColGroups(5, 1).PageFooter = True 
rt1.ColGroups(5, 1).Style.BackColor = Color.BurlyWood 
C# 
// Create and fill the table. 
RenderTable rt1 = new RenderTable(); 
for (int row = 0; row < 100; ++row) 
for (int col = 0; col < 6; ++col) 
rt1.Cells[row, col].Text = string.Format("Text in cell({0}, {1})", 
row, col); 
// Set the table and columns' widths. 
rt1.Width = Unit.Auto; 
for (int col = 0; col < 6; ++col) 
rt1.Cols[col].Width = "1in"; 
// Assign the first 2 rows as the header and set the background. 
rt1.RowGroups[0, 2].PageHeader = true; 
rt1.RowGroups[0, 2].Style.BackColor = Color.Red; 
// Assign the last 2 rows as the footer and set the background. 
rt1.RowGroups[98, 2].PageFooter = true; 
rt1.RowGroups[98, 2]. Style.BackColor = Color.Blue; 
// Assign the first column as the header. 
rt1.ColGroups[0, 1].PageHeader = true; 
rt1.ColGroups[0, 1].Style.BackColor = Color.BlueViolet; 
// Assign the last column as the footer. 
rt1.ColGroups[5, 1].PageFooter = true; 
rt1.ColGroups[5, 1].Style.BackColor = Color.BurlyWood; 
In this sample, background color is used to highlight row and column groups. 
User Cell Groups 
Cells, even cells that are not adjacent to each other in the table, can be united into groups. You can then set styles 
on all cells in a group with a single command. To define a user cell group: 
1.
Create an object of the type UserCellGroup. This class has several overloaded constructors which allow 
specifying the coordinates of cells to be included in the group (all cells must be added to the group in the 
constructor). 
2.
Add the created UserCellGroup object to the UserCellGroups collection of the table. 
312  
3.
Now you can set the style on the group. This will affect all cells in the group. 
Styles in Tables  
Though table cells, columns, and rows are not render objects (they do not derive from the RenderObject class), 
they do have some properties similar to those of render objects. In particular, they all have the Style property.  
Manipulating styles affects the corresponding element and all its content. Setting the style of a row will affect all 
cells in that row. Setting the style of a column will affect all cells in that column. The style of the cell at the 
intersection of that row and column will be a combination of the styles specified for the row and the column. If the 
same style property is set on both the row and the column, the column will take precedence.  
Additionally, groups (groups of rows, groups of columns, and user cell groups) all have their own styles, which 
also affect the display of data in cells, and the display of table rows and columns.  
The following rules govern the application of styles in tables: 
Ambient style properties propagate down through the table elements (the whole table, row and column groups, cell 
groups, individual rows and columns, and individual cells) based on the "geometric" containment, similar to how 
ambient style properties propagate down render objects' containment outside of tables.  
Ambient properties affect the cells' content, without affecting those container elements. For instance, setting the 
font on the style of a whole table affects all text within that table unless its font was explicitly set at a lower level. 
Similarly, setting the font on the style of a row within that table affects the font of all cells within that row.  
When a specific ambient property is changed on two or more of the table elements involved, the following order of 
precedence is used to calculate the effective value of the property used to draw the cell: 
Cell's own style (has the highest priority) 
UserCellGroup style, if the cell is included in such 
Column style 
Columns group style, if any 
Row style 
Rows group style, if any 
Table style (has the least priority) 
Non-ambient properties set on styles of table elements listed above (whole table, row, column and cell groups, 
rows, columns and cells) are applied to those elements themselves, without affecting the content of the cells, even 
though such elements (with the exception of the whole table) are not render objects. For instance, to draw a border 
around a row in a table, set the Style.Borders on the row to the desired value. 
To set a non-ambient style property on all cells in a table, use RenderTable.CellStyle. If specified, that style is 
effectively used as the parent for the style of render object within cells.  
The CellStyle property is also defined on rows, columns, and groups of table elements, and if specified all those 
styles will affect non-ambient properties of the object within the cell. For instance, to set the background image for 
all cells in a table, set the table's CellStyle.BackgroundImage. This will repeat that image in all cells in a table, 
while assigning the same image to the table's Style.BackgroundImage will make that image the background for the 
whole table (the difference is apparent if the image is stretched in both cases). 
Anchors and Hyperlinks 
Reports for WinForms hyperlinks. Hyperlinks can be attached to render objects (RenderObject and derived 
classes), and paragraph objects (ParagraphObject and derived classes), and can be linked to: 
An anchor within the current document. 
An anchor within another C1PrintDocument. 
313 
A location within the current document. 
An external file. 
A page within the current document. 
A user event. 
Hyperlinks are supported by the preview controls included in C1.Win.C1Preview assembly (C1PreviewPane, 
C1PrintPreviewControl and C1PrintPreviewDialog). When a document with hyperlinks in it is previewed, and the 
mouse hovers over a hyperlink, the cursor changes to a hand. Clicking the hyperlink will, depending on the target 
of the link, either jump to another location within the document, open a different document and jump to a location 
in it, open an external file, or invoke the user event. 
Note: The sample code fragments in the following topics assume that the "using C1.C1Preview" directive (in C# 
syntax; or an equivalent for other languages) has been inserted into the file, so that instead of fully qualified type 
names (such as C1.C1Preview.RenderText) we can use just the class name part (RenderText). 
Adding a Hyperlink to an Anchor within the Same Document 
To link one part of your document to another, you have to do two things: 
Mark the location (called an anchor) where you want the link to point. 
Add a link to that location (a hyperlink) to another part of the document (you can have several hyperlinks 
pointing to the same anchor, of course). 
To create an anchor on a render object, you can add an element (of the type C1Anchor) to the Anchors collection 
of that render object. For example, if rt is a RenderTable you can write: 
Visual Basic 
rt.Anchors.Add(New C1.C1Preview.C1Anchor("anchor1")) 
C# 
rt.Anchors.Add(new C1Anchor("anchor1")); 
This will define an anchor with the name anchor1 (the name used to reference the anchor) on the render table. 
To link another render object, for example a RenderText, to that anchor, you can write: 
Visual Basic 
Dim rtxt As New C1.C1Preview.RenderText() 
rtxt.Text = "Link to anchor1" 
rtxt.Hyperlink = New C1.C1Preview.C1Hyperlink("anchor1") 
C# 
RenderText rtxt = new RenderText(); 
rtxt.Text = "Link to anchor1"; 
rtxt.Hyperlink = new C1Hyperlink("anchor1"); 
Of course, you must add both involved render objects (the one containing the anchor, and the one with the 
hyperlink) to the document. 
Hyperlink is a property of the RenderObject class, which is the base class for all render objects, so in exactly the 
same manner as shown above, any render object may be turned into a hyperlink by setting that property. 
Adding a Hyperlink to an Anchor in a Different C1PrintDocument 
To link a location in one document to a location in another, you must do the following: 
As described above, add an anchor to the target document, generate that document and save it as a C1D 
file on your disk. You can save the document using the Save button of the preview control, or in code 
using the Save method on the document itself. 
314  
Add a link pointing to that anchor to another document, in a way very similar to how an internal link is 
added. The only difference is that in addition to the target' anchor name you must also provide the name 
of the file containing the document. 
Here is the text of a complete program that creates a document with an anchor in it, and saves it in a disk file 
(myDocument1.c1d). It then creates another document, adds a link to the anchor in the first document to it, and 
shows the second document in a preview dialog box: 
Visual Basic 
' Make target document with an anchor. 
Dim targetDoc As New C1.C1Preview.C1PrintDocument 
Dim rt1 As New C1.C1Preview.RenderText("This is anchor1 in myDocument1.") 
rt1.Anchors.Add(New C1.C1Preview.C1Anchor("anchor1")) 
targetDoc.Body.Children.Add(rt1) 
targetDoc.Generate() 
targetDoc.Save("c:\myDocument1.c1d") 
' Make document with a hyperlink to the anchor. 
Dim sourceDoc As New C1.C1Preview.C1PrintDocument 
Dim rt2 As New C1.C1Preview.RenderText("This is hyperlink to 
myDocument1.") 
Dim linkTarget As C1.C1Preview.C1LinkTarget = New 
C1.C1Preview.C1LinkTargetExternalAnchor("c:\myDocument1.c1d", "anchor1") 
rt2.Hyperlink = New C1.C1Preview.C1Hyperlink(linkTarget) 
sourceDoc.Body.Children.Add(rt2) 
sourceDoc.Generate() 
' Show document with hyperlink in preview. 
Dim preview As New C1.Win.C1Preview.C1PrintPreviewDialog() 
preview.Document = sourceDoc 
preview.ShowDialog() 
C# 
// Make target document with an anchor. 
C1PrintDocument targetDoc = new C1PrintDocument(); 
RenderText rt1 = new RenderText("This is anchor1 in myDocument1."); 
rt1.Anchors.Add(new C1Anchor("anchor1")); 
targetDoc.Body.Children.Add(rt1); 
targetDoc.Generate(); 
targetDoc.Save(@"c:\myDocument1.c1d"); 
// Make document with a hyperlink to the anchor. 
C1PrintDocument sourceDoc = new C1PrintDocument(); 
RenderText rt2 = new RenderText("This is hyperlink to myDocument1."); 
C1LinkTarget linkTarget = new 
C1LinkTargetExternalAnchor(@"c:\myDocument1.c1d", "anchor1"); 
rt2.Hyperlink = new C1Hyperlink(linkTarget); 
sourceDoc.Body.Children.Add(rt2); 
sourceDoc.Generate(); 
// Show document with hyperlink in preview. 
C1PrintPreviewDialog preview = new C1PrintPreviewDialog(); 
preview.Document = sourceDoc; 
preview.ShowDialog(); 
Note the following: 
Documents you may be interested
Documents you may be interested