Messages posted by: Victor Krapivin

Sorry for delay; we found the problem with 3.1 and made a fix.

Please use 3.1.29 (or 4.0.1) for mac OS X.

Can you attach us layout indicating the problems?

Thank you.

Please try using Adobe Acrobat Reader as preview tool; for most cases it helps.

Please also check if /Users/xxx/Desktop/demo.pdf file exists and non-zero (according to log piece you attached, PDF is generated). If not, please send us complete log file and your layout to us.

We're sorry, but http:// images are supprted since XSLfast 4.0.1 only.

Often, we have questions how to let XSLfast work with such OpenType font `Foo` (Foo.OTF/Foo.OTC).

The XSLfast is pure java program and it ready for OpenType fonts support; but it disabled permanently.

Why?

First, XSLfast needs to let you operate with it in GUI (menus, text boxes, etc). And here we have big problem with Java: prior to further release of Java 7, Sun Java have no support of OpenType fonts yet. It are not implemented. So, whole Java API have no possibility to operate with OpenType fonts. And as result, XSLfast also cannot let you type such texts with OpenType fonts selected. Boom.

We're waiting for Java 7 SE; and once it will be released we'll make new major version of XSLfast with OpenType support enabled.

If we understand correctly, you can do the following:

Place text element, and arrange texts you need.
With drag and drop, place XPath variables you need (it will be shown as {Foo}).
For every variable, use context menu -> convert to select representation you want
In context menu, use properties window. Here you can specify exact view for your data, including font and font styles.
In the same inspector window, you can specify IF clause. If this IF is true, element will be visible; otherwise is not.

By the way, font, colors and font styles can be applied directly to variable: move text caret inside it and use tool bar to specify colors / fonts.

Hint: if you need to show such piece of static text conditional, you can specify it as variable like this:

It will be operational as variable, including for-each and IF specifications.

Can you resend your request? It seems we didn't received it yet.

And can you explain a bit what are the problems with conditionals?

This is an simple video (less than 2 minutes) displaying such good practices to manage layouts.

There are:

Fast way to make tables with contents
Nested break levels (inner table contents without separate tables)
Summary/counting at the table
Styles
Drag and drop everywhere
Element' conversions

http://www.youtube.com/watch_popup?v=r9N3oP8L_a4

This is bug fix release for 4.0, with minor improvements.

There are:

Advanced XSD support. Now you can specify supplementary test XML file and use it for preview and other purposes.
FOP 1.0 profiles support. Specify as much FOp config files as you need, and XSLfast will able support it for previews.
Performance. Now huge XML and XSD files works more efficient and needs less memory.
New UI fixes and improvements
Editor dialogs now expandable
Custom names for tabs
More detailed progress bars
Many bug fixes.

New version will be available in few days.

The XSLfast 4 is big step - it contains hundreds of improvements everywhere.

Here is just reminder - what you might find useful.

1. Usability

We made giant changes to let you work with XSLfast 4 more productive.

predefined templates of the layouts like MS Word does
new and more easy to use grouping/filters: now XSLfast hints you most relevant XML nodes
new table wizard - you can create table and fill it with real data in few clicks
automatic support of slave tables - you don't need to count XPath expressions yourself
easy to use summaries for tables, including partial summaries, total summaries, etc
big set of XPath functions, including most useful from exslt.org now in menus
auto-XPath counting - now if you changed filtering or for-each clause, you don't need change inner Xpath leafs manually, it will be adjusted on the fly
many new elements - charts, chooses, and even completely new pivot tables
completely redesigned pop-up editors for every element
many new examples
many minor UI improvements: view filters, faster zooming, new look and feels, and more.
multiple documents at once (MDI)

2. Functions for experts

now FOP 0.95 also supported
advanced features available in latest FOP, XEP and XSLFormatter engines, including markers, n of N page numbering, bookmarks, rotation, and much more.
More robust operations with templates
close support of XSLT 2.0
now supports both Saxon6 and Saxon9
more accurate support for MS XSLT
new export feature - it now collects all necessary files nearby to XSL output
many new useful functions
advanced conversion from XSL code to usual XSLfast elements
rounded boxes
closer SVG support
choose element in UI
basic charts: pie and 2d/3d boxes
pivot tables in feel close to MS Excel
conditional styles directly in text editor

And much more.

3. Integration.

