CP RSS Channel
About Our Sponsors
Articles & Papers
Technology and Society
|Software - Extensible Stylesheet Language (XSL)|
This document references software packages that support the W3C Extensible Stylesheet Language (XSL). General information on XSL/XSLT is available in the main XSL reference document. This listing is not complete, and several items are out-of-date; additionally, some packages named may not support the current W3C specifications, or may not be supported any longer. The [current] order of items in the listing is not significant, except that a few items near the top are perhaps among the more mature/popular/up-to-date. Entries flagged with creation/revision mark of 'CR: 19990724' were not necessarily updated/checked on this date. Software tools generally applicable to the XML family of languages are referenced in the main XML page, software section. For another listing of XSL software, see the Free XML software document maintained by Lars Marius Garshol (listing by supported platform, etc.). Please report additions and corrections to Robin Cover by email.
Clark's XT is a Java implementation of XSL Transformations, viz., the W3C XSL Transformations [XSLT] Specification.
[September 23, 2000] 4XT.org is "a collaborative effort to share resources about XT and to organize its maintenance."
[October 09, 1999] James Clark has prepared a new release of his XT software to match the XSLT and XPath Proposed Recommendations, published by the W3C on October 08, 1999. XT "is a Java implementation of XSL Transformations (XSLT). This release of XT [Version 19991008] mostly updates existing functionality to match the XSLT Proposed Recommendation. For the resulting changes, consult the relevant appendices of the XSLT and XPath Proposed Recommendations. The only completely new functionality is the exclude-result-prefixes attribute on xsl:stylesheet. Note that you will have to update your stylesheets before you can use this release (in particular you have to update the namespace URI). To use XT, you need: (1) the XT distribution, (2) an XML parser in Java that supports SAX, such as XP; you should choose a SAX parser that provides Locator information, otherwise you won't get any line numbers in error messages..."
[July 26, 1999] XT Version 19990725 implements the WD-xslt-19990709 version of XSLT. Stylesheets written for earlier versions of the XSLT WD must be converted before they can be used with this 1999072 version of XT.
[July 12, 1999] New Release of Clark's XT. James Clark recently announced a new release of XT (Version 19990708) which contains bug fixes. XT is a Java implementation of XSL Transformations (viz., W3C XSL Transformations [XSLT] Specification - W3C Working Draft 21-April-1999, WD-xslt-19990421).
[May 17, 1999] James Clark recently announced the release of XT Version 19990514. XT is a Java implementation of XSL Transformations (viz.,W3C XSL Transformations [XSLT] Specification). The current version of XT implements the 'WD-xslt-19990421' working draft version of XSLT. The new release of XT incorporates "relatively few changes. . . a couple of bugs have been fixed, and the performance of the
// operators has been optimized."
[January 15, 1999] James Clark announced the release of the first beta version of XT (Version 19990115), which has seen some 'significant testing' in its several alpha releases. XT is a Java implementation of the tree construction part of the Extensible Stylesheet Language (XSL), WD-xsl-19981216 version.
[January 04, 1999] James Clark has announced the availability of a new release of XT. The major change in Version 19990101 of XT that "XT is now SAX-based: it uses the SAX Parser class for input and the SAX DocumentHandler class for output. It thus no longer depends on XP and can be used with any XML parser in Java that supports SAX. Also new in this release is an experimental extensibility mechanism. . . XT's new experimental extensibility mechanism is based on the idea of filtering fragments of the result tree through an object."
[December 21, 1998] James Clark announced the availability of a new version of XT - a Java implementation of the tree construction part of XSL. This release of XT (Version 19981220) supports the new W3C Working Draft for the Extensible Stylesheet Language Version 1.0 (WD-xsl-19981216). The new version of Clark's XT is not backwardly compatible with the previous XSL WD specification; older stylesheets will need to be updated.
[September 22, 1998] James Clark announced the availability of a new version of XT. The principal change in this version is XT's responsiveness to an initial tag
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl" xmlns="http://www.w3.org/TR/REC-html40" result-ns="">: XT "will recognize that you are generating HTML rather than XML and output the result tree accordingly."
[August 29, 1998] James Clark has announced the availability of a new version of XT. XT is a Java-based implementation of the tree construction/transformation part of the W3C Extensible Stylesheet Language (XSL). XT uses Clark's XP, a high-performance XML parser in Java. In this '19980829' version of XT, more bugs are fixed and more features implemented; it is now "getting quite close to complete." XT is still an alpha version, which has had very little testing, "intended as a tool for learning about XSL not for getting real work done." Syntax: java com.jclark.xsl.Driver
result-file. The package may be downloaded from James Clark's FTP server. [local archive copy]
[August 19, 1998] See preceding. James Clark has released the alpha version of XT, a Java implementation of the tree construction/transformation half of the W3C's new XSL (Extensible Stylesheet Language) Working Draft specification. James says he is releasing this software at an earlier stage than usual for his software distributions because he "wants people to have an implementation to play with as they read about the new XSL draft; [however], the release is not intended as a tool for getting real work done." The software is accessible via http://www.jclark.com/xml/xt.html and is free even for commercial use, and includes complete sources. This XT application uses the latest version of Clark's XP, a high-performance XML parser written in Java.
LotusXSL v0.17.4 supports the April 24, 1999 W3C XSLT Working Draft. This release provides several important bug fixes.
[July 07, 1999] On July 06, 1999, IBM alphaWorks Labs released version 0.17.3 of LotusXSL. LotusXSL is an "experimental implementation of the XSLT specification from the World Wide Web Consortium (W3C Working Draft). XSL provides a mechanism for formatting and transforming XML, either at the browser or on the server. It allows the developer to take the abstract data semantics of an XML instance and transform it into a presentation language such as HTML. LotusXSL implements an XSL processor in Java, and can interface to APIs that conform to the October 1 Document Object Model (DOM) Level 1 Specification. The processor can be used from the command line or from an wrapper applet, or it can be used as a submodule of other programs, and accessed via the API. LotusXSL v0.17.3 now supports the April 21 W3C XSLT Working Draft. This release of LotusXSL provides an XSLT servlet, and includes many bug fixes."
[December 24, 1998] 'LotusXSL - An experimental implementation of the Construction Rules section of the XSL World Wide Web Consortium (W3C) Working Draft.' The LotusXSL processor is written in Java and conforms to the construction rules features of the draft XSL specification released by the W3C [today - WD-xsl-19981216]. LotusXSL is packaged as a JavaBean for use in client or server applications, as an applet for use in Java-enabled web browsers, and as a command-line Java program. See also the announcement for several new technologies from IBM alphaworks. Note (1999-03-10): the 02/08/99 release of LotusXSL [v0.16.2] is compatible with XML4J version 1.1.14.
FOP 'A Formatting Object to PDF Translator' is a print formatter driven by XSL formatting objects. It is a Java application that reads a formatting object tree and then turns it into a PDF document. The formatting object tree, can be in the form of an XML document (output by an XSLT engine like XT or Xalan) or can be passed in memory as a DOM Document or (in the case of XT) SAX events. FOP is part of Apache's XML project. The goals of the Apache XML FOP Project are to deliver an XSL FO->PDF formatter that is compliant to at least the Basic conformance level described in the 27 March 2000 XSL WD, and that complies with the 11 March 1999 Portable Document Format Specification (Version 1.3) from Adobe Systems. Conformance to the XML 1.0 Recommendation, XSLT 1.0 Recommendation and the XML Namespaces Recommendation is understood. Other relevant documents, such as the XPath and XLink Working Drafts, are referenced as necessary. The FOP Project will attempt to use the latest version of evolving specifications." James Tauber was the original designer and developer of FOP through most of 1999. As of late 1999, FOP became part of Apache's XML project. See the record of (some of) the FOP releases.
[January 02, 2000] The announcement for the Version 0.16 release of FOP.
[October 05, 2000] As of 2000-10-05, the current version of FOP is 0.14 See the list of currently implemented features. The distribution file contains source code amd also the documentation (including some example fo files.
[October 14, 1999] James Tauber announced the release of FOP version 0.11.0.
Updated 1999-09-16: new release of FOP (version 0.10.0). See the posting for details.
[1999-07-30] FOP 0.9.0 'FOP now includes basic support for the display-rule formatting object. It can also take a color property on both text and display-rules. I've now implemented the wrap-option and white-space-treatment properties so it is possible to have <PRE>...</PRE> like effects...'
[July 28, 1999] A 'microrelease of FOP': "Lots of internal layout code changes. The actual glyph-height of a font is used and lists within lists now work. Corrected text-align(-last) properties to take "justified" rather than "justify" (thanks pault)..."
[July 19, 1999] James Tauber recently announced a new release of FOP: A Formatting Object to PDF Translator. FOP is a "print formatter driven by XSL formatting objects. It is a Java 1.1 application that reads a formatting object tree and then turns it into a PDF document. The formatting object tree, can be in the form of an XML document (output by an XSLT engine like XT) or can be passed in memory as a DOM Document. Note that FOP is still alpha. It is slow, buggy and doesn't support much of the XSL spec. It's getting there, though... Changes in this version are mostly bug fixes relating to lists. . ."
[May 24, 1999] James Tauber announced the availablity of a new version of FOP: A Formatting Object to PDF Translator. FOP is a "formatter driven by XSL formatting objects. There is no functional difference from 0.6.1 as far as the XSL side of things goes. Rather, the way FOP is invoked has changed. It is now possible to: (1) pass FOP a DOM Document rather than a filename. This makes it possible to embed FOP in other applications (such as XSLT engines and web servers), and (2) use any SAX parser, not just XP as before."
[May 04, 1999] James Tauber has announced the availability of a new release of 'FOP - a formatter driven by XSL formatting objects." FOP (A Formatting Object to PDF Translator) "is a Java application that reads an XML document representing formatting objects (e.g., the output of XT) and then turns it into a PDF document. This version is a complete re-write in light of the most recent XSL working draft. It only implements a fraction of the formatting objects and properties but the overall framework is now there and it should be relatively easy to add more support (assuming the XSL working draft doesn't change too radically). FOP should still be considered alpha." See below.
[October 05, 1998] On October 4, 1998, James Tauber reported that he is using XSL to generate documents for his XML web sites, and that he was writing an XSL flow object to PDF converter. FOP (A Formatting Object to PDF Converter) is "a Python script that, via SAX, reads an XML document representing formatting objects and then turns it into a PDF document. [There is an associated] PyPDF - A simple low-level PDF module in Python for use by FOP. It should be useful apart from FOP too. It handles the object tree and the xref table allowing you to concentrate on the commands that go in streams. In Java: 1998-10-30. On August 21, 1998, James Tauber (jtauber@JTAUBER.COM) reported to XML-DEV readers that he is working on an XSL Formatting/Flow Object to PDF converter, provisionally named 'FOP' ('Formatting Object to Pdf').
'Passive TeX' - Using TeX to format XSL Formatting Objects. "The system works in two stages: (1) apply an XSL stylesheet to the XML document and generate a new XML file containing XSL
<fo:... markup, (2) process that file with a special TeX (pdfTeX) format to generate a formatted PDF file. 'PassiveTeX' is TeX package used to directly format XSL FO material. The files in the distribution "form a demonstration of LaTeX reading XSL Formatting Objects and processing them to produce nice pages. . . using the XML version of the TEI Lite guidelines, we apply the XSL stylesheet and run it through James Clarks' XT XSL processor [producing the flow objects], then through 'pdftex' to produce the PDF file."
[October 04, 2000] See the announcement for release 1.1 of the PassiveTeX XSL FO Implementation.
[June 15, 2000] Sebastian Rahtz announced updates to (1) XSL stylesheets for TEI documents, for HTML and XSL FO rendering and (2) PassiveTex - an implementation of XSL FOs using TeX. PassiveTeX "is a library of TeX macros which can be used to process an XML document which results from an XSL transformation to formatting objects. It provides a rapid development environment for experimenting with XSL FO, using a reliable pre-existing formatter Running PassiveTeX with the pdfTeX variant of TeX generates high-quality PDF files in a single operation. PassiveTeX shows how TeX can remain the formatter of choice for XML, while hiding the details of its operation from the user. PassiveTeX relies heavily on work by David Carlisle (his namespace-aware XML parser written in TeX, xmltex), and was developed from my JadeTeX macros for processing DSSSL via Jade. The TEI stylesheets include "a set of XSLT specifications to transform TEI XML documents to HTML, and to XSL Formatting Objects. I have concentrated on TEI Lite, but adding support for other modules should be fairly easy. In the main, the setup has been used on 'new' documents, i.e., reports and web pages that I have authored from scratch, rather than traditional TEI-encoded existing material. The stylesheets have been tested with the XT, Saxon, Xalan and Oracle XSLT processors; the last of these does not support multiple file output, which means that you cannot use the 'split' feature of the stylesheets to make multiple HTML files from one XML file. If you have not yet installed an XSLT processor, it is probably sensible to pick James Clark's XT, as it appears to be the fastest and most robust." Sebastian writes: "The TEI stylesheets have many small improvements, but remain ongoing work. The PassiveTex application is even closer to the March 2000 draft spec, but still lacking in many areas. Sadly, it is hard to compare the results with FOP and XEP, as they implement an earlier draft. If you have not met PassiveTeX before, it is for you if want to use XSL formatting objects to make nice PDF files from your XML and: (1) you have a TeX setup, and like the cut of its jib; (2) you need multi-lingual hyphenation; (3) you need MathML rendering now (PassiveTeX recognizes the MathML namespace and renders it); (4) you want PDF niceties like bookmarks. It is thus targetted at a different audience from FOP. In this release, the Web pages now have some details of the conformance to the specification."
[May 04, 2000] Sebastian Rahtz has announced the update of his PassiveTeX tool to support the March 27, 2000 working draft specification Extensible Stylesheet Language (XSL) Version 1.0. "I have updated the contents of my PassiveTeX XSL FO processor on http://users.ox.ac.uk/~rahtz/passivetex/ with a version which uses the March 2000 XSL FO spec. It does not conform, but it does something with all but 17 objects, and at least recognizes all the properties. A good many properties are ignored, and for others I do not handle the full range of values. [Another] important change is that the language and hyphenate properties are now implemented. By default now 'no hyphenation', as per spec. I tested this slightly. It assumes, obviously, that your TeX setup has got the right language hyphenation patterns available. The TEI XSL stylesheets at http://users.ox.ac.uk/~rahtz/tei/ have also been updated, in both their HTML and XSL FO incarnations. I am sure that in some places the TEI XSL FO stylesheets, and PassiveTeX, misinterpret the XSL FO specification. I will actively support and develop both PassiveTeX and the TEI stylesheets, and welcome feedback. All of this material conforms to the Debian Free Software Guidelines." See the announcement for details.
[March 20, 2000] Sebastian Rahtz (Oxford University Computing Services) has released a new version of his passivetex package for printing XML documents in PDF format. "I am proud to relaunch my TeX-based system for formatting XSL formatting objects. The actual capabilities of the package are not that much changed (and it isn't quite XSL-FO 2000 yet), but it has had many internal changes, and has seen more use (to format a whole book here, for instance). Most significantly, PassiveTeX has been rewritten to use David Carlisle's 'xmltex' XML parser written in TeX, an amazing piece of work I commend to everyone. My next stage of work is to revisit the RenderX test files, and see how much of their work I can replicate; Ditto FOP."
[October 15, 1999] Sebastian announced a new release of Passive TeX.
[August 02, 1999] Passive TeX updates include (1) confirming that the package runs under windows; (2) improvement of the TEI XSL style sheet for TEI Lite (now supporting the July 1999 specification XSL Transformations - XSLT); (3) correction of many small errors.
[July 12, 1999] Sebastian Rahtz posted an announcement for provisional work on 'Passive TeX' - Using TeX to format XSL Formatting Objects. "The system works in two stages: (1) apply an XSL stylesheet to the XML document and generate a new XML file containing XSL
<fo:... markup, (2) process that file with a special TeX (pdfTeX) format to generate a formatted PDF file. On the Passive TeX Web site are some files which form a demonstration of LaTeX reading XSL Formatting Objects and processing them to produce nice pages. They rely heavily on earlier work by David Carlisle (his typehtml for typesetting HTML files), and on my JadeTeX for processing DSSSL via Jade. David has also contributed a place-holder package for dealing with UTF-8 encoding. It is expected that all the components will be replaced in the near future. How does it work? Taking the XML version of the TEI Lite guidelines (teiu5.xml, with DTD teixlite.dtd), we apply the XSL stylesheet tei.xsl [XSL FO stylesheet to format TEI Lite XML documents] and run it through James Clark's XT XSL processor. . ."
[February 09, 2001] Xalan-Java Version 2.0. David Marston recently announced the availability of Xalan-Java Version 2.0.
[October 11, 2000] Release of Apache's Xalan-C++, Version 1.0. "Xalan-C++ version 1.0 is a robust implementation of the W3C Recommendations for XSL Transformation(XSLT) and the XML Path Language (XPath). It uses version 1.3.0 of Apache's Xerces-C++ XML parser. Xalan (named after a rare musical instrument) takes input in the form of a file or URL, a stream, or a DOM. Xalan-C++ performs the transformations specified in the XSL stylesheet and produces a file, a stream, or a DOM as you specify when you set up the transformation. Along with a complete API for performing transformations in your C++ applications, Xalan-C++ provides a command line utility for convenient file-to-file transformations. Xalan-C++ also supports C++ extension functions." Major updates since version 0.40.0 include: "(1) Full support for namespace handling; (2) Full implementation of the format-number() function and support for the decimal-format element; (3) Integration with the International Components for Unicode (ICU) for number formatting, sorting, and output encoding; (4) Support for the exclude-result-prefixes attribute; (5) Support for the output encoding attribute. Download links are provided for Win32, Linux, and AIX versions. To build applications with Xalan and Xerces, you also need the Xerces-C++ binary distribution for your platform, which you can download from the Xerces-C++ distribution directory. Some people have been looking at porting issues for Solaris and HP-UX. Volunteers are more than welcome to help develop builds for other platforms..."
[March 22, 2000] "Xalan (named after a rare musical instrument) fully implements the W3C Recommendation 16 November 1999 XSL Transformations (XSLT) Version 1.0 and the XML Path Language (XPath) Version 1.0. XSLT is the first part of the XSL stylesheet language for XML. It includes the XSL Transformation vocabulary and XPath, a language for addressing parts of XML documents. You use the XSLT language to compose XSL stylesheets. An XSL stylesheet contains instructions for transforming XML documents from one document type into another document type (XML, HTML, or other). In structural terms, an XSL stylesheet specifies the transformation of one tree of nodes (the XML input) into another tree of nodes (the output or transformation result)... "By default, Xalan uses a high-performance Document Table Model (DTM) to parse XML documents and XSL stylesheets. It can be set to use the Xerces-Java XML parser, and it can be adapted to work with other DOM-producing mechanisms and SAX document handlers." See the samples for further detail.
[December 02, 1999] "The product, FO2PDF, is being developed extensively and successfully, and is still the fullest implementation of XSL FO available. A number of improvement and innovations has been made since then, and the new results will be presented to the general public in near future. [From David Tolpin, XSL-List 1999-12-02.]
[September 01, 1999] Paul Tchistopolskii posted an announcement to the effect that RenderX.com has made Web site additions of files demonstrating the work of the RenderX.com FO2PDF engine. The goal of these demonstration is to show that it is already possible to use XSL and XSL FO standards in a production environment. The "Hammer Demo" has three steps: "(Step 1: xml + xsl = fo) - Taking the XML version of the hypotetical document hammer.xml, we apply an XSL stylesheet hammer.xsl, and run it through James Clarks' XT XSL processor. This creates the new XML file hammer.fo, the stream of XSL FO. (Step 2: Optional Validation) - You may use XSL FO Validator online service running at www.RenderX.com to make sure that the stream of XSL FOs is consistent and reasonable. (Step 3: Rendering) - We now run FO2PDF rendering engine on this hammer.fo which creates the PDF file, hammer.pdf." See also among the demos the Formatting Object Parade: some formatting objects streams which produce the given PDF files running under the FO2PDF rendering engine. The validator has been updated, and consists of two steps: The first step is to invoke IBM XML4J validating parser with the special fo.dtd to be sure that FO stream has reasonable structure. The second step is to invoke the XML rendering engine in validate-only mode to perform some checks that could not be done with DTD."
[September 06, 1999] Validator updated 1999-09-06 (DTD and whitespace processing, tuning).
The DataChannel XJParser is a "complete, reliable, and innovative XML parser for delivering powerful, server-based enterprise applications utilizing open web standards. For data presentation of XML data to the web or other applications, the integrated eXtensible Stylesheet Language (XSL) processor combines XML parsing and XSL transformation in one package for tighter integration or parsing and presenting XML. The XJParser offers: (1) Comprehensive functionality including 100% XML 1.0 and DOM Level 1 compliance as well as SAX and W3C interfaces. (2) XML Validating against DTDs and Schema (XML-Data). (3) XML transformation with an integrated XSL processor. (4) Advanced technologies based on W3C working drafts including Datatyping, XSL Pattern Matching (XML Query), and Node Transformation. XJParser is a cross-platform tool and runs under any JDK 1.1 compliant Java Virtual Machine. See also the XJParser FAQ document.
[October 11, 2000] See Joshua Allen's "Unofficial MSXML XSLT FAQ" for information on installing/using the 'latest' MS parser.
[March 16, 2000] Microsoft XML Parser Technology Preview. David Turner (Microsoft 'XML Product Manager and Technical Evangelist') has posted an announcement for a new Microsoft XML Parser Technology Preview and XSLT add-on utilities. "An updated version of the Microsoft XML Parser Technology Preview was released today and can be downloaded from http://msdn.microsoft.com/downloads/webtechnology/xml/msxml.asp. Highlights of this release include increased support for XSLT (support for named templates and HTML and Text Output Method), complete XPath support and bug fixes (see http://msdn.microsoft.com/workshop/xml/general/msxml_buglist.asp). In addition, we've released two add-on utilities for Internet Explorer 5 that make it easier to validate documents in the browser and to view the output of an XSLT transform. You can download both utilities from http://msdn.microsoft.com/downloads/webtechnology/xml/iexmltls.asp". Details: "The March 2000 Microsoft XML Parser (MSXML) Technology Preview is an update to the January 2000 technology preview. This latest release of MSXML provides improved XSLT/XPath standard compliance and a number of bug fixes. For more detailed information on the new features, see 'What's New in the March Microsoft XML Parser Technology Preview Release', by Charlie Heinemann. Please note that this technology preview requires Internet Explorer 4.01 SP1 and later in order to be fully functional." Update features include: (1) XSLT/XPath Support: The XSLT/XPath implementation within the latest parser is greater than 90 percent compliant with the XSLT and XPath specifications. The following features have now been implemented: Named Templates; HTML, XML, and text output method support in XSLT; Complete XPath function support. (2) Named Templates: The MSXML Parser now supports the <xsl:call-template> element and the name attribute on the <xsl:template> element. Use these to call templates by name rather than through the <xsl:apply-templates> element. (3) HTML Output Method: This release of the MSXML Technology Preview Parser supports the HTML output method in XSLT." The distribution includes (1) the March 2000 MSXML Technology Preview Release and (2) the latest MSXML Technology Preview SDK.
The Microsoft XML Parser is implemented as a COM component, providing a complete XML foundation for Windows DNA applications. The Microsoft XML Parser has a high performance, multi-threaded architecture that makes it ideally suited for both client and server-side XML and XSL processing. Its features include: (1) The industry's first support for XSL, querying, and a schema technology preview. (2) Support for DTDs and validation. (3) Support for the W3C XML 1.0, XML DOM, and Namespaces recommendations. (4) A comprehensive, language-neutral programming model, including support for ECMAScript, Java, Perl, Python, SQL, the Visual Basic development system, the Visual C++ development system, or Visual Basic Scripting Edition (VBScript)."
[Earlier description:] msxsl - Microsoft XSL Processor, Technology Preview. No support yet for flow-object macros or named styles. See Microsoft's "list of known differences between the Microsoft XSL Processor and xslj."
[October 11, 2000] See Joshua Allen's "Unofficial MSXML XSLT FAQ" for information on installing/using the 'latest' MS parser with IE.
[September 29, 2000] See "What's New in the September 2000 Microsoft XML Parser Beta Release." Also: "Internet Explorer Tools for Validating XML and Viewing XSLT Output" [March 15, 2000 or later].
[July 25, 1999] "Microsoft Internet Explorer 5 can apply XSL style sheets that produce HTML, allowing direct browsing of the XML files. The Microsoft Internet Explorer 5 XSL implementation is based on Section 2 (Tree Construction) of the Extensible Stylesheet Language (December 18th Working Draft). Microsoft Internet Explorer 5 uses an XSL style sheet to display an XML document when that document contains a style sheet processing instruction (PI) with type
"text/xsl". For example:
<?xml-stylesheet type="text/xsl" href="review.xsl" ?>. XSL transformations can be executed on the server to provide HTML documents for downlevel browsers. The transformation process is independent of any particular output grammar and can be used for translating XML data from one schema to another. The transformation can be used for general-purpose transformations within a single grammar, including filtering, sorting, and summarizing data. For details, see: (1) Browsing XML Using XSL Style Sheets, (2) the Microsoft XSL Developer's Guide, (3) XSL Working Draft Conformance Notes", (4) XSL Pattern Reference, and (5) "Using XSL to Sort and Filter Data". [These URLs live 1999-07-24.]
Joe Kesselman has posted an announcement for the release of an 'IBM XSL Editor' from alphaWorks. The IBM XSL Editor application "allows a user to import, create, and save Extensible Stylesheet Language (XSL) style sheets and Extensible Markup Language (XML) source documents. This XSL stylesheet editor incorporates trace function and provides assistance with writing select and match expressions. It integrates XSL Trace with the Visual Transform tool, both available on alphaWorks. IBM's XSL Editor allows users to set and remove 'break points' on the style sheet and source document. The XSL Editor user interface features an XML 'source based' collapsible 'tree view' with dynamic font resizing for 'Zooming' in/out to handle small/large documents. Dynamic 'edit pads' provide a vehicle for style sheet and source document editing that are automatically kept in synch with their corresponding tree views. Style sheet authoring is made convenient by the ability to automatically generate XPath syntax from sample source documents. The tool requires a Java runtime environment and the Swing 1.0.3 component class library. The development team has not yet implemented several XSL transformation constructs. In particular: <xsl:import>, <xsl:include>, extension mechanisms, and the document() function. The IBM XSL Editor distribution includes both the IBM XML Parser (version 2.0.14) and LotusXSL engines as well as other support libraries. Also, note that Java 2 SDK does not include the swing 1.0.3 component libraries."
[October 19, 1999] Steve Muench posted an announcement for release 0.9.6 of the Oracle XSQL Page Processor, XSQL Servlet, and XSQL Command Line processor. "The XSQL Servlet makes it easy to serve database-driven XML information (optionally transformed by XSLT stylesheets) to requestors over the Web. With the servlet, one may produce dynamic XML documents based on one or more SQL queries, and optionally transform the resulting XML document in the server or client using XSLT. Some new features: (1) Uses the new Oracle XMLParser V2 220.127.116.11 that implements the XSLT Proposed Rec of 08-OCT-99; (2) Support for all popular Servlet Engines - JServ, JRun, ServletExec,...; (3) Support for any JDBC driver; (4) Support for Command-line processing of XSQL pages for use in scripts; (5) Comes with upgraded demos and samples, including a demo of an entire dynamic website built with a single .XSQL page and one XSLT stylesheet featuring stateless paging through database query results. If you include an <?xml-stylesheet?> processing instruction at the top of your .xsql file, it will be considered by the Oracle XSQL Page Processor for use in transforming the resulting dynamically-produced 'datapage' into either HTML or XML. Multiple <?xml-stylesheet?> processing instructions can be included at the top of the file and an optional media pseudo-attribute can be specified which will cause the Oracle XSQL Page Processor to try to select a stylesheet for transformation which is appropriate to the current requesting user agent." For additional details, see the Release Notes for 0.9.6.2 Technology Preview (October 14, 1999). The software is available through the Oracle Technology Network (OTN). For other XML products by Oracle, see the parser/utilities listing. For related XSL/XSLT software, see "XSL/XSLT Software Support."
From Terris: "The XSLT command-line processor uses Oracle's Java XML parser to process XSLT stylesheets. This processor doesn't do much except call Oracle's parser. It is handy, however, and can be used as an example for using the parser. It does not support XT's feature set such as setting parameters in style sheets.
"InDelv XF is an XML toolkit which supports formatting, browsing and content generation. It renders XSL-FO, CSS and XHTML content and sends output to the screen, printer or PDF documents. XSLT based projects are supported using an XML task description namespace. It runs on Java and .NET - desktop and class library versions available. Free evaluation."
[May 28, 1999] At WWW8 [Eighth International World Wide Web Conference. May 11 - 14, 1999. Metro Toronto Convention Centre, Toronto, Ontario, Canada.] Sharon Adler, Director of Product Management at Inso, "presented the prototype of an XSL stylesheet editor that allows a user to generate both XSL and CSS style sheets. In addition, the user can develop an XSL Transform (XSLT) stylesheet and the associated XML result document. Sharon discussed the design approach and issues in style editor development." (Ken Sall's report.) Apropos of which James Clark wrote [xsl-list, 28 May 1999] "Inso has demonstrated an XSL editing tool. It seemed quite useable to me."
[April 09, 1999] IBM XML Enabler - a Java Servlet that converts XML-tagged data into HTML using different stylesheets for different browsers. The XML Enabler works with the Lotus Extensible Stylesheet Language (XSL) Processor to transform data using XSL stylesheets. See the white paper, Accessing XML on the Client, [local archive copy].
XSLJ - Jade-compatible XSL-to-DSSSL translator from Henry Thompson. xslj translates valid XSL style sheets into valid extended DSSSL style sheets, which can then be used to render XML documents using Jade. Updated 980316 for compatibility with the recently announced JADE 1.1.
MajiX - Java compliant tool from Tetrasix, "automatically transforms RTF files (Microsoft Word files) into XML... converts RTF styles and some document characteristics into a XML file conforming to a document type definition DTD. The names of the tags may be changed by the user. Majix version 1.1 is the third release; it corrects some bugs from version 1.0 and provides support for XSL through James Clark's XT." With online documentation
TeXML provides a path from XML into the TeX formatting language. The path to print begins with your XML document. You write an XSL transform which accepts your document type and outputs a new XML document which conforms to the TeXML document type. The java program, TeXMLatte transforms any document conforming to the TeXML document type into TeX. The 06/23/99 version contains examples for the April 21 XSL working draft; it is updated for Lotus XSL 0.17.2 and XML4J 2.0.11. TeXMLatte now outputs options and parms in document order."
[August 01, 2000] "The Paper Path: XML to Paper Using TeXML." By Brian E. Travis. In TUGboat [The Communications of the TeX Users Group] 20 (4) (December 1999), pages 350-356. A complete tutorial on the use of IBM's TeXML.
[June 09, 1999]. Xport 2.0 - XSL Engine from T.I.M.E LUX. A communiqué from Roger Schütz of TIMELUX announces the release of new software products in the area of processing XML/SGML data. Xport 2.0 is a stand-alone XSL engine, available free of charge as a COM object. This is an XSL transformation engine that provides flow objects and data transformation for in-line display, HTML-conversion, and any other output format you may use. Furthermore, its powerful API can be addressed by most popular standard languages like C++, Visual Basic, VB- and J-script."
[February 23, 2001] Christopher Parkerson announced the release of eXcelon's Stylus Studio 3.0 as a new "integrated development environment for XML applications built around the Stylus Visual XSLT Editor. Stylus Studio includes components needed to develop XML-based solutions. Stylus Studio 3.0 supports project management, a scalable XML editor, a Schema editor, Visual XSLT editor, a Visual XML-to-XML mapper, a Java source editor, and an integrated Java and XSLT debugger. The XSLT debugger allows one to quickly debug through XSLT with support for variables, watches, and stack tracing. Studio is designed to be capable of handling XML source files tens of megabytes in size. See details.
[October 27, 1999] Transformis LLC, the makers of the Stylus XSL Editor, was recently acquired by Object Design Inc. Stylus is now available commercially as part of eXcelon 2.0, an application development and deployment environment that includes our XSL editor as well as a server product that does just what you are describing. eXcelon stores XML data in a DOM representation, which allows you to fully exploit the extensibility of XML. It also includes an integrated XSLT processor that allows you to easily deploy your XML data on the web, and our editing tool to help you create stylesheets. I would encourage you to take a look at the evaluation copy of the server and XSL editor at http://www.odi.com/excelon." [Carl Sjogreen October 21, 1999, XSL-List]
[June 23, 1999] Carl Sjogreen (President, Transformis LLC) announced an alpha testing phase for "Stylus, an Integrated Development Environment for XSLT stylesheets. Stylus provides a unified, graphical interface for visualizing input data, editing stylesheets, and viewing the result. Stylus is now available for Windows 95, 98, and NT platforms. Current key features of Stylus include: (1) Integrated XML Parser / XSL Processor: Parsing and processing errors automatically display the offending code; stylesheet output is updated and displayed at a keystroke. (2) Structural Data View: Stylus provides a synthesized view of the stylesheet's input data; XSL templates can easily be created and managed through this interface, and are visually associated with the document's hierarchy. (3) Stylesheet Backmapping: Stylesheet backmapping visually associates XSL templates with their output; when a user clicks on text in the stylesheet output, Stylus automatically displays the template that created it. (4) XSL-Aware Editor: Sense:X technology provides customizable context-sensitive help and syntax highlighting. (5) Internet Explorer Preview: If Internet Explorer 4.0 or above is installed, Stylus can preview the result of a stylesheet in an integrated Internet Explorer browser; stylesheet preview in an external browser is also possible regardless of browser version. With Stylus, developers can finally leverage the full potential of XML and XSL through an easy-to-use yet powerful interface. Stylus streamlines the creation of dynamic web sites by providing a graphical environment for the entire development process. From XML data to final result, Stylus keeps developers in control. Stylus is now available for preview through Transformis' Alpha Program. Approved participants will have access to all pre-release versions of Stylus. A public Beta Program will make Stylus available to a wider audience in the future."
"XSL Lint is a semantic lint checker for XSL. It detects: (1) Duplicate match patterns; (2) Modes that are used but never defined; (3) Modes that are defined but never used; (4) Named templates that are used but never defined; (5) Named templates that are defined but never used; (6) Templates that use
match= was probably intended." From Norman Walsh.
[March 15, 2001] Infoteria Releases Enhanced iXSLT XML Transformation Tool. Infoteria Corporation has announced a new release of its iXSLT processor with enhanced functionality for the transformation of XML data into HTML, WML, or other XML files using XSL (W3C Extensible Stylesheet Language). "New performance testing features have been added, so users can test the time it takes to perform a single XSLT transformation or multiple transformations, defined by a 'repeat number.' Additionally, iXSLT 2.0c can load external entities from both XML and XSLT documents. iXSLT adds new extension elements to make transforming data easier than ever before: (1) iXSLT 2.0c supports executing external programs and inserting the results of these programs as the values for an XML element; (2) iXSLT can now output to multiple files; (3) XPATH functionality has been extended, allowing the user to change the result tree fragment node sets and evaluate character strings as functions." [Full context]
[June 22, 2000] "[Earlier in 2000,] Infoteria Corporation announced the availability of iXSLT. iXSLT, a processor that uses XSL files to transform existing XML data, is one hundred percent compliant with the World Wide Web Consortium's (W3C) XSLT version 1.0. iXSLT can transform a single source of XML data into multiple formats for use by personal computers, personal digital assistants, cellular devices and game machines. iXSLT can be downloaded from Infoteria's web site product page at http://www.Infoteria.com. iXSLT is available in four configurations: (1) iXSLT Invoker user tool; (2) iXSLT command line utility; (3) Dynamic Link Library (DLL) for C/C++ programers; (4) Component Object Model (COM) version callable from Active Server Pages or Visual Basic." [information from Sean Kono, Infoteria Corporation]
[June 09, 1999]. Pina Hirano of Infoteria Inc. announced the public availability of iXSLT (iXSLT 1.0 Beta Evaluation edition for Windows 95/98/NT). iXSLT is an XSLT processor compatible with with the latest W3C public working draft of XSL Transformations (XSLT) (1999-04-21). iXSLT is a command-line executable, and the download file includes simple samples.
[December 20, 2001] Experimental SAXON XSLT Processor Version 7.0 Supports New XSLT 2.0 and XPath 2.0 Specifications. A posting from Michael Kay announces the release of an experimental implementation of the Saxon XSLT Processor supporting many of the new features in the new W3C XSLT 2.0 and XPath 2.0 working drafts. The Saxon package is "a collection of tools for processing XML documents, including (a) an XSLT processor; (b) a Java library, which supports a similar processing model to XSL but allows full programming capability, which you need if you want to perform complex processing; (c) a slightly improved version of the Ælfred parser from Microstar. Saxon implements the XSLT 1.0 recommendation, including XPath 1.0, in its entirety; version 7.0 also implements many features defined in the XSLT 2.0 and XPath 2.0 working drafts, in particular: (1) Support for multiple output files using xsl:result-document; (2) Full processing capability on temporary trees, previously known as result tree fragments; (3) Support for sequences of nodes and simple values; (4) Support for the new XPath expressions if, for, some and every; (5) Support for named collating sequences; (6) Many new functions and operators. The most notable omission in version 7.0 is support for XML Schema data typing: the data types currently supported are boolean, string, decimal, integer, float, and double." [Full context]
[December 03, 1999] A posting from Michael Kay to the XSL-List announces the release of SAXON version 5.0, which supports the W3C XSLT and XPath Recommendations published on November 16, 1999. Kay says that the SAXON 5.0 package is now "a complete implementation of XSLT 1.0 and XPath 1.0 - If there are any parts of the spec it doesn't implement, then that's an oversight and will be treated as a bug. Apart from full conformance, the new things in this release include: (1) a number of new extension functions [intersection(), difference() and has-same-nodes() to compare node-sets; line-number() and system-id() of the current node in the source document; if(condition, then, else)]; (2) stylesheet chaining: [specify <saxon:output next-in-chain="phase2.xsl"> to send the output of this stylesheet to be the input to another stylesheet]; (3) user-definable numbering and collating sequences; (4) internal improvements to node-set handling and sorting, which should result in better performance when handling large node-sets, and should certainly reduce the load on the garbage collector."
[October 14, 1999] Michael Kay announced the release of SAXON version 4.7. Supports the 1999-10-08 PR specifications for XSLT and XPath.
[July 30, 1999] A posting from Michael H. Kay has announced the release of SAXON version 4.5. "As well as moving to the new syntax (July 1999 XSLT and XPath), this release plugs a few of the remaining gaps in SAXON's XSL coverage, for example it now supports
xsl:include and the
document() function." Also includes "Instant SAXON."
[July 14, 1999] Michael Kay (ICL) announced a new release of the SAXON XSL interpreter and compiler with a new URL: http://users.iclway.co.uk/mhkay/saxon/. The SAXON package "is a collection of tools for processing XML documents. The main components are: (1) An XSL processor, which supports the W3C 21 April 1999 XSLT specification from the World Wide Web Consortium, found at http://www.w3.org/TR/1999/WD-xslt-19990421 with a few minor restrictions and a number of powerful extensions. (2) A Java library, which supports a similar processing model to XSL, but allows full programming capability, which you need if you want to perform complex processing of the data or to access external services such as a relational database. So you can use SAXON by writing XSL stylesheets, by writing Java applications, or by any combination of the two. SAXON provides a set of services that are particularly useful when converting XML data into other formats. The output format may be XML, or HTML, or some other format such as comma separated values, EDI messages, or data in a relational database. SAXON implements nearly all of the draft XSL transformation language standard. However, SAXON was written explicitly to do things that are beyond the scope of the XSL standard: in particular: (1) It allows XSL processing and Java processing to be freely mixed, so you can always escape into procedural code to do something non-standard -- such as accessing a database; (2) It allows multiple output files. SAXON is particularly useful for splitting a large document into page-sized chunks. You can do this without writing any Java code; (3) SAXON provides an XSL compiler. If you frequently use the same stylesheet to render different documents, you can compile the stylesheet into a Java application to improve performance. The resulting application can be installed directly as a servlet on your web server." The version 4.4 release "has very few new features but greatly improved performance. It still implements the April 21 specification. As an example of the performance boost, Oren Ben-Kiki's 8-queens stylesheet previously took 75 seconds when interpreted and 21 seconds when compiled. It now takes 12 seconds interpreted and 8.5 seconds compiled."
The Schematron: An XML Structure Validation Language using Patterns in Trees. The Schematron differs in basic concept from other schema languages in that it not based on grammars but on finding tree patterns in the parsed document. This approach allows many kinds of structures to be represented which are inconvenient and difficult in grammar-based schema languages. If you know XPath or the XSLT expression language, you can start to use The Schematron immediately. The Schematron is trivially simple to implement on top of XSLT and to customize." See the Preprocessor for the Schematron XML Schema Language.
[October 25, 1999] Rick Jelliffe (Computing Centre, Academia Sinica) has posted an announcement for an implementation of 'Schematron'. David Carlisle has produced a Schematron Report implementation of Schematron with an error browser. "The Schematron is a Open Source tree-pattern language for representing schemas for XML documents. It is a radically different approach from grammar-based schemas. It is based on XPath, and can be trivially implemented over an XSL system. I think it has the potential to largely supercede grammar-based schema languages such as DTDs, etc. for XML validation." In the top frame of the tool "are displayed the error messages produced by the Schematron itself. Click on the error messages and source code in the lower frame goes to the apporpriate place in the source document. This example uses a partial schema for the WAI guidelines. You can see the schema at http://www.ascc.net/xml/resource/schematron/wai.xml." See also the Schematron tutorial from Miloslav Nic [1999-10-27].
[December 03, 2001] Apache Cocoon XML Publishing Framework 2.0 Issued as a Stable Release. A posting from Carsten Ziegeler announces Apache Cocoon version 2.0 as the "first stable release of the 'next generation' of Apache Cocoon. This 2.0 release of the Cocoon XML publishing framework represents a complete rewrite of the first generation, removing all of the design constraints that emerged during almost three years of worldwide use. This new release is considered stable in both implementation and on the API it provides." Cocoon is an XML publishing framework that "allows you to define XML documents and transformations to be applied on them, and to eventually generate a presentation format of your choice in HTML, PDF, SVG, etc. Cocoon relies on a pipeline model: an XML document is pushed through a pipeline that exists in several transformation steps of your document. Every pipeline begins with a generator, continues with zero or more transformers, and ends with a serializer. This can be compared to the 'servlet-chaining' concept of a servlet engine." [Full context]
Part of the Java Apache Project, Cocoon is a 100% pure Java publishing framework servlet that relies on new W3C technologies (such as DOM, XML, and XSL) to provide web content. Cocoon does not aim to simplify the creation of web content: in fact, it is harder to create XML/XSL content than it is to use HTML from the beginning. The advantages come on the long run, on site management, update and refining. The Cocoon project aims to change the way web information is created, rendered and delivered. This new paradigm is based on fact that document content, style and logic are often created by different individuals or working groups. Cocoon aims to a complete separation of the three layers, allowing the three layers to be independently designed, created and managed, reducing management overhead, increasing work reuse and reducing time to market. The Cocoon project is able to create web documents in virtually any format. Its most common use, though, is the automatic creation of HTML through the XSL rendering of statically or dynamically generated XML files. Note that Cocoon aims to support the complete XSP specification and will (one day) therefore be able to create, say, PDF documents by processing a dynamically generated XML page styled into the XSL-FO namespace. The Cocoon model divides the development of web content in three separate levels: (1) XML creation: the XML file is created by the content owners. They do not require specific knowledge on how the XML content is futher processed rather than the particular choosen DTD/namespace. This layer is always performed by humans directly thru normal text editors or XML-aware tools. (2) XML processing: the requested XML file is processed and the logic contained in its logicsheet is applied. Unlike other dynamic content generators, the logic is separated fromt the content file. (3) XSL rendering: the created document is then rendered by applying an XSL stylesheet to it." See also: (1) The XSP working draft, (2) FAQ Document, (3) Cocoon User Guide, (4) Cocoon 2 White Paper: Web Publishing Framework.
[March 25, 1999] On March 10, 1999, the Java Apache Project released Cocoon Version 1.0. Cocoon "is an "XML/XSL publishing framework servlet that allows complete separation of content, logic and style. As a Java servlet, Cocoon will run on any 2.x compliant servlet platform. Cocoon uses the W3C Document Object Model to specify the documents it handles and it's not based on any particular XML parser implementation using a modular and pluggable interface. These are the XML parsers currently supported: IBM XML4J, OpenXML, and Sun ProjectX. XSL processors currently supported include the Lotus XSL Processor and the Koala XSL Processor.
[May 11, 2000] "AxKit, my toolkit for transforming XML on the Apache server has been updated to version 0.60. This version adds some improvements to the caching code, some updates to the languages, the ability to invalidate the cache when external parsed entities change, a passthru module (for XML capable clients), ability to use alternative configuration readers (for example, to emulate Cocoon 2's SITEMAP feature), and the ability to cascade processors that don't use the DOM, and many more bugfixes and lots more documentation and examples on the web site. AxKit is free software, available under either the Artistic or GNU Public license." [Matt Sergeant, XML-DEV, 2000-05-11]
[May 02, 2000] Apache XML Delivery Toolkit - AxKit. Matt Sergeant (Fastnet Software Ltd.) posted an announcement to the XSL-List [2000-04-28] concerning his Apache XML Delivery Toolkit (AxKit). The Apache XML Delivery Toolkit (AxKit) "is a suite of tools for the Apache httpd server running mod_perl, that give developers extremely flexible options for delivering XML to all kinds of browsers, from handheld systems, Braille readers, and ordinary browsers. All this can be achieved using nothing but W3C standards, although the plugin architecture provides the hooks for developers to write their own stylesheet systems, should they so desire. Two non-W3C stylesheet systems are included as examples. The toolkit provides full intelligent caching, which ensures that if any parameters in the display of the XML file change, the cache is overwritten. The toolkit also provides hooks for DOM based stylesheets to cascade. This allows (for example) the initial stylesheet to provide menu items and table of contents, while the final stylesheet formats the finished file to the desired look. It's also possible to provide multiple language support this way. . ." From a more recent description posted to the list: AxKit (Apache XML Delivery Toolkit) is a "suite of tools based on the Apache-Perl integration project, and Perl's XML processing tools, for delivering XML to clients. It has similar aims to the Cocoon project. AxKit is an extremely high performance alternative to Cocoon. I've heard some complaints of Cocoon's scalability (not many, but every now and then they pop-up on the Cocoon-users list - and I do hear this will be better with Cocoon 2). AxKit scales almost linearly with apache. My dev box runs a lot of software, so Apache is extremely constrained (with good reason - I'm behind a 64k link - so a fast web server is a low priority). ApacheBench reports 105 requests/sec for some static HTML. I get 80 requests/sec for cached converted XML files. Scale that up to a loaded Apache box, and well, you do the math... Current stylesheet systems only include XPathScript, NotXSLT (2 languages of my own invention, not perfect, but they work) and XSLT (based on Perl's XML::XSLT, with all its restrictions). Note: xml.sergeant.org runs entirely on AxKit."
"XML Spy is a professional validating XML editor for Windows developers, IT professionals and Web-Design people that lets you edit all XML, XHTML, XSL, RDF, 3DML, and DTD files and provides three advanced views on your documents: an Enhanced Grid View for strucutred editing, a Source View with syntax-coloring for low-level work, and an integrated Browser View that support CSS and XSL style-sheets.
"EXml from CUESoft "is an XML editor with a structure view and a source view and built-in XSL namespace support. It checks for well-formedness. In the structure view you can add element nodes to the tree via a dialog. It has a user-friendly dialog for inserting XSL commands that lets you select properties, for which you can enter the values after insertion. You can also easily add text, CDATA sections, comments, attributes (in a separate pane), and processing instructions. The source view is also modifyable. EXml prompts you to parse the changes back into the tree view structure."
[August 27, 2001] As of 2001-11-02, the latest revision of 'xslide: Emacs Major Mode for XSL Stylesheets' was 0.2, dated 27 August 2001. Features of xslide revision 0.2 include: (1) XSL customization group for setting some variables; (2) Initial stylesheet inserted into empty XSL buffers; (3) "Template" menu for jumping to template rules, named templates, key declarations, and attribute-set declarations in the buffer; (4) xsl-process function that runs an XSL processor and collects the output; (5)Predefined xsl-process command line templates and error regexps for Java and Windows executable versions of both XT and Saxon; (6) Font lock highlighting so that the important information stands out; (7) xsl-complete function for inserting element and attribute names; (8) xsl-insert-tag function for inserting matching start- and end-tags; (9) Automatic completion of end-tags with user-definable indentation step; (10) Comprehensive abbreviations table to further ease typing. Font lock colours can be customized once xslide is loaded by Emacs. Development on SourceForge.
[April 21, 2001] xslide 0.2b3 announcement: Revision 0.2 Beta 3 of the xslide package for an Emacs major mode for editing XSL stylesheets is available. Features of xslide revision 0.2b3 include: (1) XSL customization group for setting some variables (2) Initial stylesheet inserted into empty XSL buffers; (3) 'Template' menu for jumping to template rules, named templates, key declarations, and attribute-set declarations in the buffer; (4) 'xsl-process' function that runs an XSL processor and collects the output; (5) Predefined command line templates and error regexps for Java and Windows executable versions of both XT and Saxon; (6) Font lock highlighting so that the important information stands out; (7) 'xsl-complete' function for inserting element and attribute names; (8) 'xsl-insert-tag' function for inserting matching start- and end-tags; (9) Automatic completion of end-tags; (10) Automatic indenting of elements with user-definable indentation step; and (11) Comprehensive abbreviations table to further ease typing. See the README file. [cache]
[September 13, 2000] Tony Graham (Mulberry Technologies, Inc.) has announced the release of xslide Revision 0.2 Beta 1. The xslide package provides the implementation of an Emacs major mode for editing XSL stylesheets. Features of xslide revision 0.2b1 include: "(1) XSL customization groups for setting some variables (2) Initial stylesheet inserted into empty XSL buffers; (3) "Template" menu for jumping to template rules in the buffer; (4) xsl-process function that runs an XSL processor and collects the output; (5) Predefined xsl-process command line templates and error regexps for XT and Saxon; (6) Font lock highlighting so that the important information stands out (font lock colours can be customized once xslide is loaded by Emacs); (7) xsl-complete function for inserting element and attribute names; (8) xsl-insert-tag function for inserting matching start- and end-tags; (9) Improved automatic completion of end-tags; (10) Improved automatic indenting of elements; and (11) Comprehensive abbreviations table to further ease typing. xslide is a work in progress. Code contributions and suggestions for improvements are always welcome. Use the xsl-submit-bug-report' function to report bugs."
[September 23, 1998] xslide. Tony Graham of Mulberry Technologies, Inc. announced the public availability of an early version of xslide. The xslide package features an Emacs major mode for editing XSL stylesheets. This version supports font lock highlighting (so that the important information stands out), a function for inserting element and attribute names, a function for inserting matching start- and end-tags, automatic completion of end-tags, automatic indenting of elements, comprehensive abbreviations table to further ease typing, etc. The current version of xslide (Version 0.1, September 22, 1998) has been tested using NTEmacs 19.34.1. The package is available from the Mulberry Technologies FTP server at ftp://ftp.mulberrytech.com/pub/xslide/xslide.zip. Note that Tony Graham is also the developer and maintainer of tdtd - An Emacs Macro Package for Editing SGML/XML DTDs. [xslide ver. 01, local archive copy]
Fetch it by FTP; updated September 22, 1998 [0.1] or later.
SVG Slide Toolkit, "... transforms an XML file that uses a specific DTD into an SVG (Scalable Vector Graphics) slide presentation. This allows you to separate the content of a presentation from its look and feel. This separation allows you to modify independently the content, the presentation style or both. One advantage of this is that you can then use the same content for different audiences or events. Similarly, you can use the same look and feel for different content. The SVG Slide Toolkit includes the following components: Cascading stylesheet containing style definitions used by the elements in the generated SVG output file; DTD for slide presentations; Stylesheet for slide navigation; A test SVG file that you can use to verify that files were extracted properly from the archive and that the SVG viewer is installed correctly; Sample template file that you can use to create your own XML slide files; Presentation about SVG that you can use to test your installation and to learn more about SVG; Main (driver) stylesheet for building slides; Customizable stylesheet for slides." See the slide DTD.
[July 1999] XML Styler "was developed over a year ago to illustrate the potential of the XSL proposal submitted to the W3C by Arbortext, Microsoft and Inso. While Arbortext continues to be actively involved with the XSL specification through our representatives on the XSL Working Group, we do not have plans to upgrade this free tool. Arbortext will be incorporating XSL into its standard products, ADEPT and Epic, in upcoming releases."
XML Styler - ArborText tool for creating and modifying XSL stylesheets. Updated "XML Styler Version 2" ; see the XML Styler FAQ
XSL Templates by Example By James Tauber. 'This document briefly outlines some of the "real-life" templates I use for generating XMLSOFTWARE. The site is authored in XML and transformed to HTML using XT and a series of stylesheets (some of which are generated via other stylesheets). Here I have taken extracts that demonstrate the different things XSL can do, have ordered them in increasing complexity and added some commentary on what each does. The templates here follow the latest XSL Working Draft and work on the latest version of XT. I doubt all of them work on IE5b2.'
docproc - an XML + XSL document processor from Sean Russell. "docproc is a software package that provides processing and layout of XML documents based on XSL scripts. docproc is written in pure java, and can be used as a server-side preparser for serving XML documents on the Web."
[1998-12] XSL-Pattern is an implementation of the pattern subset of the XSL working draft 16-December-1998. Patterns are used extensively in the XSL transformation language and its control structures. They can be used outside XSL, too, for e.g., querying/selecting/matching parts of HTML/SGML/XML documents. XSL-Pattern is laid on top of PyDOM, the DOM implementation of Pythons XML special interest group. For parser construction, XSL-Pattern uses bison and Scott Hassans PyBison package." From Dieter Maurer.
Jade - James Clark's Jade (DSSSL Engine) implements some experimental DSSSL extensions - extended patterns that provide a superset of the semantics of XSL patterns. See the March 09, 1998 announcement from James Clark for the public availability of SP version 1.3 and Jade version 1.1; "in Jade 1.1 the main changes are the experimental extensions for XSL (documented in dsssl2.htm), and the use of XML for the FOT backend's output."
[October 14, 1998] Updated Koala XSL engine. The Koala XSL engine is an XSL processor written in Java, using the Simple API for XML (SAX 1.0) and the Document Object Model (DOM 1.0) API. Version 0.7b2 now supports the W3C Recommendation for DOM Level 1.0. There is new support for the parent anchor
(".."), and numerous bugs have been fixed. The software is available for download. Koala XML services including the Koala XSL engine are also accessible directly via the Web. Earlier: [September 09, 1998] From Jérémy Calles: an announcement for the second release of the java Koala XSL engine. It is "an XSL processor written in Java, using the Simple API for XML (SAX 1.0) and the Document Object Model (DOM 1.0) API. [The tool] now supports more matching patterns, more templates rules, more actions such as numbering, direct-processing, including stylesheets; [also] some examples of stylesheet that conforms to the XSL Working Draft 1.0. The distribution contains an XML SAX parser made by P. Le Hegaret (of the Koala team) and the DOM SDK 1.0 implementation from Don Park." A new release of Calles' XslSlideMaker is available in connection with the Koala XSL engine; XslSlideMaker is a 'post-processor that can allow anyone to make slides or modular slides in XSL andXML'.
[August 25, 1998] - See previous entry. Jérémy Calles posted an announcement for a first beta release of a Java XSL Processor. Though having several limitations, this is an "XSL processor written in Java that conforms to the W3C WD 1.0 (http://www.w3.org/TR/1998/WD-xsl-19980818), using the Simple API for XML (SAX 1.0) and the Document Object Model (DOM 1.0) API. The package also contains xslSlideMaker, a post-processor that can quickly make slides with XML and XSL."
XSL Authoring Studio, from ContentWare. "Soon" to be available in alpha version on the Web. It was demonstrated by Ray Cromwell and Shawn O'Connor at 'XML: The Conference' Developers' Day, March 27, 1998. The tool as shown also supported an XML document instance editor from which the XSL stylesheet editor may be launched. XSL Authoring Studio uses Lark and DocProc.
Work in progress: Francois Belanger is "working on an XSL Parser in Perl based on Sean Russell's docproc v 2, a Java XSL parser servlet..." [Perl-XML list, 19980422]
[January 11, 1999] Rick Ross (Activated Intelligence) announced the availability of an online demo page for AXSL - the Activated XSL Processor, being used 'to drive the Java Lobby website'. "AXSL is a compact, high-performance, all-Java XSL transformation and pattern-matching processor suitable for use in both client-side and server-side XML/XSL processing. AXSL is standards-based, portable, and reliable under heavy loads. It works with all major Java XML parsers, and it leverages the best characteristics of Java and XML to achieve a new level of performance in dynamic web content delivery. XSL is in production use today, dynamically generating hundreds of thousands of page views per month in real time at the Java Lobby website. AXSL is the cornerstone of the Activated Community system used to operate the Java Lobby site, and AC will soon be deployed at a broad range of other online community sites. AXSL fully implements the XML transformation and pattern-matching features of the W3C XSL Working Draft specification dated 18-August-1998. Activated expects to complete an update to support the new 16-December-1998 working draft within the next 2 weeks [viz., by about January 25, 1999]. AXSL does not implement the formatting objects sections of the XSL working drafts."
XSL:P 1.0 Beta is a free, open-source XSL processor written in Java. Currently [version 1999-07-20] the processor implements the XSLT WD 1.0 19990421 specification. The goal is to not only to create a free XSL processor, but make it fast and reliable. We plan on doing that with the help of those using the processor. We encourage people to download, use, and enhance the processor. I have done a lot of work on it, many people have contributed, but it is still a work in progress." See the docuentation, the FAQ document, and the list of cool projects which use XSL:P.
[January 19, 1999] Keith Visco has made the source code and latest version (v19990118) of XSLP available online. XSLP 1.0 Alpha is a "free XSL processor written in Java which implements the tree construction portion of the XSL WD 1.0 19981216 specification. XSLP has a number of non-standard feature extensions, including ECMAScript support.
[January 12, 1999] Keith Visco (The MITRE Corporation) announced the availablity of XSLP 1.0 Alpha (v19990111). XSLP is a free XSL processor written in Java, described as having been inspired by Sean Russell's Docproc. XSLP uses IBM's XML Parser for Java, and FESI for proprietary scripting. The documentation is now online, and the source code "will be available this week, released under an OSD complient license. . . Currently the processor implements the tree construction of the XSL WD 1.0 19981216 specification. The two main current limitations are Namespaces and sorting. I plan to have these done as soon as possible. There are a couple of non-standard features such as ECMAScript support as well as xsl:entity-ref."
[September 15, 1999] From IBM alphaWorks, XSL Trace "allows you to step through XSL scripts and shows you the transformation rules as they are created and the XML or HTML as it is generated. The IBM XSL Trace application reveals the mystery of XSL transforms! XSL Trace allows a user to visually 'step through' an XSL transformation script, highlighting the transformation rules as they are fired. Additionally, an XSL Trace user can view the XML source and the corresponding XML or HTML result in 'real time'. XSL Trace users can set and remove 'break points' on the style sheet and source document as well as highlight all source nodes processed by each style rule. The XSL Trace UI features an XML 'source based' collapsable 'tree view' with dynamic font resizing for 'Zooming' in/out to handle small/large documents. The XSL Trace application is for anyone who is developing XSL scripts for either the client or server and is a natural complement to LotusXSL. Indeed, XSL Trace is built on the new LotusXSL trace API jointly developed by the LotusXSL and Advanced Internet Publishing Teams. As a consequence, XSL Trace adheres to the latest draft of the W3C XSL specification."
[May 05, 1999] On April 22, 1999, Uche Ogbuji (FourThought LLC) announced on the Mulberry XSL Mailing List that a second public Alpha version of 4XSL has been released. "It fixes many embarrassing level problems with 4XSL 0.6.0, and now supports all XSL templates except for counters. Of course, now that W3C has removed counters, it's moot, and boy do we have a lot of work to do to match this week's latest draft. . . We've only tested it under Solaris and Linux, though." 4XSL is described as "a powerful XSL processor based on the [latest draft of the] W3C's XSL specification. One of its many uses is to render XML documents as customized and stylized HTML for browsing. 4XSL also provides a powerful programming API for applications to use for low-level, customized transformations of XML documents. The 4XSL 0.6.0 package is available for download.
XML::XSLT Home page. First release of this XSLT S2 parser written in Perl. Supports some basic xslt commands. XML::XSLT will convert the XML doc on basis of the template. It is written in Perl and works. However, at this moment it is not yet a module, but a script. Neither are all xsl command implemented. Nor is it fast. . ." Download version 0.1  of the script here. It requires the modules XML::Parser and XML::DOM which can be obtained from CPAN. Comments to: Geert Josten and Egon Willighagen. [snapshot 1999-07-26]
[May 07, 1999] Homesite XSL toolbar [which] I've developed for Homesite 4.0, so I'm posting it for anyone who has a desire to use... this has killed the tedium of writing >100 stylesheets... You can cut and paste it to "XSL.tbr" or access it from my site at: http://jabr.ne.mediaone.net/xmtp/xsl.tbr. By Jonathan Borden.
Summary: TransforMiiX is an XSLT processor which is not yet complete, but supports a good portion of the XSLT 1.0 recommendation. TransforMiiX was designed to be a "standalone" XSLT processor. This means you can call the processor from the command line, or via the XSLProcessor API. The only thing TransforMiiX requires is an XML parser, and the currently supported parser is Expat written by James Clark. There is currently an effort undergoing to integrate TransforMiiX with Mozilla. This effort is not yet complete and therefor the XSLT processor cannot yet be used within the Mozilla browser. Integration is nearing completion, however. Running TransforMiiX from the command line: The command line syntax is pretty straight forward. example: transfrmx -i my.xml -s my.xsl -o my.out This will process the XML source file called "my.xml" using the "my.xsl" XSLT stylesheet, and the result will be placed in "my.out". The "-s" flag is not required if the XSLT stylesheet is specified inside the XML source document using the "xml-stylesheet" PI (processing instruction). The stylesheet PI, should appear below the XML declaration (<?xml version="1.0"?>). See the README documentation; [cache version, 2000-03-29]
[December 18, 1999] "Keith Visco's C++ XSL engine... is now called 'TransforMiiX', and is located in the Mozilla CVS tree. Much of the source code was ported from XSL:P, an open source Java XSL processor written by Keith Visco. There were a number of contributors to XSL:P and therefor many of those contributors have indirectly contributed to this project."
[August 04, 1999] Keith Visco wrote on the XSL-List that "MITRE has a open source C++ XSL processor that will be released under the Mozilla public license 1.0, probably within two weeks. If you are interested in an early version I might be able to get you some code. Unfortunately I haven't done much documentation yet. If you are interested simply e-mail me back personally and I will see what I can do..."
[October 27, 1999] Vernon Imrich has posted an announcement to the XSL-List describing XSpLit and Rhythmyx tools. "Percussion Rhythmyx: a virtual XML data server, visual designer maps relational databases to XML, run-time engine serves data as either XML, HTML (via XSL), or binary content. Rhythmyx XSpLit - goes 'backwards' from HTML files to XSL and XML. You start with an HTML file containing both content and format, then add labels to define the content on the page (using straight text or the 'id' attribute of existing HTML tags). XSpLit parses the page, separating the content definition into an XML DTD and the formatting into an XSLT style sheet. The style sheet will thus produce an HTML page that looks like the original HTML but with any other XML content that conforms to the associated DTD. Supports repeated formatting for repeated XML fields, nested formatting, attributes, etc. XSpLit currently ships as part of Rhythmyx but can be run separately after the Rhythmyx installation."
[December 15, 1999] Takuki Kamiya (Fujitsu Limited) recently announced the release of an updated version of 'XPath Interface for XT' (Version 0.90). The 0.90 version of XPath Interface is now available for download. The XPath interface for XT "provides DOM query API facilities on top of XT. It is implemented in Java language and complies with W3C's XPath Proposed Recommendation as is currently [1999-12-15] implemented in [James Clark's] XT. Variable support in XPath is added in this release. Use the class VariableMgr to make your queries aware of variables."
[November 16, 1999] A posting from Takuki Kamiya (Fujitsu Ltd.) announces the availability of an XPath interface for XT Version 0.85'. The author says: "I have written an DOM query utility in Java on top of XT. It is implemented in Java language and complies with W3C's XPath Proposed Recommendation as it is currently implemented in XT. You can use it to retrieve DOM Nodes that matches to a given XPath selector. To use XPath interface for XT Version 0.85, [one would]: (1) Build a DOM Tree (i.e., org.w3c.dom.Document) by using a XML Parser; (2) Construct a DomQueryManager object with the DOM created in step '1'. (3) Invoke DomQueryManager's getNodesByXPath method by supplying a DOM Node and XPath selector string as arguments. I share the code with the community for free to see if anyone finds it useful... Free with no warranty. Comments are welcome. Any feedback is invited."
[December 15, 1999] posting from Khun Yee Fung announces the availability of a visualization tool for XPath. Khun Yee Fung writes: "I have written an XPath visualization tool. The tool allows you to choose an XML file as the initial XML document. The XML document is then shown as a tree (JTree in Swing). After that, you can specify XPath expressions and step through the execution of the expressions. The nodes selected in each step (can be a big step, a small step, or a baby step, or no stepping at all) are highlighted on the tree. A context tree is also presented so that the context of an XPath expression (like the context of a location path inside a predicate of another location path) can be shown. The execution stack of the context is also displayed when a context is chosen. The user can also select a node of the JTree as the initial context node of an XPath expression. This is how relative location paths are handled. The tool is meant as a learning tool for XPath. It implements nearly all the features of XPath, including the additional functions in XSLT. The tool uses the SAX and SAX2 interfaces from Xerces-1.0." The tool is available for download.
[September 18, 2000] XPath Visualiser. "This is a simple yet powerful tool for the evaluation of an XPath expression and visual presentation of the resulting nodeset. You type in your XPath expression and the returned nodes are highlighted, allowing you to experiment with XPath for finding the correct expression." By Dimitre Novatchev, from VBXML.COM. See the overview and README. See also XPath Visualiser: September  MSXML parser release support - "This is an upgrade to the original Visualiser download, which now supports the September MSXML Parser. Other new features are: 1. Namespace axis support. 2. Detecting and hi-lighting collapsed elements that contain some hidden selections. Visualiser download, which now supports the September MSXML Parser. Other new features are: 1. Namespace axis support. 2. Detecting and hi-lighting collapsed elements that contain some hidden selections..." download, [cache]
[September 25, 2000] See the 2000-09-25 announcement for Unicorn XSLT Processor, Professional Edition
[October 14, 2000] "XSLT extensions developed by Unicorn Enterprises are now published at our Web site. These specifications were created in order to achieve interoperability between XSLT and other information processing technologies. The following documents are available: (1) Object-Based Extensions in XSL Transformations; (2) Database Access Extensions in XSL Transformations; (3) Report Generation Extensions in XSL Transformations; (4) Text Input Extensions in XSL Transformations. These specifications can be found at http://www.unicorn-enterprises.com/#specifications or downloaded as a single ZIP file from www.unicorn-enterprises.com/xslext.zip"
[April 19, 2000] Alexey Gokhberg (Unicorn Enterprises SA, Switzerland) reports on the availability of the company's 'XSLT Processor'. "Unicorn XSLT processor implements XSL Transformations (XSLT) Version 1.0. The final W3C recommendation of 16 November 1999 (REC-xslt-19991116) is implemented. The current product version is 1.00.00. It should be considered an alpha release. The product is implemented in C++ and is currently running under Windows 95 and Windows NT 4.0. The recent binary distribution is available for downloading from the Unicorn Web site. UXT is currently using non-validating parser which does not process external DTD sets and external parsed entities. This may impose certain limitation on usablilty of those XSLT features that rely on DTD information stored in the external subset, though the features themselves are supported by UXT. The UXT XML parser supports UTF-8 and UTF-16 encodings. Relative URI are supported as required by REC-xslt-19991116. Fragment identifiers are not supported. The UXT processor may be started from the command line using the following command syntax, with exactly three arguments: uxt <source_document> <xslt_stylesheet> <result_document>..." See the README file for other details.
Unicorn Formatting Objects (UFO) "implements the substantial subset of the Extensible Stylesheet Language (XSL) Version 1.0 specification (W3C Workung Draft 27 March 2000). The product is optimized for composition of business-style documents (e.g., catalogs, orders, invoices, banking statements, etc). The extensive support is provided for various features (for instance, collapsing border model in tables), which are not yet supported by many existing XSL implementations. The product design was inspired by work of Sebastian Rahtz (JadeTeX, PassiveTeX) and James Clark (Jade). The renowned TeX typesetting system is used as the back-end formatting engine. The software can be used to generate output in PostScript, PDF and all other formats supported by TeX DVI drivers. The XSLT transformation engine, written in C++, implements the same functionality as the stand-alone Unicorn XSLT Processor. This module supports the transformation part of XSL processing. The XSL FO front-end, written in C++, transforms XSL FO trees into sequences of TeX macro calls. It provides numerous pre-processing functions that can be handled more efficiently in C++ rather than in TeX. The XSL FO back-end, written in TeX macro language, implements XSL FO transformation algorithms. The interface between C++ front-end and TeX back-end is well-documented. Alternative back-end implementations may be created by independent developers."
"The idea behind displets is to create a generic rendering browser that can load and activate little independent software modules tailored to create specific visualization objects. . . First the XML document is read and transformed by a normal XML parser into a internal tree representation using DOM. Then one or more layers of XSL stylesheets are applied to the DOM tree through the use of an XSL processor. This transforms the tree, at the end of all these passages, into another DOM tree that has an important property: for every element name in the tree there exist an available Java class, called displets, that provides the rendering. The XMLC application will then activate all the Java classes of the required displets, creating a tree of runnable Java objects."
A communiqué from Christian Bacher (SAXESS Software Design, Köln) reports on the recent release of VisWeb version 0.50, now available for download. Visweb is a "platform-independent XML and XSL based Shockwave/Flash encoder. The shockwave/flash format (SWF) is the most used vector graphics format on the web. It allows you to show complex but highly compressed vector graphics and animations in web browsers (netscape 4.5, IE 4.0 and higher). But generating SWF on dynamic websites is difficult, because it consists of unreadable bytecode. The solution is VisWeb: it provides a bridge between XML and the binary vector graphic format. Visweb consists of an XML/XSL based shockwave/flash generator which has an XML-interface called SWFML. SWFML represents the form of the binary shockwave/flash format and includes a couple of high level tags. The main features are: (1) Easy text generation: Visweb generates automatically the fonts into the SWF file; (2) High level shape support: Visweb supports the generation of high-level shapes like ellipses, rectangles, arcs, polygons etc... (3) Buttons and Actions support; (4) XSL support: Visweb includes a SWFML renderer for the 'formatting objects' (FOP) of XSL. Visweb makes it therefore very easy to render vector graphics via shockwave/flash. SWFML is designed to use as target format of XSL-Transformations..."
Petr Cimprich announced the release of Sablotron -- "a new open source XSLT processor written in C++ with the C and Perl API. This is a part of wider OS project, which claims to create a generic XML data distribution system... Sablotron is written in 'pure 100% C++' and is designed to be as compact and portable as possible. Thought it doesn't implement complete W3C recommendation yet, it does support a major subset and is a subject of intensive development now. Sablotron is available under the GNU license and is maintained as an Open Source project." Further documentation is provided in a manual written by Tomas Kaiser, and in a Sablotron FAQ document."
Bovone Stefano has posted an announcement for an early release version of an XML/XSL formatting engine. REXP is an open source project and everyone is welcome to collaborate on its development. "REXP, a Rendering Engine from XML/XSL into PDF, is an early implementation of a Formatting Objects engine. REXP is based on FOP version 0.9.2 (now Apache open source) and has been developed by the Department of Biophysical and Electronic Engineering (D.I.B.E. - University of Genoa) and Elsag S.p.A." The distribution with open source and binary files is available from http://www.esng.dibe.unige.it/REXP [= http://18.104.22.168/REXP/]. REXP documentation is also available on the Web site. REXP development is part of a larger endeavor being undertaken by the Electronic Systems and Networking Group (ESNG). "The project aims to investigate the use of XML/XSL for a hybrid mail system by Elsag S.p.A. A hybrid mail system receives electronic data as input and outputs physical letters for traditional post delivering. Printed letters are typically commercial statements from banks, insurance, utilities and public services, but the system is open to private citizens and can manage any type of documents. Elsag S.p.A. and the Electronic Systems and Networking Group of the Department of Biophysical and Electronic Engineering (DIBE) are working on the evolution of the system by studying new architectures and tools."
[June 15, 2000] Paul Tchistopolskii posted an announcement for 'Ux' in which 'UNIX meets XML'. "The source code of Ux framework version 0.1 is available at http://www.pault.com/Ux/. Summary: (1) Ux is UNIX, revisited with XML. (2) There is Java instead of C. (3) There is XSL instead of sh / awk / perl. (4) There is XML instead of \n and comma-separated ascii files. Ux is a consistent continuation of PXSLServlet project. PXSLServlet is a pipe of 3 components: Sql | XML | XT. In this sense, Ux version 0.1 is a prototype implementation of some universal container for pipes of unlimited length and complexity. If you like, Ux also could be called 'yet another open source XML/XSLT application server', or 'set of extensions to XT' or whatever. My final goal is somewhat re-implementation of UNIX toolbox, re-visiting some concepts of UNIX, XML, XSL and software development in general. The goal of this a bit premature publishing of Ux is to find some other people who may be interested in implementation of some well-known UNIX tools (like diff, grep, sed, etc. ) in XSLT. Version 0.1 is not the end of the story: there will be next versions. Future versions will include things like: extremely smart caching, per-node on-demand validation, plug&play ux-services, realy universal formatting objects, revolutionary efficient XSLT processing, automatic adjustment of the dataflows. To name a few. I don't know how long it will take to implement all of this. This is mostly very hard stuff. . ."
[March 09, 2001] Version 1.0 Alpha 5, February 2001, fifth Alpha release of Product Version 1.0. Use JRE 1.2 or later for compiler; any JVM for translets; BCEL 4.0.1 (formerly JavaClass 3.3.0). "The XSLT Compiler works by parsing an input XSL file and then creating a Java class file that performs the transformation instructions specified within the XSL file. After this one-time compilation, the output Java class, or translet, can be used repeatedly to transform XML files appropriate for the XSL file."
[July 2000] "The Sun XSLT Compiler is a Java-based tool that creates fast and lightweight Java class files for transforming XML files according to an input XSL file. The XSLT Compiler works by parsing an input XSL file and then creating a Java binary file that performs the transformation instructions specified within the XSL file. After this one-time compilation, the output Java class, or translet, can be used repeatedly to transform XML files appropriate for the XSL file. The benefits of this process is that the translet is faster and smaller than traditional transformation engines." See also the announcement, June 27, 2000.
"Whitehill <xsl>Composer is the next generation of web-enabling software. Whitehill <xsl>Composer can quickly be deployed as part of a development process that requires the generation of XSL. Using existing XML (extensible markup language), Whitehill <xsl>Composer automatically creates XSL/CSS (cascading style sheets), which can be used to render electronic bills, statements and reports." See the announcement of 2000-09-10.
XSLies - XSLT application for HTML presentations. "XSLies [pronounced: 'excess lies'] is a simple XSLT application for making Web-based presentations. It uses a simple XML input file to generate an HTML slideset. The resulting layout is completely customizable using XSL and CSS. XSLies is a simple XSLT application for making Web-based slideshows. I wrote XSLies in order to be able to quickly scratch together presentations on my Linux laptop... In order to use XSLies, you need the following: (1) the xslies-0.54.tar.gz package. (2) Java2 runtime environment and the Xalan XSLT processor, which is included in the XSLies package." From Sami Lempinen.
Napa. "Napa is a high-performance, progressive XSLT processor. In this first public release only the core of the XSLT specification is implemented but it is enough to perform simple transformations. A Windows EXE build is available for you to try out. This [0.3] release of Napa has been benchmarked against a number of other XSLT processors. It's currently running at about 2.5x quicker than its closest rival. The processor is also completely progressive. The transform and associated XPath expressions demand load the XML input file. This feature is very useful when rendering large documents..." Kevin Jones, October 31, 2000. [cache 2000-11-01]
[October 10, 2003] Antenna House Issues Major Upgrade to XSL Formatter for High-Quality Print. The XSL Formatter from Antenna House has been released in version 3.0, incorporating "an entirely new formatting engine developed from scratch." The XSL Formatter V3.0 application implements an XSL-FO (Extensible Style Language-Formatting Objects) processor meeting the specifications of the W3C XSL Recommendation. It supports the formatting of XML documents for production-quality printing and output to PDF. According to the announcement, XSL Formatter V3.0 "formats large XML documents, data, and forms with high speed; V3.0 is the fastest XSL Formatter available and is significantly faster than XSL Formatter V2. Version 3.0 has newly developed SVG support to retain the vector information for the output module, thus meeting the increasing demands for SVG delivery and viewing. The new V3.0 formatting engine has been designed to be able to format virtually any size of document; this design overcomes the V2.X limitation of approximately 4,000 pages in a single document so that v3.0 is able to format about 10 times as much content as XSL Formatter V2. The new version supports direct streaming of both the input FO and output PDF; since it does not go through a temporary disk file, system integration is easier and moreover is safer. Command line, COM, .NET, Java, and C++/C interfaces are supported. The XSL Formatter Hyphenation Option makes it possible to hyphenate 40 or more languages without preparing dictionaries. " An evaluation version for XSL Formatter V3.0 is available for download.
An announcement from keiko hiraide of Antenna House, Inc. describes the new Version 2.3 release of XSL Formatter.: "Antenna House, Inc is pleased to announce that it has upgraded its XSL-FO processor [XSL Formatter] to V2.3. Version 2.3 provides you with the significant enhancement of layout function capability, multilingual formatting function capability. XSL Formatter V2.3 becomes the most advanced XSL tool for multilingual formatting in the world. Version 2.3: (1) Implements the float in XSL Spec and enhances the layout function. This function provides capabilities of produce the layout of putting images, illustrations and text side-by-side or putting text around the image. (2) Enhances the function of multilingual format. XSL Formatter implements the function of bidirectionality by Unicode BIDI, the text running from left to right as English, Japanese and the text running from right to left as Arabic, Hebrew can be mixed in a single block with mixed directionality. In addition, Arabic justification becomes capable by inserting the glyph 'Kashida'. (3) Provides new support for Arabic and Hebrew: By using XSL Formatter V2.3 and PDF Option, it's possible to do layout the multilingual publications with the flexible mixture of Latin, Cyrillic, Greek alphabet, CJK (Chinese, Japanese, Korean), HAT (Hebrew, Arabic, Thai) and output to PDF. (4) Offers enhanced PDF output options: In case of creating PDF using Adobe Acrobat Distiller from XSL Formatter formatted result, a high quality PDF will be created. From V2.3, links and bookmarks are automatically created in PDF using Distiller. In addition, both EPS with preview image and EPS without preview image can be embedded in PDF via Distiller. (5) Provides graphics support enhancements: By using Plug-in (MathPlayerV1.0) downloadable, the formula written by MathML can be embedded. XSL Formatter supports almost every image formats for Windows..."
Antenna House XSL Formatter. "XSL Formatter consists of 'Formatter engine' and 'user interface.' 'Formatter engine' formats FO and output to Windows' GDI. XSL Formatter runs its engine by specifying XML document instances and XSL-FO Style Sheet. XSL Formatter needs XSL-FO. Features: (1) W3C XSL Candidate Recommendation 21-November-2000 is supported; (2) runs on Windows 95/98/Me/NT4/2000. (We recommend NT/2000. MSXML 3.0 is required. Download); (3) easy to use, web browser like user interface: specify XML-document and XSL-stylesheet URLs, click [Run Formatter] and you get the formatted results on screen, and [Print] to print or create PDF file (using PDFWriter or Acrobat Distiller). If you want to browse XSL-FO directly, specify its URL (or path name) to XML-document box and leave XSL-stylesheet box blank..." Contact: MURAKAMI Shinyu.
[November 26, 2002] Note the jEdit Plugin for RenderX XSL Formatter XEP.
[November 08, 2001] XEP Rendering Engine from RenderX Supports the W3C XSL FO Recommendation. A posting from David Tolpin announces the availability of the RenderX XEP Rendering Engine release 2.7 as an evaluation version. XEP is "an engine that converts XSL FO documents to a printable form (currently PDF or PostScript). It can be used as a component in applications that need to generate high quality printable documents from data represented in XML. XEP is a native-mode XSL FO processor: the whole procedure of calculating the layout of every page is performed inside, without recurring to any third-party formatting engines like nroff, TeX, or whatever else. Native mode processing gives you considerable advantages in flexibility and cross-platform portability." XEP version 2.7 now implements the last version of the W3C XSL specification, viz., the XSL Recommendation of October 15, 2001. It offers enhanced functionality, documentation reformatted in DocBook, and includes a stylesheet which converts XSL CR documents to the final XSL Recommendation. [Full context]
[July 06, 2001] XEP 2.5 Released. See also the list of enhancements in the XEP 2.5 announcement.
'XEP' XSL Flow Object (FO) Rendering Engine, from RenderX. Nikolai Grigoriev (RenderX) has announced the release of an updated version of XEP, a XSL Flow Object (FO) Rendering Engine for converting XSL FO documents to either PDF or PostScript. XEP Version 2.01 is now available for download from the RenderX web site. "The web site itself has also undergone major changes in both the design and the contents. All examples and demos are now conformant to the last XSL FO version (Candidate Recommendation). The new version of XEP has several improvements as compared to the previous one (XEP 1.02): (1) it supports the fresh XSL FO specification (Candidate Recommendation of 21 November 2000); (2) additional XSL FO functionality has been implemented; (3) the code has been optimized to run faster; (4) native PDFlib library calls have been replaced by pure Java code; (5) font support is greatly improved [user fonts can be embedded; Unicode support is consistent and versatile]; (6) documentation has been improved: it now includes an XSL FO primer; (7) Ant-based installation script is provided; (8) extra examples and tools are included in the distribution [FO-to-HTML stylesheet; migration stylesheet to convert XEP 1.02 files to XSL FO CR.] New tests have been added to the Test Suite. Those include a number of non-English examples (Armenian, Polish, Russian, Old Italian sample texts) that may be of particular interest for international audience... XEP is a native-mode XSL FO processor: the whole procedure of calculating the layout of every page is performed inside, without recurring to any third-party formatting engines like nroff, TeX or whatever else. Such an approach is sometimes more difficult to implement: e.g., coding an algorithm for footnotes placement on a multi-column page has never been easy. On the other hand, native mode processing gives you considerable advantages in flexibility and cross-platform portability."
"Xsldoc. Rick Maddy announced on 4 Jan 2001 that Xsldoc version 0.92 was available. Xsldoc is a tool written in Java that parses the declarations and documentation comments in a set of XSLT source files and produces a set of HTML pages describing the stylesheets, templates, and global variables. The output is very similar to Javasoft's Javadoc tool for those who are familiar with this Java tool. In order to use Xsldoc you must have JDK or JRE version 1.2 or greater installed on your computer. The download includes a Java Archive (jar) that must be added to your CLASSPATH environment variable. Once added you can run Xsldoc on a set of XSLT source files to produce HTML documentation. Version 0.92: (1) Display stylesheet parameters in the stylesheet description area; (2) Display the XSLT specification version in the stylesheet description area; (3) Display stylesheet output method in the stylesheet description area; (4) Now look for files ending in .xslt in addition to .xsl; (5) Added an example on the website."
XSLTDoc "helps you browse a set of XSLT stylesheets. It gives four views: (1) a tree of the imported/included stylesheets; (2) a summary of the top-level elements in the selected stylesheet; (3) a view of the source of a selected top-level element; (4) a description of the functionality of a selected instruction or literal result element. You need MSXML3.0 (release version) installed in replace mode and IE5+. Unzip XSLTDoc.zip into a folder and open xslt-doc.xsl in IE. You will be prompted for an XSLT stylesheet to view; enter the absolute filename or a URL..." See the announcement. [cache 2001-01-15]
Daniel Veillard posted information about an XSLT C Library for Gnome (libxslt) now under development. The XSLT C Library for Gnome (libxslt) is being released as a "first beta" version. Key points: (1) Libxslt is a C implementation; (2) Libxslt is based on libxml for XML parsing, tree manipulation and XPath support [see "The XML C library for Gnome"]; (3) It is written in plain C, making as few assumptions as possible, and sticking closely to ANSI C/POSIX for easy embedding. Should works on Linux/Unix/Windows; (4) The library is released under the GNU LGPL. Both the C library and libxml-2.3.0 are available at http://xmlsoft.org/. Online resources for using libxml include on-line resources about : the API documentation automatically extracted from code comments (using gtk doc) and the mailing-list archive.
[February 15, 2001] Libxslt-0.2.0 is the second beta release. The embedded xmlproc test program allow to run non-trivial transformations. For example it is possible to regenerate the HTML version of the XML-1.0 spec using the original XML file and the XSL stylesheets (linked from appendix I of the XML spec). The parts missing are: Extensions support, Embedding Stylesheets, document() and key() are incomplete. A quick grep on FEATURES indicates 151 YES and 14 NO.
[June 20, 2001] Version 2.0 release. XSLT-process is a minor mode for GNU Emacs/XEmacs which transforms it into a powerful editor with XSLT processing and debugging capabilities. With this mode you can: (1) run an XSLT processor on the Emacs buffer you edit, and view the results either in another Emacs buffer or in a browser. (2) run an XSLT processor in debug mode and view what happens during the XSLT transformation. You can set breakpoints, run step by step into your stylesheet, view global and local XSLT variables and many more. Currently the Saxon and Xalan Java XSLT processors are supported, and the mode comes out of the box configured to use them. The package has been tested on XEmacs 21.1.14 and GNU Emacs 20.7.1, under both Linux and Windows 2000. The package is free software and is distributed under GPL."
[February 20, 2001] Ovidiu Predescu announced the version 1.2 release of XSLT-process. XSLT-process is "a minor mode for (X)Emacs that allows you to invoke an XSLT processor of choice on a buffer, displaying the result in an additional buffer. Currently supported processors include Xalan 1.x, and Saxon 5.x and 6.x. Cocoon 1.8.x, an XML publishing framework, is also supported through its command line interface; support for other Java XSLT processors could be added easily." Changes include additional support for the TrAX interface, support for GNU Emacs on Windows NT/2000, modified keyboard bindings, and enhanced documentation.
[March 23, 2001] IBM's XSLerator Tool for XSLT Script Generation. The Java Application Development at IBM alphaWorks laboratory has released an XSLerator (XSL accelerator) tool which "generates XSLT scripts from mappings defined using a visual interface. The tool supports mappings with extended conversion functions including iterations, conditions, joins, variables, and XPATH functions. Only minimal knowledge of XSLT is required. XSLerator can be used in e-business solutions development including B2B, B2C, and web services. For example, it can be used to integrate and correlate diverse data sources to one unified data, or it can be used to transform data from one business' format to another business' format. XSLerator can be also used by content providers to provide content in different formats for different modalities and users. Using the tool, you provide the sources and the targets which can be retrieved from XML files or from databases. Then, you define mappings; each mapping is a selection of a target field, a conversion function and sources fields. Mappings can be edited, deleted or persisted for later use. After defining the mappings, you generate the XSLT script and may test it to confirm it created the desired output. Once the XSLT script was generated, you may use it with an XSLT engine, such as Apache Xalan, to combine and transform any XML documents that conforms to the sources to an XML document that conforms to the target. XSLerator is provided with samples and a tutorial." [Full context]
Joshua Lubell (NIST) announced the creation of an open source toolkit designed to "help developers avoid the drudgery of writing the complicated XSLT transforms often needed to integrate XML applications." The software has been developed within NIST's Manufacturing Systems Integration Division (MSID). The 'XSLToolbox' toolkit "currently contains two tools, both written in XSLT: (1) APEX is an application for transforming XML documents as specified by architectural forms; (2) ATTS is a stylesheet generator for adding default attribute values to XML documents. Unlike some other XSLT libraries, the XSLToolbox is specifically geared toward XML data exchange between applications rather than conversion of XML to human-readable data formats." APEX as a generic architecture engine processes "architecture support attributes which describe how its elements, attributes, and data correspond to their architectural counterparts governed by the architecture's architectural forms. [This allows the designer to:] extend XML vocabularies without breaking existing applications; to create architecture-specific document views, retaining only relevant markup and character data while hiding all other content; and to promote data sharing between user communities with inconsistent terminologies by enabling the substitution of identifier names and by allowing simple document transformations. Input to APEX consists of an XML document plus stylesheet parameters identifying an architecture used by the document. APEX produces as output an architectural document, i.e., an XML document containing only the markup and data defined by the architecture specified. ATTS provides an XSLT meta-stylesheet for assigning default attribute values to an XML document. ATTS is intended for XML applications lacking a convenient method, such as a DTD (document type definition), for specifying attribute defaults. Since the attributes that control architectural processing are usually fixed, ATTS can be used to supply their values. ATTS is therefore handy for DTD-less applications using APEX."
A posting from Mark Tracy announces the availability of MarrowSoft Xselerator XSLT Editor version 2.0, with a free 30-day evaluation. Xselerator is a fully functional XSL/XSLT IDE and debugger which "incorporates XSL/XSLT/XML editing, transformation, testing, and debugging...basically it's got everything an XSLT Editor should have plus a bit more. Editing functionality supports (1) a clear and easy to use IDE, (2) XSL/XSLT element and attribute intuitive (like Intellisense or code insight) drop-downs, (3) Automatic tag completion -- in XSL/XSLT tag completion follows model and, optionally, fills element with mandatory attributes, (4) HTML element and attribute intuitive drop-downs, (5) Full XSL, XSLT, XML and HTML color syntax highlighting -- fully customizable, (6) All the usual editor capabilities (cut, copy, paste, find, replace) plus special 'Copy as RTF' and 'Copy as HTML' features allowing syntax highlighting to be preserved when copying and pasting to word-processors, html editors and newsgroups etc. The XSLT debugger has full stepping capability, breakpoints on both XSLT and input XML, conditional breakpoints, view template call stack, watch values -- including full XPath expression watches, and support for MSXML3 transformations. The software supports transformation testing, wizards, XPath query analyzer, project files management, etc." See discussion.
TIBCO Extensibility Releases XML Transform 1.0.0. TIBCO Extensibility has announced the version 1.0 release of XML Transform. "XML Transform is a comprehensive design solution for creating and debugging complex XSLT stylesheets. As an enterprise-grade XSLT development platform, XML Transform provides an interface for solving real-world data transformations while ensuring flexibility and portability through utilization of open standards. Through its industry-leading schema support, intuitive interface and debugging environment, XML Transform offers users with the most advanced XSLT development solution available. The TIBCO Extensibility platform offers enterprises a complete solution for developing and deploying XML-based business processes. Organizations can now fully leverage the flexibility and portability of XML through use of TIBCO's XML platform comprised of the following industry-leading solutions: (1) Turbo XML for creating and editing XML, schemas and DTDs; (2) XML Validate for validating and processing XML in a run-time environment; (3) XML Transform for mapping and transforming XML documents (4) XML Canon/Developer for storing, managing and distributing XML assets..." See also the 2001-08-14 announcement.
A posting from Fabrice Desré (France Telecom R&D/DMI/GRI) announces the availability of an XSLT stylesheet documentation generator tool. XSLTDoc is itself "an XSLT stylesheet that analyzes another stylesheet, builds clean documentation on it, and also makes some sanity checks. The stylesheet has been developed and tested with xsltproc, part of the 'libxslt' XSLT C library for Gnome. The documentation generated will: (1) show global parameters; (2) show global variables; (3) list all the templates; (4) for each template it shows parameters, variables, templates called via <apply-templates/> from the current one, and templates called via <call-template/> from the current one, checking parameters; (4) builds a cross-reference matrix of called templates; it emits warnings if a named template is never used; (5) in several situations, it tries to show the relevant comments..." See the announcement.
XFC from IBM alphaWorks. IBM's XSL Formatting Objects Composer (XFC) is "a typesetting and display engine that implements a substantial portion of XSL Formatting Objects (FO), which became a W3C Recommendation on October 15, 2001. XSL FO is an XML language for typesetting, printing, or displaying any of the world's written languages. XFC produces either an interactive onscreen display using Java2D or an output file using PDF. A single formatting engine drives both Java2D and PDF output through a common interface, making XFC the world's first output-independent processor of XSL FO. Other outputs are possible, and some are being developed. XFC is a Java program, developed with JDK 1.3 and released with the run-time component of the IBM WebSphere preview technologies for Windows Developer Kit." See the table of supported features. [Full context]
The FOA 'XSL-FO Authoring tool' is a "Java application that gives users a graphical interface to author XSL-FO stylesheets. With FOA you can generate pages and page sequences, and fill them with content provided from one or more XML files. FOA will generate the XSLT stylesheet that transforms the XML content into an XSL-FO document. FOA is compatible with WH2FO so you can author more quickly you documents. From FOA GUI is also possible to invoke an XSLT processor and an XSL-FO renderer, so you can see how the document looks like..." See also the FOA Sourceforge Project Page.
On 2002-11-01 Bob Schloss (IBM) reported on the availability of software to perform "high quality printing of XML documents using XSL stylesheets and the XSL-FO vocabulary, using the existing AFP (Advanced Function Printing) support for z/OS. The Infoprint XML Extender for z/OS enables XML applications to be printed on AFP printers using standard XSL formatting. AFP is the de facto standard solution for mission critical business output in many large enterprises. Producing an AFP document from XML data is a two-step process. First the XML document is transformed using an XSL style sheet into an intermediate XML document, referred to as an XSL Formatting Object (XSL-FO) document. The XSL-FO document is then composed by Infoprint XML Extender into an AFP document. Because of this two step process, Infoprint XML Extender can accommodate either XML documents with companion XSL style sheets or XSL-FO documents as input into the production of AFP, providing a highly flexible formatting solution for XML-based applications." See other references in the news item.
See: XSL-FO Implementation in the Sun xmlroff XSL Formatter SourceForge Project.
Sun xmlroff XSL Formatter: Tony Graham (XML Technology Center, Sun Microsystems Ireland) gave a presentation on 2002-12-11 at the XML 2002 Conference on the topic "Sun XSL Formatter Goes Open Source": 'A new XSL formatter developed by Sun Microsystems is being donated to open source. This session is the public introduction of the formatter and the first call for participation to join in the further development of this exciting new software..." An update notice posted to the XSL lists added the following: "The Sun xmlroff XSL formatter is written in C, and it uses libxml2 and libxslt plus the GLib, GObject, and Pango libraries that underlie GTK+ and GNOME (although it does not require either GTK+ or GNOME). The formatter currently produces PDF output only. xmlroff is a command line program, but the bulk of the XSL formatting is implemented as a libfo library that can be linked to any program that requires XSL formatting capability. It will be available under a BSD license. It is being developed on both Solaris and Linux. The formatter is awaiting final approval before the code can be made public source. An announcement will be made on xsl-list, www-xsl-fo, and XSL-FO@YahooGroups once the code is available..."
"The internationalization support library from ISOGEN International LLC is "a Java package that demonstrates basic document internationalization services for use primarily with XML editors and formatters. It was originally driven by the need to centralize the definition of, and access to, generated text generated by style sheets for XML documents, but could be useful in any context in which translations of strings are required. It allows, for example, multiple style sheets to share a single database of translated terms and phrases. It also keeps the text strings separate from the style sheet code, reducing the cost of creating and maintaining the generated text and its tranlations. The demonstration package includes a generic base library which can then be integrated with different tools through thin Java binding layers. The demonstration code includes a Saxon binding but this code has also be integrated with the Epic XML editor as well as other XSLT engines. The library provides the following services: (1) Access to translations of fixed text strings (as would be used in style sheets for generating print or HTML renderings of XML documents). (2) Access to back-of-the-book index configuration information (primarily for use by XSLT transforms, but potentially usable by other processors). (3) Access to language-specific Java Collator objects, dynamically configured by the active index configuration. (4) Miscelaneous services needed by style sheets that work with multi-language documents..."
At Seybold San Francisco 2003, Advent 3B2, a leading supplier of standards-based publishing software, announced a new, quality-oriented, Extensible Stylesheet Language Formatting Object (XSL-FO) rendering engine called 3B2-FO. Advent 3B2-FO software supports both simplified yet flexible document production workflows for adding composition and page formatting information to XML documents so they can be printed. In operation 3B2-FO takes either ready-made XSL-FO files containing layout and formatting data, or files containing raw XML content plus an XSLT transformation script, and converts them into printable Postscript or PDF files. Advent 3B2-FO software was developed in accordance with the W3C XSL 1.0 recommendation of October 15, 2001. In addition to providing compliance with the W3C XSL-FO specification, the software engine includes a number of additional functions that provide extended composition and page layout controls. These will give users more versatile document formatting capabilities resulting in higher quality document aesthetics. The additional capabilities in 3B2-FO include controls over vertical justification on a page, extensive hyphenation controls, and the ability to add crop marks and registration marks to a page. Hyphenation features include the ability to specify the number of characters in words that can be hyphenated, the ability to prevent hyphenation at the end of a block and to use caps to keep capitalized words together, spacing controls (plus and minus) for letter and word spacing of text. Advent intends to add additional extended functionality to 3B2-FO over time..."
Lunasil has just released [2003-10-15] its Beta version of Xinc, an XSL-FO processor. Xinc is very fast and requires very little memory. A Swing based XSL-FO viewer allows you to view and print XSL-FO files as well as generate PDF files with the click of a button. Xinc can be used as a server component via its Java API. Xinc can also be used in a Microsoft server environment by using its COM interface. New features include hyphenation, basic-link, PDF output, memory/speed optimizations, COM interface and bug fixes. If you would like to try the Beta version, please go to the downloads section. We are very interested in hearing all feedback. Please send all comments and bug reports to firstname.lastname@example.org... The Xinc code was written from the ground up. The only pieces which come from Apache's FOP project are the PDF renderer and their hyphenation engine." See also the conformance statements for Formatting Objects. Announcement posted by Greg Gaffney (Lunasil Ltd).
On March 23, 2004, XyEnterprise announced a new style creation tool and support for XSL-FO in its leading XML publishing software — XML Professional Publisher (XPP). XPP is used for automated and interactive publishing in XML publishing environments, providing unmatched support for XML content, automated rendering, and Web Services integration. The new features will enable customers to enjoy further productivity gains and standards support from the world's leading automated publishing engine. XSL-FO, a recommendation from the World Wide Web Consortium (W3C), is a standard way to describe rules for formatting XML content. XPP will apply an XSL stylesheet to an XML instance, and use this information to render XML content to Postscript or PDF output. Users will have access to the robust and unmatched publishing capabilities of XPP that supplement the XSL-FO standard, including the ability to interactively edit the formatted file, control the placement of graphics, and apply sophisticated controls for page and column balancing, hyphenation and justification, and complex tabular formatting..." See "XyEnterprise Announces Support for XSL-FO and a Web-Based Style Editor for XML Professional Publisher. New Offerings, Enhancements Create Significant Advantages for Standards-Based Publishing."
|Receive daily news updates from Managing Editor, Robin Cover.|