free pdf viewer c# : Copy pdf text to word control application system azure web page .net console JasperReports-Ultimate-Guide-38-part1367

T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
ensure that they work this way, consider declaring the report fields in the same order as 
they appear in the SQL query.
BLOB and CLOB Support
When the SQL query retrieves data from table columns that have large binary or large 
char data types and are mapped to 
java.sql.Blob
and 
java.sql.Clob
values through 
JDBC, the current data source implementation tries to simplify the data by using 
intelligent field mapping.
For instance, in most cases, BLOB columns are used to store images in the database that 
the application might need to use inside a report. If the report field that maps a given 
BLOB column from the 
java.sql.ResultSet
is of type 
java.awt.Image
, the data 
source will try to read from the 
java.sql.Blob
instance and load an image object using 
java.awt.MediaTracker
.
Or, if very large chunks of text are stored in large character columns inside the database, 
then the data source will try to read the text from the database and load it in 
java.lang.String
objects, in case the corresponding report field was declared as 
being of type 
String
.
The supported mappings are as follows:
 BLOB: 
java.sql.Blob
java.io.InputStream
, and 
java.awt.Image
 CLOB: 
java.sql.Clob
java.io.InputStream
java.io.Reader
, and 
java.lang.String
J
AVA
B
EANS
D
ATA
S
OURCES
The library is shipped with two data source implementations that can wrap collections or 
arrays of JavaBean objects. Both implementations rely on Java reflection to retrieve 
report field data from the JavaBean objects wrapped inside the data sources. These data 
sources can be used to generate reports using data already available in-memory in the 
form of EJBs, Hibernate, JDO objects, or even POJOs.
The 
net.sf.jasperreports.engine.data.JRBeanArrayDataSource
is for 
wrapping an array of JavaBean objects to use for filling a report with data, and the 
net.sf.jasperreports.engine.data.JRBeanCollectionDataSource
is for 
wrapping a collection of JavaBeans. Each object inside the array or the collection will be 
seen as one record in this type of data source. 
The mapping between a particular JavaBean property and the corresponding report field 
is made by naming conventions. The name of the report field must be the same as the 
name of the JavaBean property as specified by the JavaBeans specifications. 
For instance, to retrieve the value of a report field named 
productDescription
, the 
program will try to call through reflection a method called 
getProductDescription() 
on the current JavaBean object.
P
AGE
69
Copy pdf text 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 text from scanned pdf to word; extract text from image pdf file
Copy pdf text 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
copying text from pdf into word; copying text from pdf to excel
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
Note that the current implementations rely on the Jakarta Commons BeanUtils library to 
retrieve JavaBean property values, so check their documentation to see how you can use 
nested JavaBean properties with report fields.
Let’s say that the current JavaBean object inside the data source is of type 
Product
and 
contains nested supplier information accessible by calling the 
getSupplier()
method, 
which returns a 
Supplier
object. In this case, you could have a report field that maps to 
the supplier’s address if it is called 
supplier.address
.
Note that in the past, report fields did not accept dots, spaces, or other special characters 
in their names. Therefore, to access nested JavaBean properties, the data source relied on 
the field’s description, if present, to identify the property, because dots might appear 
inside the field’s description. For backward-compatibility reasons, the current 
implementations still look into the field’s description first, by default. If there is no 
description, then the report field name is used for locating the JavaBean property. If this 
default behavior is not desirable, especially if the field description is already used for 
other purposes, you can use special data source constructors that receive a flag called 
isUseFieldDescription
to suppress this behavior.
A special field mapping can be used to access the current JavaBean object itself. Thus, 
when a field uses 
_THIS
as description or name, the data source will return the current 
JavaBean object as field value. This is useful when the report needs to extract from the 
current object some data that does not correspond to a property that follows JavaBeans 
standards (for instance, the data is returned by a method that takes some arguments), or 
when the current object needs to be passed to as argument to a method called in one of 
the report expressions.
The JavaBeans data source implementation contain few methods that are useful in 
certain cases:
 The 
getData()
method returns the underlying bean collection or array used by the 
data source.
 The 
getRecordCount()
method returns the total number of beans contained in the 
collection or array used by the data source.
 The 
