c# pdf viewer library free : How to reverse page order in pdf software application project winforms azure web page UWP winforms.reportdesigner34-part1646

335 
// Add the header to the group area: 
ra.Children.Add(rt); 
// This RenderText will print records within each group: 
rt = new RenderText(); 
// The text to print for each record: 
rt.Text = "GroupId: [Fields!GroupId.Value]\rIntValue: 
[Fields!IntValue.Value]"; 
rt.Style.Borders.Bottom = LineDef.Default; 
rt.Style.BackColor = Color.FromArgb(200, 210, 220); 
// Set the text's data source to the data source of the containing  
RenderArea - this indicates that the render object is bound to the current 
group in the specified object: 
rt.DataBinding.DataSource = ra.DataBinding.DataSource; 
// Add the text to the area: 
ra.Children.Add(rt); 
Using Aggregates 
The code below expands on the previous example by introducing aggregates in groups and the document as a 
whole: 
Visual Basic 
' Create a Render area to be repeated for each group: 
Dim ra As C1.C1Preview.RenderArea = New C1.C1Preview.RenderArea 
ra.Style.Borders.All = New C1.C1Preview.LineDef("2mm", Color.Blue)  
ra.DataBinding.DataSource = MyData.Generate(20, 0, True)  
ra.DataBinding.Grouping.Expressions.Add("Fields!GroupId.Value")  
' Make an aggregate that will calc the sum of IntValue fields within each 
group: 
Dim agg As C1.C1Preview.DataBinding.Aggregate = New 
C1.C1Preview.DataBinding.Aggregate("Group_IntValue") 
' Define the expression that will calc the sum: 
agg.ExpressionText = "Fields!IntValue.Value" 
' Specify that aggregate should have group scope: 
agg.Running = C1.C1Preview.DataBinding.RunningEnum.Group 
' Specify the data source for the aggregate: 
agg.DataBinding = ra.DataBinding 
' Add the aggregate to the document: 
doc.DataSchema.Aggregates.Add(agg) 
' Make an aggregate that will calc the sum of IntValue fields over the 
whole document: 
agg = New C1.C1Preview.DataBinding.Aggregate("Total_IntValue") 
' Define the expression to calc the sum: 
agg.ExpressionText = "Fields!IntValue.Value" 
' Specify that aggregate should have document scope: 
How to reverse page order in pdf - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
change page order in pdf file; move pages in pdf file
How to reverse page order in pdf - 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
change pdf page order reader; how to rearrange pdf pages in preview
336  
agg.Running = C1.C1Preview.DataBinding.RunningEnum.All 
' Specify the data source for the aggregate: 
agg.DataBinding = ra.DataBinding 
' Add the aggregate to the document: 
doc.DataSchema.Aggregates.Add(agg) 
' Make the group header: 
Dim rt As C1.C1Preview.RenderText = New C1.C1Preview.RenderText  
rt.Text = "GroupId: [Fields!GroupId.Value]"  
rt.Style.BackColor = Color.Yellow  
ra.Children.Add(rt) 
' This render text will print group records; as can be seen, group 
aggregate values can be referenced not only in group footer but also in 
group header and in group detail: 
rt = New C1.C1Preview.RenderText 
rt.Text = "GroupId: 
[Fields!GroupId.Value]\rIntValue:[Fields!IntValue.Value]\rGroup_IntValue:[
Aggregates!Group_IntValue.Value]\rTotal_IntValue:[Aggregates!Total_IntValu
e.Value]\rTatalNested_IntValue:[Aggregates!TatalNested_IntValue.Value]" 
rt.Style.Borders.Bottom = C1.C1Preview.LineDef.Default 
rt.Style.BackColor = Color.FromArgb(200, 210, 220) 
rt.DataBinding.DataSource = ra.DataBinding.DataSource 
ra.Children.Add(rt) 
' This aggregate is also calculated over the group, but is connected to 
the data binding of the nested object: 
agg = New C1.C1Preview.DataBinding.Aggregate("TotalNested_IntValue")  
agg.ExpressionText = "Fields!IntValue.Value"  
agg.Running = RunningEnum.All  
agg.DataBinding = rt.DataBinding  
doc.DataSchema.Aggregates.Add(agg) 
' Add the area to the document: 
doc.Body.Children.Add(ra) 
C# 
// Create a Render area to be repeated for each group: 
RenderArea ra = new RenderArea(); 
ra.Style.Borders.All = new LineDef("2mm", Color.Blue); 
ra.DataBinding.DataSource = MyData.Generate(20, 0, true); 
ra.DataBinding.Grouping.Expressions.Add("Fields!GroupId.Value"); 
// Make an aggregate that will calc the sum of IntValue fields within each 
group: 
Aggregate agg = new Aggregate("Group_IntValue"); 
// Define the expression that will calc the sum: 
agg.ExpressionText = "Fields!IntValue.Value"; 
// Specify that aggregate should have group scope: 
agg.Running = RunningEnum.Group; 
// Specify the data source for the aggregate: 
agg.DataBinding = ra.DataBinding; 
C# Word: How to Use C# Code to Print Word Document for .NET
document pages in original or reverse order within entire C# Class Code to Print Certain Page(s) of powerful & profession imaging controls, PDF document, image
reorder pages in pdf; how to reorder pages in pdf
337 
// Add the aggregate to the document: 
doc.DataSchema.Aggregates.Add(agg); 
// Make an aggregate that will calc the sum of IntValue fields over the 
whole document: 
agg = new Aggregate("Total_IntValue"); 
// Define the expression to calc the sum: 
agg.ExpressionText = "Fields!IntValue.Value"; 
// Specify that aggregate should have document scope: 
agg.Running = RunningEnum.All; 
// Specify the data source for the aggregate: 
agg.DataBinding = ra.DataBinding; 
// Add the aggregate to the document: 
doc.DataSchema.Aggregates.Add(agg); 
// Make the group header: 
RenderText rt = new RenderText(); 
rt.Text = "GroupId: [Fields!GroupId.Value]"; 
rt.Style.BackColor = Color.Yellow; 
ra.Children.Add(rt); 
// This render text will print group records; as can be seen, group 
aggregate values can be referenced not only in group footer but also in 
group header and in group detail: 
rt = new RenderText(); 
rt.Text = "GroupId: 
[Fields!GroupId.Value]\rIntValue:[Fields!IntValue.Value]\rGroup_IntValue:[
Aggregates!Group_IntValue.Value]\rTotal_IntValue:[Aggregates!Total_IntValu
e.Value]\rTatalNested_IntValue:[Aggregates!TatalNested_IntValue.Value]"; 
rt.Style.Borders.Bottom = LineDef.Default; 
rt.Style.BackColor = Color.FromArgb(200, 210, 220); 
rt.DataBinding.DataSource = ra.DataBinding.DataSource; 
ra.Children.Add(rt); 
// This aggregate is also calculated over the group, but is connected to 
the data binding of the nested object: 
agg = new Aggregate("TotalNested_IntValue"); 
agg.ExpressionText = "Fields!IntValue.Value"; 
agg.Running = RunningEnum.All; 
agg.DataBinding = rt.DataBinding; 
doc.DataSchema.Aggregates.Add(agg); 
// Add the area to the document: 
doc.Body.Children.Add(ra); 
Note that there are also aggregate types that can be used in data-bound C1PrintDocuments without declaring them 
in the document's aggregates collection (Aggregates). For more details and an example, see the Data Aggregates 
topic. 
338  
Data Aggregates 
In the 2010 v1 release, new aggregates were added to Reports for WinForms. These aggregate types can be used in 
data-bound C1PrintDocuments without the need to declare them in the document's aggregates collection 
(Aggregates). 
For instance, if "Balance" is a data field in a data-bound document, the following RenderText can be used to print 
the total balance for the dataset: 
Visual Basic 
Dim rt As New RenderText("[Sum(""Fields!Balance.Value"")]") 
C# 
RenderText rt = new RenderText("[Sum(\"Fields!Balance.Value\")]"); 
The following new properties and methods were added to the DataSet and C1DataBinding types to support this 
feature: 
Class 
Member 
Description 
C1DataBinding 
Name property 
Gets or sets the name of the current 
C1DataBinding. That name can be used in 
aggregate functions to indicate which data 
binding the aggregate refers to. 
DataSet 
Name property 
Gets or sets the name of the current DataSet. 
That name can be used in aggregate functions 
to indicate which data set the aggregate refers 
to. 
All aggregate functions have the follwing format:  
AggFunc(expression, scope) 
where: 
expression is a string defining an expression calculated for each row group or dataset row. 
scope is a string identifying the set of data for which the aggregate is calculated. If omitted, the aggregate is 
calculated for the current set of data (such as for the current group, dataset, and so on). If specified, should 
be the name of the target group or dataset. 
For example, if a dataset has the following fields, ID, GroupID, SubGroupID, NAME, Q, and records are grouped by 
GroupID and SubGroupID, the following document can be created: 
Visual Basic 
Dim doc As New C1PrintDocument() 
Dim raGroupId As New RenderArea() 
' ...set up raGroupId properties as desired... 
raGroupID.DataBinding.DataSource = dataSet 
raGroupID.DataBinding.Name = "GroupID" 
raGroupID.DataBinding.Grouping.Expressions.Add("Fields!GroupID.Value") 
Dim raSubGroupID As New RenderArea() 
' ...set up raSubGroupID properties as desired... 
raSubGroupID.DataBinding.DataSource = dataSet 
raSubGroupID.DataBinding.Grouping.Expressions.Add("Fields!SubGroupID.Value
") 
raGroupID.Children.Add(raSubGroupID) 
Dim raDetail As New RenderArea() 
' ...set up raDetail properties as desired... 
339 
raDetail.DataBinding.DataSource = dataSet 
raSubGroupID.Children.Add(raDetail) 
' show value of Q field: 
Dim rtQ As New RenderText() 
rtQ.Text = "[Fields!Q.Value]" 
raDetail.Children.Add(rtQ) 
' show sum of Q field for nested group (SubGroupID): 
Dim rtSumQ1 As New RenderText() 
rtSumQ1.Text = "[Sum(""Fields!Q.Value"")]" 
raDetail.Children.Add(rtSumQ1) 
' show sum of Q field for GroupID: 
Dim rtSumQ2 As New RenderText() 
rtSumQ2.Text = "[Sum(\"Fields!Q.Value\", "\"GroupID\"")]" 
raDetail.Children.Add(rtSumQ2) 
' show TOTAL sum of Q field for the entire dataset: 
Dim rtSumQ3 As New RenderText() 
rtSumQ3.Text = "[Sum(\"Fields!Q.Value\", "\"DataSet\"")]" 
raDetail.Children.Add(rtSumQ3) 
doc.Body.Children.Add(raGroupId) 
C# 
C1PrintDocument doc = new C1PrintDocument(); 
RenderArea raGroupId = new RenderArea(); 
// ...set up raGroupId properties as desired... 
raGroupID.DataBinding.DataSource = dataSet; 
raGroupID.DataBinding.Name = "GroupID"; 
raGroupID.DataBinding.Grouping.Expressions.Add("Fields!GroupID.Value"); 
RenderArea raSubGroupID = new RenderArea(); 
// ...set up raSubGroupID properties as desired... 
raSubGroupID.DataBinding.DataSource = dataSet; 
raSubGroupID.DataBinding.Grouping.Expressions.Add("Fields!SubGroupID.Value
"); 
raGroupID.Children.Add(raSubGroupID); 
RenderArea raDetail = new RenderArea(); 
// ...set up raDetail properties as desired... 
raDetail.DataBinding.DataSource = dataSet; 
raSubGroupID.Children.Add(raDetail); 
// show value of Q field: 
RenderText rtQ = new RenderText(); 
rtQ.Text = "[Fields!Q.Value]"; 
raDetail.Children.Add(rtQ); 
// show sum of Q field for nested group (SubGroupID): 
RenderText rtSumQ1 = new RenderText(); 
rtSumQ1.Text = "[Sum(\"Fields!Q.Value\")]"; 
raDetail.Children.Add(rtSumQ1); 
// show sum of Q field for GroupID: 
RenderText rtSumQ2 = new RenderText(); 
rtSumQ2.Text = "[Sum(\"Fields!Q.Value\", "\"GroupID\"")]"; 
raDetail.Children.Add(rtSumQ2); 
// show TOTAL sum of Q field for the entire dataset: 
RenderText rtSumQ3 = new RenderText(); 
rtSumQ3.Text = "[Sum(\"Fields!Q.Value\", "\"DataSet\"")]"; 
340  
raDetail.Children.Add(rtSumQ3); 
doc.Body.Children.Add(raGroupId); 
When the above document is generated, each instance of the raDetail group will show four values as follows: 
the current value of "Q" field 
the sum of the "Q" field over the current SubGroupID 
the sum of the "Q" field over the current GroupID 
the sum of the "Q" field over the whole document 
Table of Contents 
C1PrintDocument supports automatic generation of table of contents (TOC). The table of contents itself is 
represented by a dedicated render object, RenderToc, which is derived from RenderArea and adds TOC-specific 
features. Individual items within the TOC are represented by RenderTocItem (derived from RenderParagraph). 
Each TOC item holds a hyperlink (the RenderTocItem.Hyperlink property) pointing to a location in the 
document (represented by an anchor). So, the same mechanism is used for connecting TOC items to document 
content as for hyperlinks. Convenient methods are provided to create the TOC, see below. 
To add a table of contents to your document, do the following: 
1.
Create an instance of the RenderToc class and add it to your document at the point where you want the 
TOC to appear. 
2.
Add individual items (of the type RenderTocItem) to the RenderToc instance. Any of the following 
approaches (or a mix of them) may be used for this: 
You may add the TOC item to the TOC using any of the overloads of the RenderToc.AddItem 
method, providing the text of the item, the location it should point to, and optionally the level in the 
TOC. 
You may create an instance of the RenderTocItem class in your code, set properties on it, and add it 
to the Children collection of the TOC render object. 
An overload of the RenderTocItem constructor is provided which accepts an instance of the 
RenderToc as the argument. When that constructor is used, the newly created TOC item is added to 
the TOC within the constructor, so you do not need to add it to the Children collection of the TOC 
object manually. 
Sample Available 
For a complete sample of how to create the table of contents for a document using the dedicated RenderToc 
render object, see the RenderTOC sample located on the ComponentOne HelpCentral Sample page. 
Word Index 
You can now automatically generate indexes using C1PrintDocument. Each index (there can be several indexes in 
a document) consists of an alphabetized sorted list of letter headings with entries followed by lists of page numbers 
where the entry occurs. 
An index is represented by an instance of the RenderIndex class, a render object derived from RenderArea. You 
can add that object to the document as you would any other render object, but with one important limitation: the 
index must appear in the document after all occurrences of entries (terms) contained in it; so, like the traditional 
index, the index here would be best served to appear at the end of the document.  
Terms are words and word combinations that occur in the document and should appear as entries in the index. 
When the document is created, these terms are added to the RenderIndex object together with information about 
341 
locations where they occur (usually  the RenderText or RenderParagraph containing the term). Then, when the 
document generates, the RenderIndex object produces the actual index. 
Classes Supporting the Index Feature 
The following specialized classes support indexing: 
RenderIndex: This class is derived from RenderArea, and produces the index when inserted in a 
C1PrintDocument and that document generates.  
The RenderIndex must appear in the document after all occurrences of the index entries. The reason 
for this limitation is that the actual content of the index (and hence, the amount of space occupied by 
it) may vary significantly depending on the occurrences of the entries. 
IndexEntry: This class is used to describe an index entry (term) in the index.  
Each entry can have multiple occurrences (locations in the document where the term is described or 
referenced) associated with it. The collection of all occurrences of an entry is exposed via the 
Occurrences property on the IndexEntry.  
Each occurrence will produce a hyperlinked page number in the index when the document is 
generated. Besides which, an entry may contain a list of sub-entries (exposed by the property 
Children). The nesting level is unlimited, though usually up to 3 levels are used.  
Finally, to allow linking an entry to other entries in the index, the SeeAlso property on the entry 
contains a list of index entries that will be listed as references for the current entry in the generated 
index. 
IndexEntryOccurrence:  This class describes a single occurrence of an entry in the document.  
Elements of this type are contained in the Occurrences collection of an IndexEntry.  
One or more occurrences can be specified (as parameters to the constructor) when an instance of an 
index entry is created, and more occurrences can be added to the entry later.  
The main functional property of this class is Target, of the type C1LinkTarget, which points to the 
location of the occurrence. 
Generating an Index In Code 
Typically, the following steps would be involved in providing a simple one-level index in a document that is 
created in code: 
1.
An instance of the RenderIndex class should be created and stored in a local variable (as noted above, the 
index may not precede the occurrences of its entries). 
2.
As content (render objects) is added to the document, some program logic should identify strings that are 
to become entries (terms) in the index. Each such string should be tested on whether it has already been 
added to the Entries collection of the index object created in step 1. If this is a new entry, a new 
IndexEntry object should be created for it, and added to the index. 
3.
An entry occurrence (IndexEntryOccurrence) should be added to the existing or newly created entry, to 
point to the location of the occurrence in the document. Usually the location would be identified by the 
RenderObject that contains it and is being added to the document. 
4.
When all occurrences of the entries have been added to the document, the RenderIndex object created in 
step 1 can be added to the document's body. 
5.
When the document is generated, the RenderIndex object produces a hyperlinked index of the entries that 
have been added to it. The entries are automatically sorted, split into groups corresponding to each letter, 
and letter headings added. 
Of course, this is only one simple possible scenario designed to demonstrate the relationship between the main 
objects involved in creating an index. Other possibilities include the creation of indexed terms (index entries) prior 
342  
to document creation (for example, based on an external dictionary of terms), adding nested entries (sub-entries), 
and so on. 
Customizing the Index's Appearance 
The following properties are provided to customize the way the generated index looks: 
Styles (see also Styles): 
Style: specifies the style for the whole index (including headings, entries, and so on). 
HeadingStyle: specifies the style used for letter headings (the heading is a letter preceding the group of 
entries starting with that letter). In the generated index, each heading (usually just the capitalized letter 
preceding the group of entries beginning with it) is represented by a separate render object 
(RenderText) to which this style is applied.  
EntryStyles: an indexed property specifying the styles of entries at different levels. For instance, 
EntryStyles[0] (EntryStyles(0) in VB) specifies the style of entries at the top level, 
EntryStyles[1] (EntryStyles(1) in VB) specifies the style of sub-entries, and so on. (If the 
number of nested levels in the index is greater than the number of elements in the EntryStyles 
collection, the last style in the collection is used for nested styles.)  
In the generated index, each entry (the term followed by the list of pages where it appears) is 
represented by a separate RenderParagraph object, to which the style determined by this property 
indexed by the entry's nesting level is applied. For instance, this style allows you to specify the 
minimum number of lines of an entry text before a page break can be inserted (via MinOrphanLines). 
EntryStyle: this is a shortcut for the first (with index 0) element of the EntryStyles collection. 
SeeAlsoStyle: allows you to specify the style of the "see also" text used to precede cross references 
between entries (see SeeAlso). 
Style: allows you to override the style for a particular entry. 
SeeAlsoStyle: allows you to override the style of the "see also" text for a particular entry. 
Other properties: 
RunIn: a Boolean property (False by default) which, if True, indicates that sub-entries should appear 
in line with the main heading rather than indented on separate lines. 
EntryIndent: a Unit property specifying the indent of sub-entries relative to the main entry. The 
default is 0.25 inch. 
EntryHangingIndent: a Unit property specifying the hanging indent (to the left) of the first line of an 
entry's text relative to the following lines (used if the list of references does not fit on a single line). The 
default is -0.125 inch. 
LetterSplitBehavior: a SplitBehaviorEnum property that determines how a letter group (entries 
starting with the same letter) can be split vertically. The default is SplitBehaviorEnum.SplitIfNeeded. 
Note that headings (represented by their letters by default) are always printed together with their first 
entry. 
Italic: similar to Bold but uses italic face instead of bold. 
LetterFormat: a string used to format the letter headings. The default is "{0}". 
TermDelimiter: a string used to delimit the entry term and the list of term's occurrences (page 
numbers). The default is a comma followed by a space. 
RunInDelimiter: a string used to delimit the entries when a run-in (see RunIn) index is generated. The 
default is a semicolon. 
343 
OccurrenceDelimiter: a string used to delimit the list of occurrences of an entry (page numbers). The 
default is a comma followed by a space. 
PageRangeFormat: a format string used to format page ranges of entries' occurrences. The default is 
"{0}-{1}". 
SeeAlsoFormat: a string used to format the "see also" references. The default is " (see {0})" (a space, 
followed by an opening parentheses, followed by the format item used to output the reference, 
followed by a closing parentheses). 
FillChar: a character used as filler when the page numbers are aligned to the right 
(PageNumbersAtRight is True). The default value of this property is a dot. 
PageNumbersAtRight: a Boolean property indicating whether to right-align the page numbers. The 
default is False. 
EntrySplitBehavior: a SplitBehaviorEnum property that determines how a single entry can split 
vertically. The default is SplitBehaviorEnum.SplitIfLarge. This property applies to entries at all levels. 
Bold: a Boolean property that allows you to highlight the page number corresponding to a certain 
occurrence of an entry using bold face. (For example, this can be used to highlight the location where 
the main definition of a term is provided,. 
Index Styles Hierarchy 
The hierarchy of index-specific styles is as follows: 
Style, of the RenderIndex object, serves as AmbientParent for all other index-specific styles 
HeadingStyle 
EntryStyles 
Style 
SeeAlsoStyle 
SeeAlsoStyle 
With the exception of the Style of RenderIndex, all of the styles listed above serve as both Parent and 
AmbientParent for the inline styles of related objects. So for example, while setting a font on the Style of a 
RenderIndex will affect all elements of that index (unless overridden by a lower-level style), specifying a border on 
that style will draw that border around the whole index but not around individual elements in it. On the other 
hand, specifying a border on SeeAlsoStyle for instance will draw borders around each "see also" element in the 
index. 
The Structure of the Generated Index 
The following figure shows the structure and hierarchy of the render object tree created by a RenderIndex object 
when the document generates (note that in the figure, only the RenderIndex object at the top level is created by 
user code; all other objects are created automatically): 
RenderIndex 
344  
RenderArea (represents a group of entries starting with the same letter) 
RenderText (prints letter group header) 
RenderParagraph (prints top-level IndexEntry) 
RenderParagraph (prints sub-entry, offset via Left) 
RenderArea (represents a group of entries starting with the same letter) 
RenderText (prints letter group header) 
RenderParagraph (prints top-level IndexEntry) 
RenderParagraph (prints sub-entry, offset via Left) 
Outline 
C1PrintDocument supports outlines. The document outline is a tree (specified by the Outlines property), with 
nodes (of the type OutlineNode) pointing to locations in the document. The outline is shown on a tab in the 
navigation panel of the preview, and allows navigating to locations corresponding to items by clicking on the 
items. Also, outlines are exported to formats supporting that notion (such as PDF). 
To create an outline node, use any of the overloaded Outline constructors. You can specify the text of the outline, 
the location within the document (a render object or an anchor), and an icon to be shown in the outline tree panel 
in the preview. Top-level nodes should be added to the Outlines collection of the document. Each outline node 
may, in its turn, contain a collection of child nodes in the Children collection, and so on. 
Documents you may be interested
Documents you may be interested