free pdf viewer c# : Get text from pdf online software application dll windows html winforms web forms JasperReports-Ultimate-Guide-32-part1348

T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
java.io.Serializable
interface. This allows users to store their report templates as 
serialized objects either in their fully modifiable state (
JasperDesign
objects) or in their 
compiled form (
JasperReport
objects
).
For serializing objects to files or output streams, the JasperReports library offers a utility 
class named 
net.sf.jasperreports.engine.util.JRSaver
.
To load serialized objects, you can rely on the supplied 
net.sf.jasperreports.engine.util.JRLoader
utility class, which exposes various 
methods for loading objects from files, input streams, URLs, or classpath resources. This 
utility class has a method called 
loadObjectFromLocation(String location)
, with 
built-in logic to load a serialized object from a specified 
java.lang.String
location 
received as parameter. If this method is called, the program first tries to see if the 
specified location is a valid URL. If it is not, it then tries to determine whether the 
location points to an existing file on disk. If that also fails, the program tries to load the 
serialized object from the classpath using the specified location as a classpath resource 
name.
The library also exposes methods for parsing JRXML content into 
JasperDesign 
objects or for producing JRXML content out of a 
JasperDesign
or 
JasperReport 
object. 
The functionality is located in the following classes:
  
net.sf.jasperreports.engine.xml.JRXmlLoader
  