cloneDataSource()
method returns a copy of data source by creating a fresh 
data source that uses the same underlying JavaBeans collection or array.
You can use the last method, for instance, when a master report contains a subreport that 
needs to iterate on the same JavaBeans collection as the master. In this case, the 
subreport would use the following data source expression:
<dataSourceExpression>((net.sf.jasperreports.engine.data.JRBeanColl
ectionDataSource) 
$P{REPORT_DATA_SOURCE}).cloneDataSource()</dataSourceExpression>
P
AGE
70
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
Ability to copy selected PDF pages and paste into The portable document format, known as PDF document, is a they are using different types of word processors.
get text from pdf online; c# extract text from pdf
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
Extract, Copy, Paste PDF Pages. |. Home ›› XDoc.PDF ›› VB.NET PDF: Copy and Paste PDF Page. Ability to copy PDF pages and paste into another PDF file.
copy and paste text from pdf to word; cut text pdf
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
M
AP
-B
ASED
D
ATA
S
OURCES
JasperReports is shipped with two data source implementations that can wrap arrays or 
collections of 
java.util.Map
objects. 
The 
net.sf.jasperreports.engine.data.JRMapArrayDataSource
wraps an array 
of 
Map
objects, and 
net.sf.jasperreports.engine.data.JRMapCollectionDataSource
can be used 
to wrap a 
java.util.Collection
of 
Map
objects.
These implementations are useful if the parent application already stores the reporting 
data available in-memory as 
Map
objects. Each 
Map
object in the wrapped array or 
collection is considered a virtual record in the data source, and the value of each report 
field is extracted from the map using the report field name as the key.
Map-based data source implementations contain the same set of utility methods as 
JavaBeans data sources (described in the previous section): 
getData()
to access the underlying map collection or array
getRecordCount()
to return the total number of maps/records
cloneDataSource()
to create a fresh copy of the data source
T
ABLE
M
ODEL
D
ATA
S
OURCE
In some Swing-based desktop client applications, the reporting data might already be 
available in the form of a 
javax.swing.table.TableModel
implementation used for 
rendering 
javax.swing.JTable
components on various forms. JasperReports can 
generate reports using this kind of data if a given 
javax.swing.table.TableModel 
object is wrapped in a 
net.sf.jasperreports.engine.data.JRTableModelDataSource
instance before 
being passed as the data source for the report-filling process.
There are two ways to use this type of data source. Normally, to retrieve data from it, 
you must declare a report field for each column in the 
javax.swing.table.TableModel
object bearing the same name as the column it 
maps. Sometimes it is not possible or desirable to use the column name, however, 
because the report field name and columns could still be bound to report fields using 
their zero-based index instead of their names.
For instance, if you know that a particular column is the third column in the table model 
object (
index=2
), then you could name the corresponding field 
"COLUMN_2"
and use the 
column data without problems.
An example is provided in the 
/demo/samples/datasource
sample.
P
AGE
71
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
VB.NET Tutorial for How to Convert PDF to Word (.docx) Document in VB.NET. using RasterEdge.XDoc.PDF; Convert PDF to Word Document in VB.NET Demo Code.
copy pdf text to word; extract text from pdf to excel
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
PDF ›› C# PDF: Extract PDF Image. How to C#: Extract Image from PDF Document. Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document.
can't copy and paste text from pdf; get text from pdf file c#
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
XML D
ATA
S
OURCES
XML documents can be used as report data sources by means of a data source 
implementation. JasperReports features a built-in XML data source implementation 
(
net.sf.jasperreports.engine.data.JRXmlDataSource
) that is based on DOM 
and uses XPath expressions to select data from the XML document.
An XML data source instantiation involves the following inputs:
 An XML document. The parsed document, its location, or its source is provided as 
an argument to the data source constructor.
 An XPath expression to select the node set that corresponds to the data source 
record list. The expression is passed to the data source as a constructor argument. 
The default XPath expression selects the document node itself; in this case the data 
source would produce a single record. The XPath expression is executed when the 
data source is instantiated; each item in the resulting node set will generate a 
record/row in the data source.
 For every field in the report/data set, an XPath expression to select the field value 
for each record. The field’s XPath expression is provided by the field description 
(
<fieldDescription>
element in JRXML). The field’s XPath expression is 
executed for each record using as a context node the current node from the main 
node set.
An XML data source can be used create sub–data sources to be used for subreports or 
subdatasets. There are two methods of creating a sub–data source from a parent XML 
data source:
 A sub–data source can be created for a new document that uses the current node as 
a root node. An XPath expression can additionally be specified to select the list of 
nodes for the sub–data source. The 
subDataSource()
and 
subDataSource(String selectExpression)
methods should be used to create 
sub–data sources in this scenario.
 The same document can be reused for a new sub–data source, which would specify 
