free pdf viewer c# : Export text from pdf to word software Library dll winforms .net html web forms JasperReports-Ultimate-Guide-324-part1353

S
CRIPTLETS
All the data displayed in a report comes from the report parameters and report fields. 
This data can be processed using the report variables and their expressions. Some 
variables are initialized according to their reset type when the report starts, or when a 
page or column break is encountered, or when a group changes. Furthermore, variables 
are evaluated every time new data is fetched from the data source (for every row). 
But simple variable expressions cannot always implement complex functionality. This is 
where scriptlets come in. Scriptlets are sequences of Java code that are executed every 
time a report event occurs. Through scriptlets, users can affect the values stored by the 
report variables. Since scriptlets work mainly with report variables, it is important to 
have full control over the exact moment the scriptlet is executed. 
JasperReports allows the execution of custom Java code before or after it initializes the 
report variables according to their reset type: 
Report
Page
Column
, or 
Group
In order to make use of this functionality, users need only create a scriptlet class, by 
extending one of the following two classes:
net.sf.jasperreports.engine.JRAbstractScriptlet
net.sf.jasperreports.engine.JRDefaultScriptlet
Note
Support for scriptlets is available both at report level (main dataset) and subdatasets. For the sake of 
simplicity, we are referring only to report level scriptlets, but it should be understood that everything applies to 
subdataset scriptlets as well.
Any number of scriptlets can be specified per report. If no scriplet is specified for a 
report, the engine still creates a single 
JRDefaultScriptlet
instance and registers it 
with the built-in 
REPORT_SCRIPTLET
parameter.
Listing 16-1 gives the JRXML syntax for scriptlets.
Listing 16-1. JRXML Syntax
<!ELEMENT scriptlet (property*, scriptletDescription?)>
<!ATTLIST  scriptlet
P
AGE
229
Export text from pdf to word - extract text content from PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Feel Free to Extract Text from PDF Page, Page Region or the Whole PDF File
copy and paste text from pdf to word; .net extract text from pdf
Export text from pdf to word - VB.NET PDF Text Extract Library: extract text content from PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
How to Extract Text from PDF with VB.NET Sample Codes in .NET Application
get text from pdf file c#; pdf text replace tool
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
name NMTOKEN #REQUIRED
class CDATA #REQUIRED
>
<!ELEMENT scriptletDescription (#PCDATA)>
For each scriplet, a name and a class extending the 
JRAbstractScriptlet
class must 
be specified. The class must be available in the classpath at report filling time and must 
have an empty constructor, so that the engine can instantiate it on the fly.
The only case when the name of the scriptlet is not required is when it is specified using 
the 
scriptletClass
attribute of the 
<jasperReport>
element. The scriptlet instance 
created with this attribute, acts like the first scriptlet in the list of scriptlets and has the 
predefined name 
REPORT
.
When creating a JasperReports scriptlet class, there are several methods that developers 
should implement or override, including 
beforeReportInit()
afterReportInit()
beforePageInit()
afterPageInit()
beforeGroupInit()
, and 
afterGroupInit()
. The report engine calls these methods at the appropriate time when 
filling the report.
For more complex reports containing very complicated report expressions for grouping 
or displaying data, create a separate class to which you then make calls from simplified 
report expressions. The scriptlet classes are ideal for this. This is because the reporting 
engine supplies you with references to the scriptlet objects it creates on the fly using the 
built-in 
[ScriptletName]_SCRIPTLET
parameters.
Scriptlet objects are not instantiated by the engine if an instance is already provided as a 
value for the corresponding 
[ScriptletName]_SCRIPTLET
parameter, by the caller.
Check the 
/demo/samples/scriptlet
sample provided with the project source files to 
see this type of functionality used.
G
LOBAL
S
CRIPTLETS
Another way to associate scriptlets with reports is by declaring the scriptlets globally so 
that they can apply to all reports being filled in the given JasperReports deployment.
This is made easy by the fact that scriptlets can be added to JasperReports as extensions. 
The scriptlet extension point is represented by the 
net.sf.jasperreports.engine.scriptlets.ScriptletFactory
interface. 
JasperReports will load all scriptlet factories available through extensions at runtime and 
will ask each one of them for the list of scriptlets instances that they want to apply to the 
current report that is being run. When asking for the list of scriptlet instances, the engine 
gives some context information that the factory could use in order to decide which 
scriptlets actually apply to the current report. For example, some scriptlets could look for 
P
AGE
230
C# WPF PDF Viewer SDK to convert and export PDF document to other
PDF from CSV. Create PDF from RTF. Create PDF from Text. PDF Export. Convert PDF to Word (.docx). Convert PDF to Tiff. Convert PDF to
extract text from scanned pdf; c# extract text from pdf
VB.NET PDF - Convert PDF with VB.NET WPF PDF Viewer
PDF from RTF. Create PDF from Text. PDF Export. Convert PDF to Word (.docx). Convert PDF to Tiff. Convert PDF to HTML. Convert PDF to
cut and paste text from pdf document; copy text from encrypted pdf
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
certain report properties in the report template to see if they should be triggered or stay 
dormant during the current report execution.
R
EPORT
G
OVERNORS
Governors are just a breed of global scriptlets that enable us to tackle a problem that has 
been around for sometime in JasperReports.
It is known that certain invalid report templates could cause the reporting engine to enter 
an infinite loop at runtime, while trying to generate the reports. Such invalid report 
templates cannot be detected at design time, because most of the time the conditions for 
entering the infinite loops depend on the actual data that is fed into the engine at runtime.
There are many reasons for a report to be invalid and cause such infinite loops, but 
regardless of the actual cause, infinite loops occur when the reporting engine tries to 
layout a page in the generated report and the content of this current page overflows onto 
another page. On the second page where the content has overflown, some of the elements 
from the previous page need to appear again (either because they represent a page header 
or the user has specifically indicated that they should appear again by setting their 
isPrintWhenDetailOverflows=”true”
). Because of these elements appearing again 
on the new page, conditions are met again for the page to overflow to another new page. 
And so the engine has entered an infinite loop trying to layout new pages in the 
generated document and hoping that everything will fit nicely. Unfortunately it does not 
fit and there is no way for the program itself to realize it has entered an infinite loop.
Simply put, we cannot anticipate that certain report templates will cause the engine to 
enter an infinite loop, and while within an infinite loop, there is no way for the program 
to know it is trapped in such a loop.
And here's where report governors become handy, because they can help deciding 
whether a certain report has entered an infinite loop and they can stop it, preventing 
resource exhaustion for the machine that runs the report.
JasperReports is shipped with two simple report governors that would stop a report 
execution based on a specified maximum number of pages or a specified timeout 
interval.
The 
net.sf.jasperreports.governors.MaxPagesGovernor
is a global scriptlet 
that is looking for two configuration properties to decide if it applies or not to the report 
currently being run:
net.sf.jasperreports.governor.max.pages.enabled=[true|false]
net.sf.jasperreports.governor.max.pages=[integer]
The 
net.sf.jasperreports.governors.TimeoutGovernor
is also a global scriptlet 
that is looking for the following two configuration properties to decide if it applies or 
not:
P
AGE
231
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
PDF from RTF. Create PDF from Text. PDF Export. Convert PDF to Word (.docx). Convert PDF to Tiff. Convert PDF to HTML. Convert PDF to
copy pdf text with formatting; extract all text from pdf
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
NET control to export Word from multiple PDF files in VB. Create editable Word file online without email. Supports transfer from password protected PDF.
copy text from pdf to word; copy text from pdf
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
net.sf.jasperreports.governor.timeout.enabled=[true|false]
net.sf.jasperreports.governor.timeout=[milliseconds]
The properties for both governors can be set globally, in the 
jasperreports.properties
file, or at report level, as custom report properties. This is 
useful because different reports can have different estimated size or timeout limits and 
also because you might want turn on the governors for all reports, while turning it off for 
some, or vice-versa.
P
AGE
232
C# PDF Converter Library SDK to convert PDF to other file formats
Support to convert multi-page PDF file to multi-page Tiff file. Able to export PDF document to HTML file. Allow users to convert PDF to Text (TXT) file.
delete text from pdf file; extract text from pdf c#
VB.NET PDF Converter Library SDK to convert PDF to other file
PDF Export. |. Home ›› XDoc.PDF ›› VB.NET PDF: PDF Export. VB.NET sample code. Conversion of PDF to Text. A quick and efficient
extract text from pdf with formatting; export text from pdf to word
I
NTERNATIONALIZATION
JasperReports lets you associate a 
java.util.ResourceBundle
with the report 
template, either at design time (by using the new 
resourceBundle
attribute) or at 
runtime (by providing a value for the built-in 
REPORT_RESOURCE_BUNDLE
parameter).
If the report needs to be generated in a locale that is different from the current one, use 
the built-in 
REPORT_LOCALE
parameter to specify the runtime locale when filling the 
report. To facilitate report internationalization, a special syntax is available inside report 
expressions to reference 
java.lang.String
resources placed inside a 
java.util.ResourceBundle
object associated with the report. The 
$R{}
syntax is for 
wrapping resource bundle keys to retrieve the value for that key.
For formatting messages in different languages based on the report locale, a built-in 
method inside the report’s 
net.sf.jasperreports.engine.fill.JRCalculator 
offers functionality similar to the 
java.text.MessageFormat
class. This method, 
msg()
, has three convenient signatures that allow you to use up to three message 
parameters in the messages. 
Also provided is the built-in 
str()
method (the equivalent of the 
$R{}
syntax inside the 
report expressions), which gives access to the resource bundle content based on the 
report locale.
For date and time formatting, the built-in 
REPORT_TIME_ZONE
parameter can be used to 
ensure proper time transformations.
In the generated output, the library keeps information about the text run direction so that 
documents generated in languages that have right-to-left writing (like Arabic and 
Hebrew) can be rendered properly.
If an application relies on the built-in Swing viewer to display generated reports, then it 
too must be internationalized by adapting the button ToolTips or other texts displayed. 
This is very easy to do since the viewer relies on a predefined resource bundle to extract 
locale-specific information. The base name for this resource bundle is 
net.sf.jasperreports.view.viewer
. Check the 
/demo/samples/i18n
and 
/demo/samples/unicode
samples for details.
P
AGE
233
C# HTML5 PDF Viewer SDK to convert and export PDF document to
from OpenOffice. Create PDF from CSV. Create PDF from RTF. Create PDF from Text. PDF Export. Convert PDF to Word (.docx). Convert PDF
copy and paste text from pdf; extract text from pdf using c#
C# WPF PDF Viewer SDK to view, annotate, convert and print PDF in
from OpenOffice. Create PDF from CSV. Create PDF from RTF. Create PDF from Text. PDF Export. Convert PDF to Word (.docx). Convert PDF
copy pdf text to word with formatting; export highlighted text from pdf to word
R
EPORT
E
XPORTERS
The proprietary document format used by JasperReports to generate and store final 
documents is represented by a 
net.sf.jasperreports.engine.JasperPrint
object, 
which can be serialized for transfer over the network or permanent storage. However, 
when these documents must be sent to third-party consumers who do not have the proper 
tools to view and print them in the JasperReports proprietary format, the best solution is 
to export those documents to more popular formats like PDF, HTML, RTF, XLS, ODT, 
or CVS, for which there are specialized viewers available on almost all platforms.
JasperReports tries to expose its exporting functionality in a flexible way and allow users 
to fully customize how documents are exported, as well as extend the existing 
functionality if needed. All document exporting in JasperReports is done through a very 
simple interface called 
net.sf.jasperreports.engine.JRExporter
. Every 
document format that JasperReports currently supports has an implementation of this 
interface. When a report must be exported, an instance of the desired exporter 
implementation is created and configured before the export method is called to launch 
the actual export process on that exporter.
All the input data the exporter might need is supplied by the so-called exporter 
parameters before the exporting process is started. This is because the exporting process 
is always invoked by calling the 
exportReport()
method of the 
net.sf.jasperreports.engine.JRExporter
interface, and this method does not 
receive any parameters when called. The exporter parameters must have already been set 
using the 
setParameter()
method on the exporter instance you are working with 
before the export task is launched. 
You might also choose to bulk set all the exporter parameters using the 
setParameters()
method, which receives a 
java.util.Map
object containing the 
parameter values. The keys in this map should be instances of the 
net.sf.jasperreports.engine.JRExporterParameter
class, as they are supplied 
when individually calling the 
setParameter()
method for each of the exporter 
parameters.
Note that no matter what type of output your exporter produces, you will be using 
parameters to indicate to the exporter where to place or send this output. Such parameters 
might be called OUT parameters. For example, if you want your exporter to send the 
output it produces to an output stream, supply the 
java.io.OutputStream
object 
reference to the exporter using a parameter, probably identified by the 
net.sf.jasperreports.engine.JRExporterParameter.OUTPUT_STREAM
constant.
P
AGE
234
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
PDF from RTF. Create PDF from Text. PDF Export. Convert PDF to Word (.docx). Convert PDF to Tiff. Convert PDF to HTML. Convert PDF to
edit pdf replace text; erase text from pdf
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
All the supported exporter parameters are identified by an instance of the 
net.sf.jasperreports.engine.JRExporterParameter
class or one of its 
subclasses. All have predefined constants that are used as keys to store and retrieve the 
parameter values from the internal map that each exporter uses behind the scenes to keep 
all parameter values. Each exporter can recognize and use its own parameters, but some 
predefined parameters are common to all exporters. These are identified by constants in 
the 
JRExporterParameters
base class. They are described in the following section.
E
XPORTER
I
NPUT
The input data for an exporter comes in the form of one or more 
JasperPrint 
documents that must be exported to some other document format. These 
JasperPrint 
objects may be already in memory, come from the network through an input stream, or 
reside in files on disk.
An exporter should be able to handle such a wide range of document sources. In fact, all 
the exporter implementations that are shipped inside the library already do this. They all 
extend the 
net.sf.jasperreports.engine.JRAbstractExporter
class, which 
holds all the logic for dealing with the source documents that need to be exported inside 
its defined 
setInput()
method.
B
ATCH
M
ODE
E
XPORT
The first thing an exporter needs to know is whether it is acting on a single 
JasperPrint
document or a list with several such generated documents. Exporting 
multiple 
JasperPrint
objects to a single resulting document is called batch mode 
exporting.
Not all exporters can work in batch mode, but those that do first look into the supplied 
parameter values to see whether a 
java.util.List
of 
JasperPrint
object has been 
supplied to them using the 
JASPER_PRINT_LIST
exporter parameter. If so, the exporter 
loops through this list of documents and produces a single document from them.
If the exporters act on a single document, then they check whether a value is supplied to 
the 
JASPER_PRINT
parameter, representing a single in-memory 
JasperPrint
document 
that must be exported. If no value is found for this parameter, then the input for the 
exporter is a single 
JasperPrint
document to be loaded from an input stream, an URL, 
a file object, or a file name. The exporter checks the following exporter parameters in 
this exact order, stopping at the first that has a non-null value: 
INPUT_STREAM
INPUT_URL
INPUT_FILE
, and 
INPUT_FILE_NAME
. If it does not find any of these 
parameters being set, then the exporter throws an exception telling the caller that no 
input source was set for the export process.
P
AGE
235
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
E
XPORTER
O
UTPUT
There are at least three types of exporters, depending on the type of output they produce:
 Exporters that export to text- or character-based file formats (HTML, RTF, CSV, 
TXT, and XML exporters)
 Exporters that export to binary file formats (PDF and XLS exporters)
 Exporters that export directly to graphic devices (
Graphics2D
and Java Print 
Service exporters)
The first two categories of exporters reuse generic exporter parameters for configuring 
their output. A text- or character-oriented exporter first looks into the 
OUTPUT_STRING_BUFFER
parameter to see whether it needs to output the text content it 
produces to a supplied 
java.lang.StringBuffer
object. If no value has been supplied 
for this parameter, then it will subsequently try to identify the output destination for the 
content by checking the following exporter parameters in this order: 
OUTPUT_WRITER
OUTPUT_STREAM
OUTPUT_FILE
, and 
OUTPUT_FILE_NAME
. If none of these OUT 
parameters have been set, then the exporter throws an exception to inform the caller.
A binary exporter uses similar logic to find the output destination for the binary content 
it produces. It checks generic exporter parameters in this exact order: 
OUTPUT_STREAM
OUTPUT_FILE
, and 
OUTPUT_FILE_NAME
.
Special exporters that do not produce character or binary output but rather render the 
document directly on a target device have special export parameters to configure their 
output. These special parameters are explained in the following sections.
When not working in batch mode, all exporters allow users to export only parts of the 
single document received as input. To export a single page or a range of pages from this 
source document, set the 
PAGE_INDEX
or the 
START_PAGE_INDEX
and the 
END_PAGE_INDEX
exporter parameters. Page indexes are zero-based, and 
PAGE_INDEX 
overrides both 
START_PAGE_INDEX
and 
END_PAGE_INDEX
if all are set for any given 
exporter.
The page content can be moved horizontally and vertically by using the 
OFFSET_X
and 
OFFSET_Y
parameters. This is useful especially for printing, when the page content 
doesn’t always fit with the printer page margins.
All text-based exporters except the RTF one (RTF is a 7-bit ASCII format) support the 
CHARACTER_ENCODING
exporter parameter, which can be used to force the encoding of 
the generated text files.
E
XPORTER
F
ILTERS
When exporting a report to any format, it is possible to filter the elements from the 
generated report by skipping elements that do meet a certain condition. This allows 
report designers to control what gets exported to each format. In many cases, it's not 
P
AGE
236
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
desirable to export all report sections and elements to all output formats; for instance, 
some visual report elements should only be displayed in output formats that are meant 
for on-screen viewing and not in other data-centric output formats.
JasperReports comes with two built-in filter implementations that cover the most 
frequent use cases. It also defines a set of interfaces that can be used to introduce other 
filter implementations. Custom export filter can be written by users to support specific 
filtering mechanisms.
When exporting a report, a filter can be explicitly specified using an export parameter, or 
a filter can be implicitly created based on the properties/export hints present in the report.
To explicitly specify an export filter, the export parameter 
FILTER
(accessible as a 
constant member of the 
net.sf.jasperreports.engine.JRExporterParameter 
class) should be used to pass a filter object, which would be an instance of a class that 
implements the 
net.sf.jasperreports.engine.export.ExporterFilter 
interface. The filter object can be of one the built-in export filter types, or of a custom 
filter implementation type.
When no value is set for the export filter parameter, the exporter will use a default filter 
factory to instantiate a filter that will be used for the export. The default filter factory 
class is set via a property named 
net.sf.jasperreports.engine.export.default.filter.factory
.
The built-in default filter factory implementation calls all registered filter factories and 
allows each of them to apply filters on the exporter report. If any of the filters decides to 
exclude an element, the element will be excluded from the export process. In most cases 
the built-in default filter factory provides the desired behavior. However users can 
choose to change it by setting another value for the default filter factory property.
To allow a custom export filter implementation to be used by the implicit export filter 
mechanism, one needs to register an export filter factory class with JasperReports. To do 
so, a property named 
net.sf.jasperreports.engine.export.filter.factory.<factory_name>
has 
to be included in the 
jasperreports.properties
file (or set at runtime via 
JRProperties
). The factory name is an arbitrary suffix, and the property value should 
be the name of a class that implements 
net.sf.jasperreports.engine.export.ExporterFilterFactory
. The engine 
uses the class name to instantiate an export filter factory, therefore the factory class 
needs to have an accessible no-argument constructor.
Each registered filter factory has the chance of producing a filter every time a report 
export occurs. The filter factory receives an object that contains information about the 
current export process, including the exporter report and a property prefix that 
corresponds to the exporter, and decides based on this information whether it applies to 
the current export or not. This would usually involve consulting custom properties of the 
exporter report to determine whether the report contains properties that indicate some 
filtering criteria. The recommended practice is to make the filter factory recognize 
P
AGE
237
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
properties that have a specific suffix appended to the exporter property prefix. For 
instance, the element key filter factory recognizes properties that have 
exclude.key 
appended after the exporter property prefix.
If the exporter factory decides that it applies to the current report, it needs to return a non 
null exporter filter, which is an instance of a class that implements 
net.sf.jasperreports.engine.export.ExporterFilter
. This filter will be 
applied to each element in the generated report and will be able to trigger the exclusion 
elements that match a given criteria.
Each exporter uses a different property prefix such that different filter criteria can be set 
for each exporter. The built-in exporters use property prefixes of the form 
net.sf.jasperreports.export.<output_format>
. The following table lists the 
property prefixes for the built-in exporters:
Output Format
Exporter
Property Prefix
Java Print/Graphics2D
JRGraphics2DExporter
JRPrintServiceExporter
net.sf.jasperreports.exp
ort.graphics2d
PDF
JRPdfExporter
net.sf.jasperreports.exp
ort.pdf
RTF
JRRtfExporter
net.sf.jasperreports.exp
ort.rtf
XML
JRXmlExporter
net.sf.jasperreports.exp
ort.xml
HTML
JRHtmlExporter
net.sf.jasperreports.exp
ort.html
XLSX
JRXlsExporter
JExcelApiExporter
JRXlsxExporter
net.sf.jasperreports.exp
ort.xls
OpenDocument Text
JROdtExporter
net.sf.jasperreports.exp
ort.odt
DOCX
JRDocxExporter
net.sf.jasperreports.exp
ort.docx
PPTX
JRPptxExporter
net.sf.jasperreports.exp
ort.pptx
OpenDocument 
Spreadsheet
JROdsExporter
net.sf.jasperreports.exp
ort.ods
CSV
JRCsvExporter
net.sf.jasperreports.exp
ort.csv
Text
JRTextExporter
net.sf.jasperreports.exp
ort.txt
XML Spreadsheet
JRXmlssExporter
net.sf.jasperreports.exp
ort.xmlss
Table 18-1. Exporter Filter Properties Prefixes
P
AGE
238
Documents you may be interested
Documents you may be interested