net.sf.jasperreports.engine.xml.JRXmlWriter
In certain cases in your application, you might want to manually load the JRXML report 
template into a 
net.sf.jasperreports.engine.design.JasperDesign
object 
without immediately compiling it. You might do this for applications that 
programmatically create report designs and use the JRXML form to store them 
temporarily or permanently.
You can easily load 
net.sf.jasperreports.engine.design.JasperDesign
objects 
from JRXML report designs by calling one of the public static 
load()
methods exposed 
by the 
net.sf.jasperreports.engine.xml.JRXmlLoader
class. This way, report 
design objects can be loaded from JRXML content stored in a database field or other 
input stream sources.
The library contains utility methods for parsing JRXML into report design objects and 
vice versa. You can generate JRXML from an in-memory report design object.
As shown, sometimes report designs are generated automatically using the JasperReports 
API. Report design objects obtained this way can be serialized for disk storage or 
transferred over the network, but they also can be stored in JRXML format.
P
AGE
9
Get text from pdf online - 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 text from encrypted pdf; export highlighted text from pdf to word
Get text from pdf online - 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
a pdf text extractor; copy highlighted text from pdf
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
You can obtain the JRXML representation of a given report design object by using one 
of the public static 
writeReport()
methods exposed by the 
net.sf.jasperreports.engine.xml.JRXmlWriter
utility class.
C
OMPILING
R
EPORT
T
EMPLATES
Source report templates, created either by using the API or by parsing JRXML files, are 
subject to the report compilation process before they are filled with data.
This is necessary to make various consistency validations and to incorporate into these 
report templates data used to evaluate all report expressions at runtime.
The compilation process transforms 
net.sf.jasperreports.engine.design.JasperDesign
objects into 
net.sf.jasperreports.engine.JasperReport
objects. Both classes are 
implementations of the same basic 
net.sf.jasperreports.engine.JRReport 
interface. However, 
JasperReport
objects cannot be modified once they are produced, 
while 
JasperDesign
objects can. This is because some modifications made on the 
report template would probably require re-validation, or if a report expression is 
modified, the compiler-associated data stored inside the report template would have to be 
updated.
JasperDesign
objects are produced when parsing JRXML files using the 
net.sf.jasperreports.engine.xml.JRXmlLoader
or created directly by the parent 
application if dynamic report templates are required. The GUI tools for editing 
JasperReports templates also work with this class to make in-memory modifications to 
the report templates before storing them on disk.
JasperDesign
object must be subject to the report compilation process to produce a 
JasperReport
object. 
Central to this process is the 
net.sf.jasperreports.engine.design.JRCompiler 
interface, which defines two methods, one being the following:
public JasperReport compileReport(JasperDesign design) throws 
JRException;
There are several implementations for this compiler interface depending on the language 
used for the report expressions or the mechanism used for their runtime evaluation.
E
XPRESSIONS
S
CRIPTING
L
ANGUAGE
The default language for the report expressions is Java (see the discussion of the 
language
property in “Report Template Properties” on page 42), but report expressions 
can be written in Groovy, JavaScript or any other scripting language as long as a report 
compiler implementation that can evaluate them at runtime is available.
P
AGE
10
C# PDF insert text Library: insert text into PDF content in C#.net
String inputFilePath = Program.RootPath + "\\" 1.pdf"; PDFDocument doc = new PDFDocument(inputFilePath); // get a text manager from the document
extract text from pdf using c#; extract text from image pdf file
VB.NET PDF Annotate Library: Draw, edit PDF annotation, markups in
with a great .NET solution to annotate .pdf file with both text & graphics. From this page, you will get a simple VB.NET online PDF annotation tutorial.
delete text from pdf preview; get text from pdf c#
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
JasperReports currently ships report compiler implementations for the Groovy
scripting 
language (http://groovy.codehaus.org), JavaScript
(http://www.mozilla.org/rhino), and 
the BeanShell
scripting library (http://www.beanshell.org). The compiler implementation 
classes are:
  
net.sf.jasperreports.compilers.JRGroovyCompiler
net.sf.jasperreports.compilers.JavaScriptCompiler
net.sf.jasperreports.compilers.JRBshCompiler
Historically, these compiler implementations used to be shipped as separate samples, but 
now they are part of the core library.
For more details about those report compilers, check the 
/demo/samples/beanshell
, /
demo/samples/groovy
and the 
/demo/samples/javascript
samples distributed with the project source files.
R
EPORT
C
OMPILERS
The report templates can be compiled using the desired report compiler implementation 
by instantiating it and calling the 
compileReport()
method mentioned previously.
Since the most common scenario is to use the Java language for writing report 
expressions, default implementations of the report compiler interface are shipped with 
the library and are ready to use. They generate a Java class from the report expressions 
and store bytecode in the generated 
net.sf.jasperreports.engine.JasperReport 
object for use at report-filling time.
The Java report compilers come in different flavors depending on the Java compiler used 
to compile the class that is generated on the fly:
net.sf.jasperreports.engine.design.JRJdtCompiler
net.sf.jasperreports.engine.design.JRJdk13Compiler
net.sf.jasperreports.engine.design.JRJdk12Compiler
net.sf.jasperreports.engine.design.JRJavacCompiler
net.sf.jasperreports.engine.design.JRJikesCompiler
To simplify the report-compilation process, the JasperReports API offers a facade class 
(
net.sf.jasperreports.engine.JasperCompileManager
) for compiling reports. 
This class has various public static methods for compiling report templates that come 
from files, input streams, or in-memory objects. The facade class relies the report 
template language to determine an appropriate report compiler.
The report compilation facade first reads a configuration property called 
net.sf.jasperreports.compiler.<language>
to determine whether a compiler 
implementation has been configured for the specific report language. If such a property 
is found, its value is used as compiler implementation class name and the facade 
P
AGE
11
VB.NET PDF insert text library: insert text into PDF content in vb
Dim inputFilePath As String = Program.RootPath + "\\" 1.pdf" Dim doc As PDFDocument = New PDFDocument(inputFilePath) ' get a text manager from the
copy text from pdf reader; copy paste text pdf
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
NET framework application with trial SDK components and online C# class users are able to extract image from PDF document page and get image information
extract text from pdf image; copy text from protected pdf
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
instantiates a compiler object and delegates the report compilation to it. By default, 
JasperReports includes configuration properties that map the Groovy, JavaScript and 
BeanShell report compilers to the 
groovy
javascript
and 
bsh
report languages, 
respectively.
If the report uses Java as language and no specific compiler has been set for this 
language, the report compilation facade employs a built-in fall back mechanism that 
picks the best Java-based report compiler available in the environment in which the 
report compilation process takes place.
The 
net.sf.jasperreports.engine.design.JRDefaultCompiler
first reads the 
configuration property called 
net.sf.jasperreports.compiler.class
to allow 
users to override its built-in compiler-detection logic by providing the name of the report 
compiler implementation to use directly. More on configuration properties for 
customizing report compilation can be found later in this chapter.
This facade first tries to see if the JDT compiler from the Eclipse Foundation is available 
in the application’s classpath. If it is, the 
net.sf.jasperreports.engine.design.JRJdtCompiler
implementation is used. 
The current JasperReports distribution ships the JDT compiler packed in the 
/lib/jdt-
compiler.jar
file.
If the JDT compiler is not available, the compilation facade then tries to locate the JDK 
1.3–compatible Java compiler from Sun Microsystems. This is normally found in the 
tools.jar
file that comes with the JDK installation.
If the JDK 1.3–compatible Java compiler is not in the classpath, the fall back search 
mechanism looks for the JDK 1.2–compatible Java compiler, also from Sun 
Microsystems, in case the application is running in an environment that has a JDK 
version prior to 1.3 installed. This is also found in the 
tools.jar
file from the JDK 
installation.
If all these fail, the last thing the fall back mechanism does is to try to launch the 
javac.exe
program from the command line in order to compile the temporarily 
generated Java source file on the fly.
A B
RIEF
H
ISTORY
OF
R
EPORT
C
OMPILATION
All these report compiler implementations are included for historical reasons. In the 
beginning, JasperReports started with only the JDK 1.2–compatible report compiler. 
Then the JDK 1.3–compatible report compiler was introduced. But both were slow. This 
is why the 
net.sf.jasperreports.engine.design.JRJikesCompiler
was created, 
because the Jikes compiler proved to be up to ten times faster than the JDK-based Java 
compiler.
However, compiling reports on the fly (in the cases in which dynamic report templates 
were required) proved to be problematic, especially in a web environment, because all 
the aforementioned compilers worked only with files on disk and required a temporary 
P
AGE
12
C# PDF Annotate Library: Draw, edit PDF annotation, markups in C#.
box to PDF and edit font size and color in text box field using RasterEdge.XDoc.PDF; Note: When you get the error "Could not load file or assembly 'RasterEdge
copy and paste text from pdf to excel; copy pdf text with formatting
VB.NET PDF: Get Started with PDF Library
C#.NET rotate PDF pages, C#.NET search text in PDF Viewer, C# Online Dicom Viewer, C# Online Jpeg images VB.NET PDF: Get Started with .NET PDF Library Using VB.
export text from pdf to excel; c# extract pdf text
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
working directory to store the generated Java source files and the corresponding class 
files during the report-compilation process. This is why a new implementation was added
—one that relied on the BeanShell library for runtime expression evaluation. BeanShell 
does not produce Java bytecode and can work with in-memory scripts that it interprets at 
runtime. With the 
net.sf.jasperreports.engine.design.JRBshCompiler
deployment was simpler, but expression evaluation was slower and loss in performance 
was noticeable.
The addition of the JDT-based report compiler makes the whole process both faster and 
simpler to deploy, as it does not require files on disk and its performance is comparable 
to Jikes. Runtime report compilation is not an issue anymore, and simply putting the 
supplied 
/lib/jdt-compiler.jar
file in the application’s classpath allows dynamic 
report template creation without requiring any further settings.
C
ONFIGURATION
P
ROPERTIES
TO
C
USTOMIZE
R
EPORT
C
OMPILATION
Because it is a library, JasperReports offers various mechanisms for letting users 
customize its behavior. One of these mechanisms is a complete set of configuration 
properties. The following paragraphs list all the configuration properties that customize 
report compilation. You can learn more about how JasperReports can be configured in 
“Configuration Files” on page 272.
net.sf.jasperreports.compiler.xml.<LANGUAGE>
Such properties are used for indicating the name of the class that implements the 
JRCompiler
interface to be instantiated by the engine for a specific report language 
when the default compilation is used through the 
JasperCompileManager
facade The 
value for such a configuration property can be the name of one of the built-in 
implementations of this interface shipped with the library as listed previously, or the 
name of a custom-made implementing class.
One can configure report compilers for custom report languages and override the default 
compiler mappings by setting JasperReports properties of the form 
net.sf.jasperreports.compiler.<language>
to the desired compiler 
implementation class names. In particular, the mechanism that automatically chooses a 
Java report compiler can be superseded by explicitly setting the 
net.sf.jasperreports.compiler.java
property to the name of one of the built-in 
Java compiler classes or of a custom compiler implementation class.
Note that the classes implementing the 
JRCompiler
interface can also be used directly in 
the programs without having to call them through the facade 
JasperCompilerManager 
class.
P
AGE
13
C#: Use OCR SDK Library to Get Image and Document Text
C#: Use OCR SDK Library to Get Image and Document Text. C#.NET Online Tutorial for How to Extract Text from Tiff, Jpeg, Png, Gif, Bmp, and Scanned PDF Files.
.net extract text from pdf; how to copy and paste pdf text
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
Security PDF component download. Online source codes for quick evaluation in VB.NET class. You can easily get pages from a PDF file, and then use these
can't copy text from pdf; copy pdf text to word document
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
net.sf.jasperreports.compiler.xml.validation
This was formerly known as the 
jasper.reports.compile.xml.validation
system 
property.
The XML validation, which is on by default, can be turned off by setting the 
net.sf.jasperreports.compiler.xml.validation
configuration property to 
false
. When turned off, the XML parser no longer validates the supplied JRXML 
against its associated XSD. This might prove useful in some environments, although it is 
not recommended.
When working with a Java class generating the type of a report compiler, further 
customizations can be made using the following system properties, which only apply to 
them.
net.sf.jasperreports.compiler.classpath 
Formerly known as the 
jasper.reports.compile.class.path
system property, this 
supplies the classpath. JDK-based and Jikes-based compilers require that the classpath be 
supplied as a parameter. They cannot use the current JVM classpath. The supplied 
classpath resolves class references inside the Java code they are compiling.
This property is not used by the JDT-based report compiler, which simply uses the parent 
application’s classpath during Java source file compilation.
net.sf.jasperreports.compiler.temp.dir 
This was formerly known as the 
jasper.reports.compile.temp
system property.
The temporary location for the files generated on the fly is by default the current working 
directory. It can be changed by supplying a value to the 
net.sf.jasperreports.compiler.temp.dir
configuration property. This is used by 
the JDT-based compiler only when it is requested that a copy of the on-the-fly generated 
Java class be kept for debugging purposes as specified by the next configuration 
property, because normally this report compiler does not work with files on disk.
net.sf.jasperreports.compiler.keep.java.file 
This was formerly known as the 
jasper.reports.compile.keep.java.file
system 
property.
Sometimes, for debugging purposes, it is useful to have the generated 
*.java
file or 
generated script in order to fix compilation problems related to report expressions. By 
default, the engine deletes this file after report compilation, along with its corresponding 
*.class
file. To keep it, however, set the configuration property 
net.sf.jasperreports.compiler.keep.java.file
to 
true
.
P
AGE
14
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
JDT C
OMPILER
–S
PECIFIC
C
ONFIGURATION
P
ROPERTIES
The 
JRJdtCompiler
report compiler can use special JasperReports configuration 
properties to configure the underlying JDT Java compiler. This report compiler collects 
all the JasperReports configuration properties (the ones usually set in the 
jasperreports.properties
file) that start with the 
org.eclipse.jdt.core.
prefix 
and passes them to the JDT Java compiler when compiling the generated Java class to 
evaluate report expressions.
One of the uses of this mechanism is to instruct the JDT compiler to observe Java 1.5 
code compatibility. To do so, the following properties should be set:
org.eclipse.jdt.core.compiler.source=1.5
org.eclipse.jdt.core.compiler.compliance=1.5
org.eclipse.jdt.core.compiler.codegen.TargetPlatform=1.5
This is demonstrated in the 
/demo/samples/java1.5
sample distributed with 
JasperReports. 
A
NT
T
ASKS
When the number of different report files that one has to deal with in a project is 
significant, there is a need for automating repeating or re-occurring tasks that are to be 
performed on those files.
From a design point of view, the most notable operation that needs to be performed on 
report source files after they are finished and ready to be deployed is the report 
compilation. Sometimes reports need to be decompiled in order to reproduce  their 
corresponding source files and perform additional design work on them, or when the 
same modification needs to be performed identically on all reports.
For these re-occurring tasks, JasperReports provides built-in ready-to-use Ant task 
definitions.
A
NT
T
ASKS
FOR
C
OMPILING
R
EPORTS
Since report template compilation is more like a design-time job than a runtime one, a 
custom Ant task has been provided with the library to simplify application development.
This Ant task is implemented by the 
net.sf.jasperreports.ant.JRAntCompileTask
class. Its syntax and behavior are 
very similar to the built-in 
<javac>
Ant task.
The report template compilation task can be declared like this, in a project’s 
build.xml 
file:
P
AGE
15
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
<taskdef name="jrc" 
classname="net.sf.jasperreports.ant.JRAntCompileTask"> 
<classpath>
<fileset dir="./lib">
<include name="**/*.jar"/>
</fileset>
</classpath>
</taskdef>
In the preceding example, the 
lib
should contain the 
jasperreports-x.x.x.jar
file 
along with its other required libraries.
You can then use this user-defined Ant task to compile multiple JRXML report template 
files in a single operation by specifying the root directory that contains those files or by 
selecting them using file patterns.
A
TTRIBUTES
OF
THE
R
EPORT
T
EMPLATE
C
OMPILATION
T
ASK
Following is the list of attributes that can be used inside the Ant report compilation task 
to specify the source files, the destination directory, and other configuration properties:
srcdir
: Location of the JRXML report template files to be compiled. Required unless 
nested 
<src>
elements are present.
destdir
: Location to store the compiled report template files (the same as the source 
directory by default).
compiler
: Name of the class that implements the 
net.sf.jasperreports.engine.design.JRCompiler
interface to be used for 
compiling the reports (optional).
xmlvalidation
: Flag to indicate whether the XML validation should be performed on 
the source report template files (
true
by default).
tempdir
: Location to store the temporarily generated files (the current working directory 
by default).
keepjava
: Flag to indicate if the temporary Java files generated on the fly should be kept 
and not deleted automatically (
false
by default).
The report template compilation task supports nested 
<src>
and 
<classpath> 
elements, just like the Ant 
<javac>
built-in task.
To see this in action, check the 
/demo/samples/antcompile
sample provided with the 
project’s source files.
P
AGE
16
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
A
NT
T
ASK
FOR
D
ECOMPILING
R
EPORTS
Sometimes it happens that report templates are to be found only in their compiled form. 
The source report template files might have been lost and we might have only  the 
compiled report template on which we need to make some modifications.
In such cases, the Ant task for decompiling report template files that JasperReports 
provides becomes very handy. It is implemented by the 
net.sf.jasperreports.ant.JRAntDecompileTask
class and its declaration inside a 
build.xml
should be as follows:
<taskdef name="jrdc"
classname="net.sf.jasperreports.ant.JRAntDecompileTask"> 
<classpath refid="classpath"/>
</taskdef>In the above example, the classpath should contain the 
jasperreports-x.x.x.jar file along with its other required 
libraries.
This task works similarly to the report compilation task, but it does the reverse operation. 
The files to be decompiled can be specified using the 
srcdir
attribute for their root 
folder or, for more sophisticated file match patterns, a nested 
<src>
tag.  The output 
folder for the generated files is specified using the 
destdir
attribute. 
This task is demonstrated in the 
/demo/samples/antcompile
sample provided with 
the project source files.
A
NT
T
ASK
FOR
U
PDATING
R
EPORTS
Although JasperReports always guarantees backward compatibility of report templates 
when upgrading to a newer version, sometimes tags or attributes in JRXML are 
deprecated and replaced with newer ones that offer enhanced capabilities. So while the 
deprecated attributes and tags still work, it is always advisable to use the latest syntax 
and thus get rid of the deprecation warnings.
Upgrading a report template to the latest JasperReports syntax is very easy; all that needs 
to be done is to load the report and save it again using the API's utility classes, such as 
the 
JRXmlLoader
or 
JRLoader
and the 
JRXmlWriter
.
This operation can be automated for any number of files using the Ant report update task 
provided by the JasperReports library in the 
net.sf.jasperreports.ant.JRAntUpdateTask
class, which should have the 
following definition in a 
build.xml
file:
<taskdef name="jru" 
classname="net.sf.jasperreports.ant.JRAntUpdateTask"> 
<classpath refid="classpath"/> 
</taskdef> 
P
AGE
17
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
This task is useful also in situations where the same modification needs to be applied on 
a number of different report files. The required modifications can be performed using the 
JasperReport API after the report design object has been loaded but before it is saved 
again. 
Custom implementations of the 
net.sf.jasperreports.engine.util.ReportUpdater
interface can be registered 
with the Ant report update task using nested 
<updater>
tags, as seen in the 
/demo/samples/antupdate
sample provided with the project.
P
AGE
18
Documents you may be interested
Documents you may be interested