a different XPath expression for the main node set. This can be accomplished via 
dataSource()
and 
dataSource(String selectExpression)
methods calls.
Note
The built-in XML data source is a generic implementation that is very flexible due to the power of XPath 
and hence convenient in many cases. However, especially when dealing with large XML documents, this 
implementation might not perform optimally because DOM would require large amounts of heap space for the in-
memory document, and XPath expression evaluations would cause slower data processing speeds. In such 
cases, custom data source implementations that use SAX or other stream parser mechanisms to process specific 
XML documents would significantly increase the performance.
To illustrate the preceding concepts, consider the following XML document:
P
AGE
72
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
VB.NET PDF - Extract Image from PDF Document in VB.NET. Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document in VB.NET Project.
copying text from pdf to word; erase text from pdf file
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
A convenient C#.NET control able to turn all Word text and image content into high quality PDF without losing formatting. Convert
delete text from pdf with acrobat; extract text from pdf acrobat
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
<CompanyData>
<Info>
<Reference>123</Reference>
</Info>
<Customer ID="ALFKI">
<CompanyName>Alfreds Futterkiste</CompanyName>
<Address>Obere Str. 57</Address>
<Phone type="Fixed">075-5554321</Phone>
<Phone type="Mobile">030-0074321</Phone>
<Order>
<OrderID>10248</OrderID>
<OrderDate>1996-07-04</OrderDate>
</Order>
<Order>
<OrderID>10249</OrderID>
<OrderDate>1996-07-05</OrderDate>
</Order>
</Customer>
<Customer ID="ANATR">
<CompanyName>Ana Trujillo Emparedados y helados</CompanyName>
<Address>Avda. de la Constitución 2222</Address>
<Phone type="Fixed">(5) 555-4729</Phone>
<Order>
<OrderID>10242</OrderID>
<OrderDate>1996-07-01</OrderDate>
</Order>
</Customer>
</CompanyData>
To create a data source that iterates the 
Customer
nodes, you could use the following:
new JRXmlDataSource(document, "/CompanyData/Customer")
Possible field mappings would be as follows:
@ID
: Map the 
ID
attribute of the current 
Customer
node.
CompanyName
: Map the value of the 
CompanyName
child node of the current node.
Phone[@type = "Fixed"]
: Map the fixed phone number of the current customer.
/CompanyData/Info/Reference
: Absolute XPath expressions are also possible; 
the field would yield the same value for each record.
To create a sub–data source that iterates on the 
Order
nodes under the current 
Customer 
node, the following expression could be used as a subreport data source:
((JRXmlDataSource) 
$P{REPORT_DATA_SOURCE}).subDataSource("/Customer/Order")
To create a sub–data source that only includes the 
Info
node, you could use the 
following:
P
AGE
73
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
key. Quick to remove watermark and save PDF text, image, table, hyperlink and bookmark to Word without losing format. Powerful components
copy and paste text from pdf; extract text from pdf java open source
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Convert PDF to SVG. Convert PDF to Text. Convert PDF to JPEG. Convert PDF to Png, Gif Page: Replace PDF Pages. Page: Move Page Position. Page: Copy, Paste PDF
copy text from pdf to word; copy formatted text from pdf
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
((JRXmlDataSource) 
$P{REPORT_DATA_SOURCE}).dataSource("/CompanyData/Info")
Jaxen as XPath interpreter
XML data sources work by interpreting XPath expressions and selecting nodes and 
values from the XML document based on these expressions. This functionality related to 
XPath processing has been extracted into a generic service interface called 
net.sf.jasperreports.engine.util.xml.JRXPathExecuter
.
The XPath executer implementation used by XML data sources can be configured via a 
JasperReports property named 
net.sf.jasperreports..xpath.executer.factory
This property gives the name of a XPath executer factory class, which has to implement 
the 
net.sf.jasperreports..engine.util.xml.JRXPathExecuterFactory
..
JasperReports includes two built-in XPath executer implementations, one based on 
Apache Xalan (
http://xml.apache.org/xalan-j/
) and the second on Jaxen 
(
http://jaxen.codehaus.org/
). The Xalan-based implementation is used by default 
for backward compatibility reasons.
In many cases, though, the Jaxen XPath executor provides better performance than an 
executor that uses Xalan. To switch to the Jaxen XPath executer, one needs to set the 
net.sf.jasperreports.xpath.executer.factory
. property to 
net.sf.jasperreports.engine.util.xml.JaxenXPathExecuterFactory
, which 
is usually done by including the following line in the 
jasperreports.properties 
configuration file:
net.sf.jasperreports.xpath.executer.factory=net.sf.jasperreports.en
gine.util.xml.JaxenXPathExecuterFactory
To switch back to Xalan, one would comment or remove the property line, or explicitly 
set the property to 
net.sf.jasperreports.engine.util.xml.XalanXPathExecuterFactory
.
Localization Support
The XML data source provides localization support for both number and date/time 
values rendered as text in the wrapped XML document.
In order to parse these text values into 
java.lang.Number
or 
java.util.Date
values 
according to the declared report field type in the report template, the program needs to 
know which pattern and locale to use. For date/time report fields, if the text value inside 
the XML representing time is rendered in a specific time zone, then this time zone needs 
to be provided to the data source so that it is taken into account when parsing.
There are four setter methods in the 
JRXmlDataSource
class for specifying:
 Number pattern: To use for parsing all text values corresponding to report fields of 