Now XSLfast has basic support of conversions of HTML and XSL-FO documents into layouts. Of course it does not convert everything - just most important contents like tables, texts and images. No JavaScript, no CSS3, no tricks.

XSLfast supports

- FOP 0.20.5
- FOP 0.95
- XEP 4.x
- XSLFormatter 4.x

It can produce XSL with embedded functions for

- Saxon6 (XSLT 1.1)
- Saxon9 (XSLT 2.0)
- Xalan
- MS XML/XSLT

XSLfast supports images directly

- JPEG/JPG
- PNG
- TIFF (JAI is needed)
- SVG
- More formats are available if JAI installed.

XSLfast supports the following elements:

- Text (multi-style, variables and conditions inside, date/tine, choose, internet links and more)
- XSL text
- Squares (including rounded boxes)
- Lists
- Tables
- Pivot tables
- Chooses
- Template calls
- Bar codes
- Images
- Specific text types: date/time, internet links, formatted numbers, and more
- Lines

All elements (except template calls) can be templates.

In previous versions, XSLfast supported only limited booklet form for multiple pages:

- one page sequence
- one master page
- one tail page
- regions for page sequence.

Now, XSLfast has ability to manage for unlimited set of page sequences with separate regions for every layout.

Earlier, XSLfast had no support of multiple layouts at once; now it works.

There are most interesting major changes in XSLfast 4.0.

You always can specify unit зща measures in output. To do this, you need:

Extras->Preferences->XSLT Output

[x] Use selected units of measures in XSLT output

and press [OK] button

At main area, near to rules, left top corner, you can see indicator displaying current unit of measure. Click on it via mouse (it will be rotated points- millimeters - centimeters - inches in cycle) until you see necessary unit of measure.

Note: In XSLfast 4.0.1 you can find units of measure select box in the same manner as for old 3.1 version.

I am evaluating the XSLFast 4.0 on RenderX XEP. I created the FO sample but when I was trying to render the file using the XEP 4.x, it failed. I ran directly from
XSLFast using the FOP to generate PDF, it has no problem.

First, we recommend to install XEP directly at XSLfast/lib/XEP folder (and place XEP license here too). At next start, XSLfast will find XEP and you'll able to manage XEP directly in the same way as FOP. At Preview->Layout settings dialog you can specify FO render engine easily for your layout.

Why we recommend this?

XEP has a lot of benefits and features, and FOP have no this. By clicking XEP in UI, you'll inform XSLfast to enable these features directly in user interface.

FOP (especially FOP 0.20.5) needs many tricks and workarounds to let you print data as you want. For XEP case, these workarounds are not needed, and in fact it produces XEP warnings. XSLfast will not place it into XSL/XSL-FO if you'll choose XEP in UI.

But in such cases, you need to let XEP work with FOP-specific workarounds. To do this, you need to disable XEP strict validation, by passing parameter

at command line of XEP tool.

Unfortunately, a lot of memory is consumed by FOP.

Check the difference for yourself. Launch XSLfast, open your layout with a large XML file and check how much memory is used. Then run FOP and take another look at the memory consumption.

You can use the following heuristics for the memory usage when creating large PDF-files with FOP: multiply your
XSL-FO file size in bytes with 10; that gives you an idea about the memory that FOP needs to render the file.

FOP does the rendering process completely in memory and does not care about the memory consumption.

Other (commercial) renderers like XEP from RenderX or XSLFormatter from Antennahouse can decrease his multiplier to 2 or 3 depending
on the XSL-FO content, especially if you have a lot of images to be printed.

However, when you render a large file with eg. 25.000 customers, this is something where you should always expect that a lot of memory is needed.

In production environments, if you need to print very large PDF files, especially in a web environment, we recommend to use an architecture with a queue of requests and limited worker threads or processes to generate the PDF files asynchronously. Once the PDF is created, you can send an notification about it or simply indicate the status by showing the queue.

You could implement that like this:

a) Instead of generating PDF immediately, collect all necessary files into a queue (eg. by copying the contents in an incoming folder)

b) With separate threads / processes, check the incoming folder periodically

c) If a new request arrived, move the file(s) out of the incoming folder, and do the formatting via FOP

d) When FOP finished the request, move the PDF to an output folder, and return to (b).

I have a XML document like this :

