Internet Forms

2008-11-25T22:16:00.006+13:00

I have not blogged for a while, in truth have just been busy. Thought I would share some experiences with the world.
First the news.
Mozzie 1.8 is still going well, probably because I have left it alone ;-)

There is a new version, it runs on Firefox 3 and incorporates all of the new stuff being done by the team working on the XForms plug-in, as well as some goodies. It will be called 2.9 to keep with the tradition of incremental releases.
So what will be in it:

All of the latest trunk of the Mozilla XForms
Extra functions for xpath (choose, etc) as well as some xslt functions.

One of the areas where the xforms implementation differed from the mozilla code base was that repeats could be represented as tables. With Firefox 3.0 this is no longer needed as you can use css to do the same thing.

Expect this early next year.

The other side of the coin is what has been keeping us busy, and that has been our SAAS/PAAS (should it be called S-PAAS?) which is an XML platform for delivering services.

It is intended to not be an open source product rather than it is targeted at ISP's who don't want to loose their customers to Amazon/Google/MS-Azure platforms. It is a an XML standards based platform for collaborative software delivery.
The only issue is that one of the core technologies is XProc and the standardization of that is taking a while.
The idea is that it is an SOA platform with a standards flavor,so that you can move between any ISP with pure XML markup (no code or library dependencies).

It will be released at the same time as Mozzie 2.9 as that forms a core component of the forms delivery platform.

I will blog over the next few months with the details. For now keep using XForms and XML standards....

Mozzie 1.8.0 Released

2007-09-18T10:06:00.000+12:00

We have been using release 1.8.0 quite a bit now and think it is stable enough to release for more testing and comments.
There are 2 releases:

MozzIE.1.8.0.xpi
This is an XPI that allows testing of forms within Firefox 2.0.0.6
Since there are a lot of extension functions and new capability that is not in the Firefox version, this will help anyone developing to test forms.

MozzIE.1.8.0.exe
This is the Internet explorer plug-in that will add XHTML+XForms support to Internet Explorer. It includes the xforms engine that is packaged within the XPI.

The major features of this release are:

Code from the Mozilla Project Xforms 0.8 has been merged into the project.
EXSLT functions have been implemented for math and date.
Some xforms 1.1 functionality is complete (most notably if() and while() on actions).

Please try this release.

MozzIE 1.7.1

2007-05-05T11:56:00.000+12:00

I have changed the numbering conventions on the MozzIE project. The change is to make it more aligned with the core XForms project that MozzIE comes from. The release numbers now represent the XForms plug-in for firefox build numbers. So 1.7 is based on the 0.7 Firefox XPI.
When the Firefox buuild changes for 0.8 hit the Mozilla tree it will take me a couple of days to pull the changes into MozzIE and release 1.8.
The minor build number (1.x.m) is the MozzIE release number.
There are some additions to MozzIE not found in the Firefox releases. Here is a list:

1. Repeats are fully implemented and all of the W3 tests pass. We also support having repeats as a table body.
2. Schema validation and types work for attributes as well as elements.
3. The XForms 1.1 functions of days-to-date(), second-to-dateTime(), local-date(), local-dateTime() and digest() are implemented. The other 1.1 functions are stubbed out but will be working in 1.7.2.
4. The bind(IDREF) function is implemented, this is slated to appear in xforms 1.2 but I found it so useful that I decided to implement it sooner. It really tidies up the XForms code. The only thing you need to be really careful of is that you don't create a circular dependency.

XProc XSD

2007-03-15T14:26:00.000+13:00

I have done an XSD for XProc and placed it into the Visual Studio Intellisense zip file located in the XSP.NET Files Wiki page.
Unfortunately the xproc working group has decided to base the syntax on RELAX NC rather than schema definitions. Just when the community was getting used to something (xml schema) some bright spark thinks of something to make everything different again!
Also located there is a small xhtml page that demonstrates using xproc to format an xform at the server. This is intended to be a test case only (actually one of the unit tests of XSP.NET 2.0) but it shows how XProc can be used to perform what would have been done using scripts in the past.
XSP.NET 2.0 is coming along well, and the pipeline is already implementing the following:

xml
xml:lang
xml:base
exslt:dates-and-times
exslt:common
exslt:math
exslt:random
exslt:regular-expressions
exslt:sets
exslt:strings
xml:xpointer
xml:xinclude
xml:xproc

The xproc processor is not complete yet and the XSP.NET Community Portal has quite a bit of info about how the processor hangs together.

XForms Intellisense for Visual Studio 2005

2007-03-07T13:59:00.000+13:00

I find Visual Studio to be a great development environment, and even better when you can edit your source code files with Intellisense.
Visual Studio 2005 added support fo XML intellisense using the xml\Schemas directory however the supplied xhtml.xsd file did not support xforms intellisense for xhtml files. So I did something about this and modified the xsd to be xforms 1.1 aware:

As you can see when I create a file with the correct namespace declarations and the XHTML 1.1 strict DTD, the xml editor now knows that a <head> can have an xforms:model and within that it supports an xforms:instance (also note that the document annotations are available).
Rather cool I think. I don't really see xforms as being a wysiwyg language, much the same as writing c++ code using uml is like poking yourself in the eye with a sharp stick. You can do it, but it will hurt :->
I have uploaded the file Schemas.zip to the xsp.net wiki. The page to look at is the Files page.
Extract the contents (all of the xsd files) to the directory:
C:\Program Files\Microsoft Visual Studio 8\Xml\Schemas
(this could be different if you did not install visual studio to the default location).
I do not recommend trying to develop xforms using aspx pages rather use xsp.net and do all your markup as strict xhtml. The highlighting does not work very well if you are using an html dialect and miss the correct namespace declarations.
I will be updating this as XSP.NET becomes XProc compliant (and XProc becomes a reality). I am doing a port of the appache XML:fop project to xsp.net so will also be adding the support for XML:FO to the schemas soon. Will post when this is complete.

XSP.NET and MozzIE Wiki

2007-02-27T09:23:00.000+13:00

I have converted the XSP.NET and MozzIE sites to using mediawiki.
The sites should get more content on how to do XForms/XHTML and XProc over the comming weeks.

MozzIE Beta2

2007-02-06T22:50:00.000+13:00

A beta release for Version 2.0 of MozzIE has been posted to sourceforge.
This release is built against the Gecko 1.8 rendering engine which is the same as is used in the Firefox Release 2.0.0.1 and the xforms is the 0.7 release of the firefox xforms engine.
There are patches however to add schema support for attributes as well as using repeats as a table body.
On the trunk of the Firefox browser, both of these are nearing inclusion into the xforms installer. This will come back to MozzIE in release 3.0 which will use the Gecko 1.9 engine and what is hopefully a fully xforms 1.1 compliant processor.
MozzIE will probably have 1 more Beta, not that any rendering functionality will change, but there is initial support for the 3 tools that are essential for xforms development. Venkman, the javascript debugger which makes making XBL controls a snap. The DOM Inspector which is a must for any serious XHTML work and the error console. Hopefully we will also get the xforms buddy which was created by Allan Beaufour.
The tools do not yet work 100% as there is problems with the javascript engine that I have not had time to sort out.
The real goal of this release was to get the stable version of Gecko into the build and to make the GUI complete, even if there are some issues.
Please download and enjoy.

XBL in forms

2007-02-01T16:14:00.000+13:00

One of the nicest features of MozzIE and Firefox is XBL. I use this a lot to bind custom renderings to xform controls. This example changes the default xf:output to one that if you put an html:mediatype with a type of text/html will render the contents as an HTML fragment.

Firstly we create 2 files which will hold the XBL.

html-output.xml:

<?xml version="1.0"?>
<bindings xmlns="http://www.mozilla.org/xbl"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns:xhtml="http://www.w3.org/1999/xhtml"
xmlns:xbl="http://www.mozilla.org/xbl"
xmlns:xforms="http://www.w3.org/2002/xforms"
xmlns:mozType="http://www.mozilla.org/projects/xforms/2005/type">



<binding id="mozzie-xformswidget-output-html"
extends="chrome://xforms/content/xforms.xml#xformswidget-base">
<content>
<children includes="label"/>
<xhtml:span anonid="content" />
<children/>
</content>

<implementation>
<field name="_escapeUpdate">false</field>
<method name="refresh">
<body xmlns="http://www.mozilla.org/xbl">
var textSpan = this.ownerDocument.getAnonymousElementByAttribute(this, "anonid", "content");

var doc = this.ownerDocument;
var r = doc.createRange();
r.selectNodeContents(textSpan);
r.deleteContents();

var val = this.stringValue;
var df;

if(val.length != 0)
df = r.createContextualFragment(val);
else
df = doc.createTextNode(String.fromCharCode(0xa0));

textSpan.appendChild(df);

return true;
</body>
</method>

</implementation>
</binding>
</bindings>

and a corresponding css file:

@namespace url(http://www.w3.org/2002/xforms);
@namespace html url(http://www.w3.org/1999/xhtml);
@namespace mozType url(http://www.mozilla.org/projects/xforms/2005/type);

/* replace output with one that handles html mediatype */
output[mozType|type="http://www.w3.org/2001/XMLSchema#string"][html|mediatype="text/html"]
{
-moz-binding: url('xforms.xml#les-xformswidget-output-html');
}

Now we include these into out xform (not all code is shown here).

<?xml version="1.0"?>
<html xmlns:ev="http://www.w3.org/2001/xml-events"
xmlns:xforms="http://www.w3.org/2002/xforms"
xmlns:xhtml="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">
<head>
<link rel="contents" href="html-output.xml" />
<link type="text/css" rel="stylesheet" href="html-output.css" />

</head>
<body>
<xf:output bind="..." mediatype="text/html">
<xf:label>HTML Text</xf:label>
</xf:output>
</body>
</html>

When rendered the contents of the bind will be interpreted as HTML and displayed. This technique can be applied to other markup to display SVG for example.

XSP.NET

2007-02-01T11:37:00.000+13:00

The first release of XSP.NET is available on sourceforge.
XSP.NET is an HTTP Handler and build provider for .NET version 2. The important point about XSP.NET is that it understands schemas and xforms instances when rendering xhtml pages. It is identical in concept to ASPX pages in that the markup is parsed and a temporary assembly is created to render the pages.
The obvious question is why write another version of an aspx page. There are several reasons.

ASPX pages and asp.net controls are HTML based. Although you can ask for an aspx page to render as strict xhtml many controls do not work as expected.
The MozzIE plug-in and Firefox browsers need a content type of application/xhtml+xml and if you configure each aspx page to be served as this then most stop working. So you have a lot of work to do to configure your web site.
ASPX uses master pages and processing instructions to generate pages, and most controls have lots of embedded javascript. This does not lend itself very well to server-side xml processing using xslt (Believe me I tried :-)

Since the interest of this column and the MozzIE project is strict xhtml and xforms having to use html technologies was a pain.
XSP.NET pages have the extension .xhtml and can exist on the same site as aspx pages.
XSP.NET generates pages using a form of xml:include, but it is not pure xml:include. One day they will probably be the same but the .NET framework does not support xml:base which is really required for xml:include to work.
Pages can just be very simple xhtml or include other pages or web services. One of the best patterns of use is to include the WSDL from a web service as a schema in the model of a web page:

<xforms:model id="mdlForm">

<xsp:include src="~/services/les.asmx?WSDL" transform="../stylesheets/ExtractSchema.xslt">

<xsp:include file="../schema/soap.xsd" transform="../stylesheets/ExtractSchema.xslt"/>


<xsp:include file="../schema/LES.xsd" transform="../stylesheets/ExtractConstants.xslt"/>


<xsp:include file="../models/LookupItem.xhtml" transform="../stylesheets/ExtractModel.xslt"/>
</xf:model>

The examples extract a schema from a live web service and embed it into the xforms model.

<xsl:stylesheet version="1.0" xsl="http://www.w3.org/1999/XSL/Transform" xsd="http://www.w3.org/2001/XMLSchema">

<xsl:output indent="yes" method="xml">


<xsl:param name="service-name"></xsl:param>

<xsl:template match="//xsd:schema">
<xsl:variable name="schema-name" select="name(.)">
<xsl:variable name="target-namespace" select="./@targetNamespace">

<xsl:element name="contents" xmlns="urn:schemas-vistic-net:xsp">
<xsl:element name="{$schema-name}" namespace="http://www.w3.org/2001/XMLSchema">
<xsl:for-each select="descendant-or-self::*/namespace::*">
<xsl:copy>
</xsl:copy>

<xsl:attribute name="targetNamespace">
<xsl:value-of select="$target-namespace">
</xsl:value-of>


<xsl:copy-of select="./*">
</xsl:copy-of>
</xsl:attribute>
</xsl:for-each>

</xsl:element>

This is from a real site using XSP and will become part of the sample site I am working on.
This ability to develop sites using modules then have them rendered as a complete page is similar to cocoon, but not as complicated.
So have a go, I will be posting more samples in the next few days which should help people get started with this ASP.NET add-on.

Content Types

2007-01-24T11:32:00.000+13:00

I have been working hard on the Beta2 for MozzIE and have been looking at the content types we use. Found that the plug-in did not render .svg file so have added a content type for that.
The mechanism used by MozzIE to switch from the MSHTML Active Document to MozzIE is the one documented by Microsoft. It is a very open and easy to use technique that is well documented.
The technique and restrictions are well documented in this article
Changes to Functionality in Microsoft Windows XP Service Pack 2

As part of this we handle the following mime content types:

xhtml+xforms - application/xhtml+xml
xul - application/vnd.mozilla.xul+xml
svg - image/svg+xml

There is no technical reason why we could not handle xml as well, however the default behavior of Internet Explorer would need to change, which is something we have not wanted to do. All of the enhancements have added to IE, not removed any existing functionality.
So it is critical that web site authers wanting to use MozzIE set the content type correctly for the pages being served. Apache based servers do this fairly well, MS IIS sites need a bit of configuration however.
Possibly we will support more mime types as the project progresses. One idea is to add a custom page to the installer that allows an experienced user to select the mime types to be handled by MozzIE and those that stay with IE.
One issue not yet resolved is that when a file is opened, IE does doctype sniffing and sees most things as XML rather than using the content handler. We are working to find a solution to this, for now the only option is to download the file.