type 
java.lang.Number
or any subclass of it 
P
AGE
74
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
code, such as, PDF to HTML converter assembly, PDF to Word converter assembly and PDF to PNG converter control. C#.NET DLLs: Use PDF to Text Converter Control
extract text from pdf open source; get text from pdf image
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
(
setNumberPattern(java.lang.String)
method)
 Date pattern: To use for parsing all date/time values corresponding to report fields 
of type 
java.util.Date
or any subclass of it 
(
setDatePattern(java.lang.String)
method)
 Locale: To use for getting localized number and date parsers 
(
setLocale(java.util.Locale)
method)
 Time zone: To use for properly translating time values when they are not expressed 
in GMT (
setTimeZone(java.util.TimeZone)
method)
Patterns should be non-localized and in accordance with the 
java.text.DecimalFormat
and 
java.text.SimpleDateFormat
pattern syntax. If 
specific patterns are not supplied, the defaults for these two format classes apply.
You can see how this data source implementation works by checking the 
/demo/samples/ xmldatasource
sample provided with the project source files.
CSV D
ATA
S
OURCES
Sometimes data that users need to fill the report with is found in plain text files, in a 
certain format, such as the popular CSV (comma-separated value). 
JasperReports provides an implementation for such a data source, by wrapping the CSV 
data from a text file into a 
net.sf.jasperreports.engine.data.JRCsvDataSource
.
The CSV data source usually needs to read a file from disk, or at least from an input 
stream. Thus, the 
JRCsvDataSource
can be initialized in three ways, depending on 
where it gets the data:
 A file: 
new JRCsvDataSource(File)
 An input stream: 
new JRCsvDataSource(InputStream)
 A reader: 
new JRCsvDataSource(Reader)
The CSV format employs certain formatting rules. Data rows are separated by a record 
delimiter (text sequence) and fields inside each row are separated by a field delimiter 
(character). Fields containing delimiter characters can be placed inside quotes. If fields 
contain quotes themselves, these are duplicated (for example, 
"John ""Doe"""
will be 
displayed as 
John "Doe"
). 
The default values in JasperReports (and also the most common for CSV files) are a 
comma for field delimiter and a newline (
\n
) for record delimiter. Users can override 
these default values by calling 
setFieldDelimiter(char)
and 
setRecordDelimiter(String)
. For example, on some systems, users may need to 
replace the default 
\n
delimiter with 
\r\n
.
P
AGE
75
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
Since CSV does not specify column names, the default convention is to name report 
fields 
COLUMN_x
and map each column with the field found at index 
x
in each row (these 
indices start with 0). To avoid this situation, users have two possible solutions:
 Using the 
setUseFirstRowAsHeader(true)
method to force the program to read 
the column name from the first line of the CSV file.
 Providing an array of column names using the 
