free pdf viewer c# : Copy highlighted text from pdf Library software class asp.net windows azure ajax JasperReports-Ultimate-Guide-37-part1366

T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
B
UILT
-I
N
F
UNCTIONS
When JasperReports was internationalized, some of the data and message-formatting 
logic was placed inside the engine itself to avoid forcing users to rely on external utility 
classes.
Report expressions can perform method calls on various objects that are available during 
report filling, such as parameters, fields, or variable values, but can also call methods on 
a special object that is already available as the 
this
reference. This is the calculator 
object presented in the previous section. It has public utility methods that are ready to 
use inside report expressions.
Currently, there are only a few utility methods of the calculator object available as built-
in functions inside report expressions. These are the following:
msg
: This function offers a convenient way to format messages based on the current 
report locale, just as you would normally do when using a 
java.text.MessageFormat
instance. Furthermore, several signatures for this 
function take up to three message parameters in order to make the formatting 
functionality easier to use.
str
: This function is the equivalent of the 
$R{}
syntax. It gives access to locale-
specific resources from the associated resource bundle.
C
ONDITIONAL
E
XPRESSIONS
As the Java language documentation states, an expression is a series of variables, 
operators, and method calls (constructed according to the syntax of the language) that 
evaluate to a single value.
So even if you rely on the Java language for writing report expressions, you cannot use 
Java statements like 
if else
for
, or 
while
.
However, quite often an expression must return a value that is calculated based on a 
condition or even multiple conditions. To accomplish this, use the conditional operator 
?:
. You can even nest this operator inside a Java expression to obtain the desired output 
based on multiple conditions.
The following text field displays 
No data
if the value for the 
quantity
field is 
null
:
<textFieldExpression>
$F{quantity} == null ? "No data" : String.valueOf($F{quantity})
</textFieldExpression>
P
AGE
59
Copy highlighted text from pdf - 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
extract highlighted text from pdf; delete text from pdf online
Copy highlighted text from pdf - 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
find and replace text in pdf file; c# get text from pdf
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
P
ARAMETERS
Parameters are object references that are passed into the report-filling operations. They 
are very useful for passing to the report engine data that it cannot normally find in its 
data source. 
For example, you could pass to the report engine the name of the user who launched the 
report-filling operation if you want it to appear on the report, or you could dynamically 
change the title of your report.
Listing 8-1 gives the JRXML syntax for the report parameters.
Listing 8-1. JRXML Syntax
<!ELEMENT parameter (property*, parameterDescription?, 
defaultValueExpression?)>
<!ATTLIST parameter
name NMTOKEN #REQUIRED
class CDATA #REQUIRED
isForPrompting (true | false) "true"
>
<!ELEMENT parameterDescription (#PCDATA)>
<!ELEMENT defaultValueExpression (#PCDATA)>
Declaring a parameter in a report template is very simple. Simply specify only its name 
and its class: 
<parameter name="ReportTitle" class="java.lang.String"/>
<parameter name="MaxOrderID" class="java.lang.Integer"/>
<parameter name="SummaryImage" class="java.awt.Image"/>
The supplied values for the report parameters can be used in the various report 
expressions, in the report SQL query, or even in a report scriptlet class. The following 
special sections of this book address each report expression, the query, and the scriptlets.
The following subsections describe the components that make a report parameter 
definition complete.
P
ARAMETER
N
AME
The 
name
attribute of the 
<parameter>
element is mandatory and allows referencing the 
parameter by its declared name. The naming conventions of JasperReports are similar to 
those of the Java language regarding variable declaration. That means that the parameter 
name should be a single word containing no special characters like a dot or a comma.
P
AGE
60
C# PDF Text Highlight Library: add, delete, update PDF text
etc. Able to remove highlighted text in PDF document in C#.NET. Support to change PDF highlight color in Visual C# .NET class. Able
copy text from locked pdf; extract text from pdf online
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
Text in any fonts, colors and sizes, or highlighted characters are easy to be converted to plain text. Text can be extracted from scanned PDF image with OCR
copy text from pdf in preview; extract text from pdf c#
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
P
ARAMETER
C
LASS
The second mandatory attribute for a report parameter specifies the class name for the 
parameter values. The class attribute can have any value as long it represents a class 
name that is available in the classpath both at report-compilation time and report-filling 
time.
P
ROMPTING
FOR
P
ARAMETER
V
ALUES
In some GUI applications, it is useful to establish the set of report parameters for which 
the application should request user input, before launching the report-filling process.
It is also useful to specify the text description that will prompt for the user input for each 
of those parameters.
This is why we have the Boolean 
isForPrompting
attribute in the parameter 
declaration sequence and the inner 
<parameterDescription>
element.
The following example shows the declaration of a text parameter, along with the 
description that could be used at runtime when requesting the user to input the parameter 
value, in a custom-made dialog window:
<parameter name="Comments" class="java.lang.String" 
isForPrompting="true">
<parameterDescription>
<![CDATA[
Please type here the report comments, if any
]]>
</parameterDescription>
</parameter>
Note the 
<![CDATA[
and 
]]>
character sequences that delimit the parameter description. 
Those are part of the XML-specific syntax that instructs the XML parser to not parse the 
text inside. This allows you to use special XML characters like the 
>
<
"
, and others in 
your texts. You’ll see this syntax used in other examples throughout this book and the 
samples.
P
ARAMETER
C
USTOM
P
ROPERTIES
In addition to the parameter description and the prompting flag mentioned previously, 
some applications might need to attach more information or metadata to a report 
parameter definition. This is now why report parameters can have any number of 
custom-defined name/value property pairs, just like the report template itself could have 
at the top level (see the “Custom Properties” section on page 48 for details).
P
AGE
61
VB.NET PDF Convert to Text SDK: Convert PDF to txt files in vb.net
Plain text can get from any fonts, colors and sizes, or highlighted characters. Text extraction from scanned PDF image with OCR component in VB.NET.
.net extract pdf text; export text from pdf
XDoc.HTML5 Viewer for .NET, All Mature Features Introductions
To help users quickly locate what you are looking for, all results will be highlighted with specific color. Annotate. Text Select, Copy & Paste.
extract pdf text to excel; export text from pdf to excel
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
P
ARAMETER
D
EFAULT
V
ALUE
Parameter values are supplied to the report-filling process packed in a 
java.util.Map 
object with the parameter names as the keys. This way, you are not obliged to supply a 
value for each parameter every time. 
If you do not supply a value for a parameter, its value is considered to be 
null
, unless 
you specify a default value expression in the report template for this particular report 
parameter. This expression is only evaluated if you don’t supply a value for the given 
parameter.
Here’s a 
java.util.Date
parameter whose value will be the current date if you do not 
supply a specific date value when filling the report:
<parameter name="MyDate" class="java.util.Date">
<defaultValueExpression>
new java.util.Date()
</defaultValueExpression>
</parameter>
In the default value expression of a parameter, you can only use previously defined 
report parameters.
B
UILT
-I
N
R
EPORT
P
ARAMETERS
Every report template contains some predefined report parameters, along with the ones 
that the report template creator decides to introduce. These built-in parameters are 
presented in the following subsections.
REPORT_PARAMETERS_MAP
This is a built-in parameter that will always point to the 
java.util.Map
object that 
contains the user-defined parameters passed when calling the report-filling process.
This parameter is especially useful when you want to pass to the subreports the same set 
of report parameters that the master report has received.
REPORT_CONNECTION
This report parameter points to the 
java.sql.Connection
object that was supplied to 
the engine for execution of the SQL report query through JDBC, if it is the case. It has a 
value different than 
null
only if the report (or subreport) has received a 
java.sql.Connection
when the report-filling process was launched and not a 
net.sf.jasperreports.engine.JRDataSource
instance.
This parameter is also useful for passing the same JDBC connection object that was used 
by the master report to its subreports. You can see this in action in the supplied subreport 
sample.
P
AGE
62
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
REPORT_DATA_SOURCE
When filling a report, a data source object is either directly supplied by the parent 
application or created behind the scenes by the reporting engine when a JDBC 
connection is supplied. This built-in parameter allows you access to the report’s data 
source in the report expressions or in the scriptlets.
REPORT_MAX_COUNT
You may want to limit the number of records from the report data source during the 
report-filling process. This built-in parameter accepts 
java.lang.Integer
values 
representing the number of records from the data source that the engine will process 
during the report filling. When the internal record counter reaches the specified value, 
the engine will assume that it has reached the last record from the data source and will 
stop the iteration through the rest of the data source.
REPORT_SCRIPTLET and [ScriptletName]_SCRIPTLET
There is a built-in parameter available for each scriptlet instance associated with the 
report or the dataset. The 
REPORT_SCRIPTLET
parameter points to the reports scriptlet 
specified using the s
criptletClass
attribute available at report or dataset level. For 
each of the scriptlet instances declared using the named scriptlet tag 
<scriptlet>
available at report or dataset level, there is a build-in parameter having the same name as 
the named scriptlet and the 
_SCRIPTLET
suffix.
Even if the report or dataset does not declare any scriptlet, the 
REPORT_SCRIPTLET 
built-in parameter will point to a 
net.sf.jasperreports.engine.JRAbstractScriptlet
instance, which in this case 
is a 
net.sf.jasperreports.engine.JRDefaultScriptlet
object. When using 
scriptlets, these built-in parameters referencing the scriptlet instances that are created 
when filling the report allow specific methods to be called on them. This is so the data 
that the scriptlet objects have prepared during the filling process can be used or 
manipulated. This is shown on the last page of the 
/demo/samples/scriptlet
sample 
report when a call is made to this scriptlet object. See “Scriptlets” on page 230 for more 
details about these parameters.
REPORT_LOCALE
Report templates can be reused to generate documents in different languages. The target 
language used during report filling is specified by the 
java.util.Locale
object 
supplied as the value for the 
REPORT_LOCALE
parameter. The engine uses 
Locale.getDefault()
if no value is explicitly supplied for this built-in parameter at 
runtime. 
More about this parameter can be found in ”Internationalization” on page 234.
P
AGE
63
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
REPORT_RESOURCE_BUNDLE
This parameter points to the 
java.util.ResourceBundle
object that contains 
localized information associated with the report template. This object can be supplied 
directly by the caller application or created by the engine using the resource bundle base 
name specified in the 
resourceBundle
property of the report template. The engine tries 
to read locale-specific information from this object based on the report-supplied locale 
and the key used inside the report expressions. More details about internationalization 
can be found in “Internationalization” on page 234.
REPORT_TIME_ZONE
The 
java.util.TimeZone
instance supplied as value for this built-in parameter is used 
during the report-filling process to format all date and time values. If no value is supplied 
for this parameter at runtime, the default time zone of the host machine is used.
REPORT_VIRTUALIZER
When very large reports are generated and memory becomes insufficient, the engine can 
rely on the report virtualization mechanism to optimize memory consumption during 
report filling. Report virtualization is activated by supplying an instance of the 
net.sf.jasperreports.engine.JRVirtualizer
interface as the value for the 
REPORT_VIRTUALIZER
built-in parameter. By doing this, the engine will store temporary 
data in a serialized form in order to minimize the amount of memory needed during 
report filling. Report virtualization is explained in the 6 Large files support chapter.
JASPER_REPORT
This parameter gives access to the current 
net.sf.jasperreports.engine.JasperReport 
template object that is being filled.
IS_IGNORE_PAGINATION
By default, JasperReports produces page-oriented documents that are ready for printing. 
Sometimes, especially in Web applications, pagination is irrelevant. One way to avoid 
breaking documents into multiple pages and to obtain a more flow-oriented document 
layout is to set this built-in parameter to 
Boolean.TRUE
at runtime. By doing this, the 
engine will ignore all the report settings that are related to page breaking and will 
produce a document that contains a single very large page.
When used, this fill-time parameter overrides the value of the 
isIgnorePagination 
property of the report template.
P
AGE
64
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
REPORT_CLASS_LOADER
Resources such as images, fonts, and subreports can be referenced using their relative 
classpath location. By default, JasperReports uses the current thread’s context class 
loader to locate the resource. If that fails, it then falls back to the class loader that loads 
the library’s classes themselves. To extend the resource-lookup mechanism and give 
greater flexibility to the library, you can pass a custom-made class loader implementation 
as the value for the 
REPORT_CLASS_LOADER
fill-time parameter. This would allow 
applications to load resources from repository locations that are not normally part of the 
overall application classpath. 
The equivalent export-time parameter is the 
CLASS_LOADER
exporter parameter. This is 
used by exporter implementations to look up lazy images or font files based on their 
classpath-relative location.
REPORT_URL_HANDLER_FACTORY
When images, fonts, and subreports templates are referenced using URLs, the program 
recognizes only some common protocols by default. File system–based and HTTP-based 
URLs that start with the 
file:
and 
http:
prefixes, respectively, work without need for 
any special configuration.
If custom-made protocols are required to locate and retrieve the resources, there is a need 
for a mechanism that associates an URL handler to a specific protocol. Java provides two 
such standard mechanisms (see the Javadoc for 
java.net.URL.URL(String 
protocol, String host, int port, String file)
). However, neither of the two 
solutions is possible in certain scenarios (for instance, when an web application deployed 
in Apache Tomcat needs to use custom URL handlers present in the application’s 
classpath). To work around this limitation, the JasperReports library has created its own 
alternative mechanism to associate URL handlers for custom URLs used as image, font, 
or subreport locations.
JasperReports provides several ways to register a 
java.net.URLStreamHandlerFactory
instance, either globally or locally:
 Globally, by calling 
JRResourcesUtil.setGlobalURLHandlerFactory()
 Locally, in the following ways:
*When filling a report, by setting the 
URLStreamHandlerFactory
instance as 
the value of the built-in 
REPORT_URL_HANDLER_FACTORY
parameter (the name 
of the parameter is accessible via the 
JRParameter.REPORT_URL_HANDLER_FACTORY
constant)
*When exporting a report, by using the 
JRExporterParameter.URL_HANDLER_FACTORY
export parameter
*By calling 
JRResourcesUtil.setThreadURLHandlerFactory()
directly
P
AGE
65
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
When a local/context or global URL handler factory is registered with JasperReports, the 
engine uses it (the local one takes precedence when both are registered) to obtain an 
URL handler while creating 
java.net.URL
instances from 
java.lang.String 
locations. When the location of a resource is specified as a 
java.lang.String
value, 
the engine will check whether the location begins with a protocol token followed by a 
colon (
:
) and whether the registered URL handler factory returns a valid URL handler 
for the specific protocol. If so, the URL handler will be used to create the 
java.net.URL
instance and to open the URL and read data from it.
This mechanism would mainly apply to the following cases:
 Report images can have custom URLs specified as a 
java.lang.String
location, 
for instance 
<imageExpression>"my_protocol://image_host/logo.jpg"</ 
imageExpression>
. (Note that the image source should not be a 
java.net.URL 
object.)
 Subreports can specify custom URLs as location.
 PDF fonts names can be defined as custom URLs.
Client code using the JasperReports APIs can also benefit from the mechanism by using 
methods of the 
JRResourcesUtil
or 
JRLoader
utility classes.
Therefore, when one or more custom URL protocols have to be used as locations for 
various report resources, you only need to write an implementation of 
java.net.URLStreamHandlerFactory
and make sure that the 
createURLStreamHandler(String protocol)
method returns non-null protocol 
handlers for each custom protocol.
REPORT_FORMAT_FACTORY
The value for this parameter is an instance of the 
net.sf.jasperreports.engine.util.FormatFactory
interface, which is either 
provided directly by the calling program or created internally by the reporting engine, 
using the 
formatFactoryClass
attribute of the report template. If this parameter is 
provided with a value by the report-filling process caller, it takes precedence over the 
attribute in the report template.
REPORT_TEMPLATES
java.util.Collection
containing 
JRTemplate
instances can be passed to the 
report at fill time using this built-in parameter. These templates add to the ones specified 
in the report template itself. In the final templates list, they are placed after the report 
templates, therefore styles from these templates can use and override styles in the report 
templates. However, they are placed before the report styles, hence report styles can use 
and override styles from these templates.
P
AGE
66
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
REPORT_FILE_RESOLVER
This parameter can be used to customize the way in which report resources (such as 
images or subreport templates) are resolved to local files.
By default, the engine interprets resource locations as file system paths that can are either 
absolute or relative to the current user directory (given by the Java 
user.dir
system 
property). If the path constructed this way resolves to an existing file, the report resource 
will be loaded from this file.
The default behavior can be changed by using the 
REPORT_FILE_RESOLVER
parameter at 
fill time to pass a file resolver object. The file resolver object needs to be an instance of a 
class that implements the 
net.sf.jasperreports.engine.util.FileResolver 
interface. The interface contains a single method which is responsible for resolving a 
resource location to an abstract file path (represented by a 
java.io.File
object).
When a file resolver is set via the report parameter, the engine will use it to interpret 
resource locations as file paths. If a file resolver returns a non-null file path for a 
resource location, the file located at the returned path will be used to load the resource.
JasperReports ships with a built-in file resolver implementation called 
net.sf.jasperreports.engine.util.SimpleFileResolver 
that interprets 
resource locations as paths relative to one or several file system folders. To create such a 
file resolver, the user has to specify one or more resources folders. When the resolver is 
asked to resolve a resource location, it interprets the locations as a path relative to each 
of the resource folders, and returns the first path that corresponds to an existing file.
D
ATA
S
OURCES
When filling the report, the JasperReports engine iterates through the records of the 
supplied data source object and generates every section according to the template defined 
in the report design.
Normally, the engine expects to receive a 
net.sf.jasperreports.engine.JRDataSource
object as the data source of the 
report that it has to fill. But as we shall see, another feature lets users supply a JDCB 
connection object instead of the usual data source object when the report data is found in 
a relational database.
The 
net.sf.jasperreports.engine.JRDataSource
interface is very simple. You 
implement only two methods:
public boolean next() throws JRException;
public Object getFieldValue(JRField jrField) throws JRException;
P
AGE
67
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
The 
next()
method is called on the data source object by the reporting engine when 
iterating through the data at report-filling time. The second method provides the value 
for each report field in the current data source record.
It is very important to know that the only way to retrieve data from the data source is by 
using the report fields. A data source object is more like a table with columns and rows 
containing data in the table cells. The rows of this table are the records through which the 
reporting engine iterates when filling the report and each column should be mapped to a 
report field, so that we can make use of the data source content in the report expressions.
There are several default implementations of the 
net.sf.jasperreports.engine.JRDataSource
interface, and we shall take a closer 
look to each of them.
JDBC D
ATA
S
OURCE
The 
net.sf.jasperreports.engine.JRResultSetDataSource
is a very useful 
implementation of the 
net.sf.jasperreports.engine.JRDataSource
interface 
because it wraps a 
java.sql.ResultSet
object. Since most reports are generated using 
data in relational databases, this is probably the most commonly used implementation for 
the data source interface.
Interestingly, you might end up using this implementation even if you do not instantiate 
this class yourself when filling your reports. This is what happens: if you specify the 
SQL query in your report template, the reporting engine executes the specified SQL 
query and wraps the returned 
java.sql.ResultSet
object in a 
net.sf.jasperreports.engine.JRResultSetDataSource
instance. The only thing 
the engine needs to execute the query is a 
java.sql.Connection
object. You supply 
this connection object instead of supplying the usual data source object. You can see this 
in such samples as 
jasper
scriptlet
subreport
, and 
query
, found under the 
/demo/samples
directory of the distributed package.
Of course, you could execute the SQL query in the parent application, outside 
JasperReports, if you want (or have) to. In this case, you could manually wrap the 
java.sql.ResultSet
obtained using an instance of this data source class before calling 
the report-filling process.
The most important thing to know when using this type of data source is that you must 
declare a report field for each column in the result set. The name of the report field must 
be the same as the name of the column it maps, as well as the data type.
If this is not possible for some reason, the data source also allows users to retrieve data 
from a particular column in the 
java.sql.ResultSet
by index. The report field that 
maps the specified column can be named 
COLUMN_x
, where 
x
is the one-based index of 
the result set column.
For maximum portability, as stated in the JDBC documentation, the values from a 
java.sql.ResultSet
object should be retrieved from left to right and only once. To 
P
AGE
68
Documents you may be interested
Documents you may be interested