<report>
<customer>
<name>CA</name>
<seller-id>1</seller-id>
</customer>
<customer>
<name>BA</name>
<seller-id>2</seller-id>
</customer>
<customer>
<name>DA</name>
<seller-id>1</seller-id>
</customer>
</report>

I want to do a page grouping by seller-id :

On the first page :

Seller : 1
customer CA
customer DA

On the second page :

Seller : 2
customer BA

This is case of

For case we have unique seller-id, this task is pretty simple. The steps are:

Assign grouping customer/seller-id to page.
Specify sort clause to '.', numeric, ascending.
Place table with data you want to see.
Assign grouping to table as 'customer/name', and place all data you need into table, like name itself: '{.}' (without quotes).

But in case you have non-unique seller-id values in XML, the way is the pretty similar, but with initial step: "group by" seller-id's.

How to do this?

First, we need to define xsl:key, as follows:

a) Follow to Layout->Layout settings dialog, "additional templates" tab.
b) Define internal variable here:

This is important step informing XSLfast to group customer nodes by seller-id, and store grouped nodes for future usage.

Once we have grouped nodes, we need to refer to it in groupings. So, we need to use feature in XSLfast named "virtual groupings". It named "virtual" because there are limited selections from real XML node sets by values.

The simplest case of this grouping is

it uses customer name related to specific seller-id.

Note:

To make these virtual groupings, you need to use 2nd tab at grouping dialog, named "filtering". At the left, you see tree with nodes and you can drag and drop values from it as usual. At the top, check box and "copy from" edit box let you specify from which node you planning to start make virtual grouping. It will add sub-nodes and attributes to it once you pressed "add" button for drag and drop in future with correct XPath substitution. If you don't need this, you can turn off check box here.
At the middle, you see expression box; here you need type expression to filtering. By pressing "evaluate" button at he bottom you'll see the results of filtering immediately. The rest of buttons let you add, modify or delete virtual groupings by selecting it at left tree and pressing buttons.

Above, we used groupings customer/seller-id and customer/name respectively. Now, instead of these simple expressions, we need to use bit more complex ones:

and

respectively. The expression customer[generate-id(.)=generate-id(key('customer-key',seller-id))]/seller-id describes we need only unique values of seller-id for this grouping. Typically it is page grouping. And the expression customer[seller-id=current()]/name' specifies we're using names related to specific seller-id at the page scope.

Except additional step and bit more complex expressions, the basic idea is the same as for unique seller-id values in XML: two groupings for page and for table respectively, and sort expression of page grouping. Of course you can use two tables instead, where one table is placed inside of other table, with the same approach.

When I work with XSD, the XPATH expression in XSL stylesheet generated by XSLFast don't contains namespaces prefixes.

Here we have two different problems. Using namesspaces in conjunction with XSD files and different namesspaces
for different XPath expressions.

In the first case, you wnat to copy the namespace definitions from your schemas to
the output XSL file. For XML files, XSLfast does this automatically; for
DTD and XSD files you need to give XSLfast some hints, as described below.

a) Create an .XFN file in a text editor. Inside, please put some lines
with the namespaces that you need to copy into XSL.

Example:

Add as many lines as you need, and save the file.

b) Open the Preferences dialog in XSLfast (Extras -> Preferences). In
this dialog goto the XSD/DTD settings tab.

c) In this tab, click on "Enable custom namespaces", select the XFN file
that you created before and save.

Now you have custom namespaces and these namespaces will be added into
your XSL files automatically.

This procedure is necessary if you are using non-standard namespaces and
XSD files. XSLfast tries to create namespaces itself, but for XSD it has
less heuristics than for an XML file and if XSLfast cannot figure out
the namespace definitions correctly, you need to make the namespaces
explicit.

This way Saxon will run with namespaces and your XSL-FO will not be
empty as you described.

This is also shown in the tutorial example named "13_Namespace".

Second problem: XSLfast has no ability to add different namespaces to
each XPath expression like "myn:Products", and we have no workaround for
this.

If you need namespaces directly in XPath expressions, you need to
specify them manually.

We're sorry for this limitation of XSLfast. We might add this ability
into a future release. I've created a JIRA ticket for this:
http://jira.jcatalog.com/browse/XSL-1535

This issue happens if you are using two or more namespaces in your XML
document. If you don't need different namespaces in the XPath
expressions, XSLfast will use local names for the XPath expressions.