setColumnNames(String[]) 
method.
Note that in both cases, the number of provided column names must be at least equal 
with the number of actual fields in any record, otherwise an exception will be thrown. 
Also, for any column name in the data source, an equivalent report field must exist.
Handling data types for fields in CSV data sources is special since the CSV file format 
does not provide such information. This matter is solved by trying to match each field in 
the data source to its corresponding report field type. For number and date/time fields, 
converting text values to 
java.lang.Number
and 
java.util.Date
values respectively 
requires parsing using format objects. This is controlled by specifying the date and 
number format objects to be used with the 
JRCsvDataSource
instance by calling its 
setDateFormat(DateFormat)
and 
setNumberFormat(NumberFormat)
methods 
before passing it to the report-filling process.
The CSV data source implementation also has a 
JRCsvDataSourceProvider
class, 
useful for design tools creators. See the “Data Source Provider” section later in this 
chapter for more details.
XLS D
ATA
S
OURCES
When reporting data is in Microsoft Excel files (XLS), the 
net.sf.jasperreports.engine.data.JRXlsDataSource
data source 
implementation can be used to read it and feed it into the report.
The XLS data source uses the JExcelApi library to load the XLS workbook and read 
from it. Instances of this data source can be created by supplying either an in-memory 
workbook object, a file, or an input stream to read the data from
.
Report-field mapping for this data source implementation is very similar to the CSV data 
source field-mapping explained in the previous section. It works on the assumption that 
the workbook contains data in a tabular form (rows are records and columns contain 
report-field values).
E
MPTY
D
ATA
S
OURCES
The 
net.sf.jasperreports.engine.JREmptyDataSource
class is a very simple 
data source implementation that simulates a data source with a given number of virtual 
records inside. It is called “empty data source” because even though it has one or more 
records inside, all the report fields are null for all the virtual records of the data source.
P
AGE
76
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
Such a simple data source implementation is used by the UI tools to offer basic report 
preview functionality, or in special report templates, or for testing and debugging 
purposes.
R
EWINDABLE
D
ATA
S
OURCES
The 
net.sf.jasperreports.engine.JRRewindableDataSource
is an extension of 
the basic 
net.sf.jasperreports.engine.JRDataSource
interface, to which it adds 
the possibility of moving the record pointer back before the first virtual record. It adds 
only one method, called 
moveFirst(),
to the interface.
Rewindable data sources are useful when working with subreports. If a subreport is 
placed inside a band that is not allowed to split due to the 
isSplitAllowed="false" 
setting and there is not enough space on the current page for the subreport to be rendered, 
then the engine has to give up rendering the current band, introduce a page break, and 
restart the band and the subreport on the next page. But since the subreport has already 
consumed some of the supplied data source records when trying to render the band on 
the previous page, it needs to move the record pointer of the data source back before the 
first data source for the subreport to restart properly.
All built-in data source implementations are rewindable except for the 
net.sf.jasperreports.engine.JRResultSetDataSource
, which does not support 
moving the record pointer back. This is a problem only if this data source is used to 
manually wrap a 
java.sql.ResultSet
before passing it to the subreport. It is not a 
problem if the SQL query resides in the subreport template because the engine will re-
execute it when restarting the subreport on the next page.
D
ATA
S
OURCE
P
ROVIDER
To simplify integration with the GUI tools for creating and previewing report templates, 
the JasperReports library has published an interface that allows those tools to create and 
dispose of data source objects. This is the standard way to plug custom data sources into 
a design tool.
This is very useful when the developer wants to preview the reports with the design tool 
and use the actual data that the target application will supply at runtime. In order to 
achieve this, simply create a custom implementation of the 
net.sf.jasperreports.engine.JRDataSourceProvider
interface and make it 
available to the design tool to create the required data sources to use during report 
preview.
The data source provider interface has only a few methods that allow creating and 
disposing of data source objects and also methods for listing the available report fields 
inside the data source if possible. Knowing which fields will be found in the created data 
sources helps you to create report field wizards inside the design tools to simplify report 
creation.
P
AGE
77
T
HE
J
ASPER
R
EPORTS
U
LTIMATE
G
UIDE
The library also comes with an abstract implementation of the 
JRDataSourceProvider 
interface that can be used as the base class for creating data source provider 
implementations that produce JavaBean-based data sources. 
The 
net.sf.jasperreports.engine.data.JRAbstractBeanDataSourceProvider 
uses Java reflection to provide available report fields names for a given JavaBean class.
For more details about data source providers, check the Javadoc API documentation.
R
EPORT
Q
UERIES
To fill a report, provide the reporting engine with the report data, or at least instruct it 
how to get this data.
JasperReports normally expects to receive a 
net.sf.jasperreports.engine.JRDataSource
object as the report data source, but 
it has also been enhanced to work with JDBC so that it can retrieve data from relational 
databases if required.
SQL Q
UERIES
The library allows the report template to specify the SQL query for report data if this 
data is located in relational databases.
The SQL query specified in the report template is taken into account and executed only if 
java.sql.Connection
object is supplied instead of the normal 
net.sf.jasperreports.engine.JRDataSource
object when filling the report.
This query can be introduced in the JRXML report template using the 
<queryString> 
element. If present, this element comes after the report parameter declarations and before 
the report fields. It’s complete syntax is given in Listing 8-2.
Listing 8-2. JRXML Syntax
<!ELEMENT queryString (#PCDATA)>
<!ATTLIST queryString
language CDATA "sql"
>
Here is a simple SQL query that retrieves data from a table called 
Orders
placed in a 
relational database:
<queryString><![CDATA[SELECT * FROM Orders]]></queryString>
Report parameters in the query string are important to further refine the data retrieved 
from the database. These parameters can act as dynamic filters in the query that supplies 
data for the report. Parameters are introduced using a special syntax, similar to the one 
used in report expressions.
P
AGE
78
Documents you may be interested
Documents you may be interested