Adding the elements

RDFa requires two elements, meta and link. The main ways in which they change from normal XHTML are:

• meta takes an attribute of property instead of name;
• both meta and link can be nested inside themselves and each other;
• both meta and link can take inline text;
• both meta and link can appear anywhere within a document.

Since there were so many changes to be made it got to the point where a redefinition of the existing elements left so little of the original intact, that new modules were created for each. However, once that was done it became clear that the two modules were almost complete copies of each other, so they have been merged into a new module called xhtml11-rdfa-1.xsd.

This means that in xhtml11-modules-1.xsd the references to xhtml-meta-1.xsd and xhtml-link-1.xsd have been removed, and replaced with this single module.

All of the attributes that were needed for RDFa were moved out to a separate module, and placed in the 'common attribute' collection (see next section). Then all that is needed is for meta and link to use this collection exactly like other elements do. (Note that all the other attributes have been left intact for now.):

  <xs:attributeGroup name="meta.attlist">
    <xs:attributeGroup ref="Common.attrib"/>
    <xs:attribute name="name" type="xs:NMTOKEN"/>
    <xs:attribute name="scheme" type="xh11d:CDATA"/>
  </xs:attributeGroup>

  <xs:attributeGroup name="link.attlist">
    <xs:attributeGroup ref="Common.attrib"/>
    <xs:attribute name="media" type="xh11d:MediaDesc"/>
  </xs:attributeGroup>

(At some point scheme may get deprecated since property is a CURIE, which means that the namespace prefix plays the role of a scheme.)

Defining the elements themselves then becomes a case of adding a common content model:

  <xs:group name="rdfa.content">
    <xs:choice>
      <xs:element ref="meta" />
      <xs:element ref="link" />
    </xs:choice>
  </xs:group>

And then making use of it in both elements:

  <xs:complexType name="meta.type" mixed="true">
    <xs:group ref="rdfa.content" minOccurs="0"
      maxOccurs="unbounded" />
    <xs:attributeGroup ref="meta.attlist"/>
  </xs:complexType>

  <xs:complexType name="link.type" mixed="true">
    <xs:group ref="rdfa.content" minOccurs="0"
      maxOccurs="unbounded" />
    <xs:attributeGroup ref="link.attlist"/>
  </xs:complexType>

  <xs:element name="link" type="link.type"/>
  <xs:element name="meta" type="meta.type"/>

Note that defining both elements in terms of each other fulfills the requirement that they can be nested to any depth. And by adding mixed="true" we also provide for inline text in both elements, although their meanings differ (inline text in meta sets the value for content, whilst inline text in link is the same as in a).

Finally, to allow the use of these two elements anywhere in the XHTML document we need to redefine the Misc.extra group in xhtml.xsd:

  <xs:group name="Misc.extra">
    <xs:choice>
      <xs:group ref="xh11:Misc.extra" />
      <xs:element ref="meta"/>
      <xs:element ref="link"/>
    </xs:choice>
  </xs:group>

Adding the attributes

To incorporate the attributes a module called rdfa-10-rules.xsd was created, and in it an attribute group was added:

  <xs:attributeGroup name="rdfa.attlist">
    <xs:attribute name="about" type="CurieOrURI"/>
    <xs:attribute name="content" type="xs:string" />
    <xs:attribute name="datatype" type="Curie"/>
    <xs:attribute name="href" type="CurieOrURI"/>
    <xs:attribute name="property" type="Curie"/>
    <xs:attribute name="rel" type="CurieOrLinkTypeList"/>
    <xs:attribute name="rev" type="CurieOrLinkTypeList"/>
  </xs:attributeGroup>

All of the data types listed here are included in the same module, and discussed in the next section. (They will however, be broken out into a separate 'types' document.)

As you saw in the previous section, some of the attributes that XHTML uses are not here--more XHTML-specific attributes have been kept back in the XHTML driver file.

To make use of these RDFa attributes we simply need to redefine Common.extra:

  <xs:attributeGroup name="Common.extra">
    <xs:attributeGroup ref="Common.extra"/>
    <xs:attributeGroup ref="rdfa.attlist" />
    <xs:attribute name="charset" type="xh11d:Charset"/>
    <xs:attribute name="hreftype" type="xh11d:ContentType"/>
    <xs:attribute name="hreflang" type="xh11d:LanguageCode"/>
    <xs:attribute name="http-equiv" type="xs:NMTOKEN"/>
  </xs:attributeGroup>

Common.extra is an empty definition in XHTML M12N but is part of Common.attribs which is applied to every element.

Note that hreftype is used here instead of type since otherwise there would be a conflict. This is the name proposed in XHTML 2.0.

Adding the datatypes

As we saw in the previous section, the RDFa attributes rely on a set of datatypes, the most important being the CURIE.

CURIE

Although this may change, for now a CURIE is defined as follows:

  <xs:simpleType name="Curie">
    <xs:restriction base="xs:string">
      <xs:pattern value="[\i-[:]][\c-[:]]*:.+" />
    </xs:restriction>
  </xs:simpleType>

It's pretty straightforward, but to give a quick overview:

• \i is the set of characters that can start an XML name, which is any letter, an '_' or a ':';
• [\i-[:]] means any character that is in the set \i but is not a colon...for obvious reasons;

So the first character of our CURIE must be a letter or an underscore, i.e., not a number, colon, equals sign, etc. After that we can have any XML name character, which can now include numbers:

• \c is the set of XML name characters that can appear after the first character;
• [\c-[:]] is the same set but without a colon;
• [\c-[:]]* means match as many as we can (zero or more);

The prefix part has been made quite strict because it must match the namespace prefix rules. But after the colon we can be looser, hence:

• .+ means one or more of any character.

Note that we could say that the part after the colon can be any valid URI, and this does actually work fine. But since pretty much anything matches successfully, there didn't seem a lot of point. However, so that we have a record of it, making the part after the colon a valid URI can be done with the following expresson (line-breaks only added for layout):

  [\i-[:]][\c-[:]]*
  :
  (([^:/\?#]+):)?(//([^/\?#]*))?([^\?#]*)(\?([^#]*))?(#(.*))?

Escaped CURIEs

An escaped CURIE is used in places where direct use can be ambiguous, and is currently achieved by placing square brackets around the CURIE. The definition is as follows:

  <xs:simpleType name="CurieEsc">
    <xs:restriction base="xs:string">
      <xs:pattern value="\[[\i-[:]][\c-[:]]*:.+\]" />
    </xs:restriction>
  </xs:simpleType>

Note that there is no way with XML Schemas for this regular expression to reference our first expression, hence the repitition of the pattern for a CURIE.

Escaped CURIE or URI

Once we have our escaped CURIE we can use it to create a type that can contain both a URI and an escaped CURIE:

  <xs:simpleType name="CurieOrURI">
    <xs:union memberTypes="xs:anyURI CurieEsc" />
  </xs:simpleType>

This type is used for about and href.

CURIE or Link Type List

The rel and rev attributes are a little tricky since they can contain CURIEs as well as tokens that come from a standard list...which is made slightly more complicated by the fact that it is acceptible to have multiple values.

The first step is to create a 'CURIE or link type' definition, which allows either a CURIE or one of a restricted range of values:

  <xs:simpleType name="CurieOrLinkType">
    <xs:union memberTypes="Curie">
      <xs:simpleType>
        <xs:restriction base="xs:string">
          <xs:enumeration value="alternate"/>
          <xs:enumeration value="forward"/>
          <xs:enumeration value="start"/>
          <xs:enumeration value="next" />
          .
          .
          .
          <xs:enumeration value="profile" />
          <xs:enumeration value="role" />
          <xs:enumeration value="cite" />
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>

Once we have this it's a simple matter to create a list of 'CURIE or link types':

  <xs:simpleType name="CurieOrLinkTypeList">
    <xs:list itemType="CurieOrLinkType" />
  </xs:simpleType>

This definition would make the following valid:

  <link rel="subsection ab:foreward prev" href="[cd:ef]" />

and the following invalid:

  <link rel="blah ab:foreward" href="[cd:ef]" />

Rationalising @href

One of the problems with the schemas created for XHTML Modularization 1.1 is that attributes that play the same role in different places are not always rationalised. One example of this is the href attribute used on anchors and image maps, and another is the use of type on object, script and style.

In order to allow href to appear anyway in the document we need to remove it from the places where it is already set. We achieve this by creating replacements for xhtml-hypertext-1.xsd and xhtml-csismap-1.xsd in which any references to any of the attributes that have now been moved into the Common.attribs group, are dropped.

Constructor

Constructs an instance of the EventListener class.

Parameters: Optional JavaScript function to be called from the proxy's implementation of handleEvent.

Return Value: none

Example Usage

function handleEvent(evt)
{
  ...
}

  ...

  var l = new EventListener(handleEvent);

Destroy

Destroy the instance and free its resources.

Parameters: none

Return Value: none

Example Usage

function handleEvent(evt)
{
  ...
}

  ...

  var l = new EventListener(handleEvent);

  ...

  l.Destroy();

SetHandler

Nominates the JavaScript method to be used as an event handler by this instance. Overrides any handler nominated by preceding calls to this method or in the constructor.

Parameters: JavaScript function to be called from the proxy's implementation of handleEvent.

Return Value: none

Example Usage

function handleEvent(evt)
{
  ...
}

  ...

  var l = new EventListener();
  l.SetHandler(handleEvent);

AutoHide

The value of this parameter dictates whether the object will automatically hide when it loses mouse focus. If this parameter is unspecified or invalid, the default setting of false is used.

Values: true | false

Context

The value of this parameter dictates the context in which the Edge, Position and Direction parameters are to be applied. If this parameter is unspecified or invalid, the default setting of "screen" is used.

Values: "screen" | [handle]

Where [handle] represents the value returned by an object's GetHandle() method.

Direction

The value of this parameter dictates in which direction, relative to its Context, an AutoHide object will slide open. If this parameter is unspecified or invalid, the default setting of "in" is used.

Values: "in" | "out"

Edge

The value of this parameter dictates the edge of the Context area that the object will be positioned against. If this parameter is unspecified or invalid, the default setting of "none" is used.

Values: "left" | "right" | "top" | "bottom" | "none"

Height

The value of this parameter dictates the height, in pixels, of the client area of the Renderer window. The client area includes only the rendered content; window chrome should not be accounted for here.

Values: any positive integer

Opacity

The value of this parameter dictates the relative opacity of the object. A value of 100 renders the the object completely opaque, whereas a value of 0 renders the object completely transparent. If this parameter is invalid or unspecified, the default value of 100 is used.

Values: any integer in the range 0 .. 100

Position

The value of this parameter dictates the position along an Edge of a Context, at which the object will be placed. If this parameter is unspecified or invalid, the default setting of "centred" is used.

Values: "left" | "right" | "top" | "bottom" | "centred"

PositionX

The value of this parameter dictates the precise position, measured in pixels, along the x-axis of a Context, at which the object will be placed.

Values: any positive integer

PositionY

The value of this parameter dictates the precise position, measured in pixels, along the y-axis of a Context, at which the object will be placed.

Values: any positive integer

Style

The value of this parameter dictates a number of different window styles, each one set by a different bit. These bits may be specified by performing a logical or operation with the appropriate values, described in the list below. Values that are not present in the list are reserved and should not be used. In the event that other values are used, behaviour is undefined.

0x00000002: Hides the taskbar button for this window.
0x00000200: Displays a maximise button in the title bar of the window.
0x00000400: Displays a minimise button in the title bar of the window.
0x00000800: Adds a system menu for this window.
0x00001000: Displays a close button in the title bar of the window.
0x00002000: Creates the window in its maximised state.
0x00004000: Creates the window in its minimised state.
0x00008000: Forces the window to always be displayed on top of other windows.
0x00200000: Displays a window with no border.
0x02000000: Displays a border around the window.
0x20000000: Displays a title bar on the window.

Title

The value of this parameter dictates the title that is assigned to the object. If this parameter is unspecified or invalid, the default setting of the application name is used.

Values: any string

Transparency

The value of this parameter nominates, in hexadecimal rrggbb format, a colour to be rendered as transparent within the object. This has the effect of making all regions that match the nominated colour completely hidden, with other windows and applications visible "underneath". If this parameter is unspecified or invalid, no colours are nominated as transparent.

Values: any string containing a 24 bit hexadecimal value, where the 8 highest-order bits denote the level of red in the nominated colour, the 8 middle-order bits denote the level of green in the nominated colour and the 8 lowest-order bits denote the level of blue in the nominated colour

Type

The value of this parameter dictates whether an XHTML or a text Renderer is created. If this parameter is unspecified or invalid, the default setting of "xhtml" is used.

Values: "xhtml" | "text"

Width

The value of this parameter dictates the width, in pixels, of the client area of the Renderer window. The client area includes only the rendered content; window chrome should not be accounted for here.

Values: any positive integer

Constructor

Constructs an instance of the Renderer class.

Parameters: Optional creation parameters, used to set physical properties of the window.

Return Value: none

Example Usage

  var r = new Renderer(
      {
          Type: "xhtml",
          Width: 800,
          Height: 600
      }
  );
  r.Create();
  r.Show();

Create

Create the Renderer window.

Parameters: Optional creation parameters, used if none were specified during instantiation

Return Value: none

Example Usage

  var r = new Renderer;
  r.Create(
      {
          Type: "xhtml",
          Width: 800,
          Height: 600
      }
  );
  r.Show();

Destroy

Destroy the Renderer window and free its resources.

Parameters: none

Return Value: none

Example Usage

  var r = new Renderer;
  r.Create(
      {
          Type: "xhtml",
          Width: 800,
          Height: 600
      }
  );
  r.Show();

  ...

  r.Destroy();

Show

Show the Renderer window.

Parameters: none

Return Value: none

Example Usage

  var r = new Renderer;
  r.Create(
      {
          Type: "xhtml",
          Width: 800,
          Height: 600
      }
  );
  r.Show();

Hide

Hide the Renderer window.

Parameters: none

Return Value: none

Example Usage

  var r = new Renderer;
  r.Create(
      {
          Type: "xhtml",
          Width: 800,
          Height: 600
      }
  );
  r.Show();

  ...

  r.Hide();

Load

Load and render an XHTML document.

Parameters: an RFC3986-conformant URI string

Return Value: none

Example Usage

  var r = new Renderer;
  r.Create(
      {
          Type: "xhtml",
          Width: 800,
          Height: 600
      }
  );
  r.Show();
  r.Load("http://www.formsplayer.com/");

Write

Load and render in-memory data.

Parameters: a string containing either an XHTML document or plain text (dependent on the object's Type)

Return Value: none

Example Usage

  var r = new Renderer;
  r.Create(
      {
          Type: "xhtml",
          Width: 800,
          Height: 600
      }
  );
  r.Show();
  r.Write("<html xmlns=\"http://www.w3.org/1999/xhtml\"><head><title>Title</title></head><body>Body</body></html>");

Insert

On text renderers only, insert in-memory data before existing rendered data.

Parameters: a string containing plain text

Return Value: none

Example Usage

  var r = new Renderer;
  r.Create(
      {
          Type: "text",
          Width: 800,
          Height: 600
      }
  );
  r.Show();
  r.Write("This is line two.\n");
  r.Insert("This is line one.\n");

Append

On text renderers only, append in-memory data after existing rendered data.

Parameters: a string containing plain text

Return Value: none

Example Usage

  var r = new Renderer;
  r.Create(
      {
          Type: "text",
          Width: 800,
          Height: 600
      }
  );
  r.Show();
  r.Write("This is line one.\n");
  r.Append("This is line two.\n");

Clear

Clear the rendered data.

Parameters: none

Return Value: none

Example Usage

  var r = new Renderer;
  r.Create(
      {
          Type: "xhtml",
          Width: 800,
          Height: 600
      }
  );
  r.Show();
  r.Write("<html xmlns=\"http://www.w3.org/1999/xhtml\"><head><title>Title</title></head><body>Body</body></html>");

  ...

  r.Clear();

GetHandle

Retrieves the handle associated with this instance, which may be used as the value for the Context parameter.

Parameters: none

Return Value: String containing the instance handle

Example Usage

  var r1 = new Renderer;
  r1.Create(
      {
          Type: "xhtml",
          Width: 800,
          Height: 600
      }
  );

  var r2 = new Renderer;
  r2.Create(
      {
          Type: "xhtml",
          Width: 200,
          Context: r1.GetHandle(),
          Edge: "left",
          Direction: "out"
      }
  );

  r1.Show();
  r2.Show();

GetRenderingImplementation

Retrieves the platform-dependent implementation of this instance, which may be used when handling new window requests.

Parameters: none

Return Value: ObjectParcel containing the platform-dependent Renderer implementation.

Example Usage

function onNewWindow(evt)
{
    var r = new Renderer;
    r.Create( { Type:"xhtml" } );
    r.Show();

    evt.parameter.objectValue = r.GetRenderingImplementation();
}

function handleEvent(evt)
{
    switch(evt.type)
    {
        case "renderer-request-newwindow":
            onNewWindow(event);
            break;
        ...
    }
}

    ...

    var l = new EventListener;
    l.SetHandler(handleEvent);

    var r = new Renderer;
    r.Create(
        {
            Type: "xhtml",
            Width: 800,
            Height: 600
        }
    );
    r.addEventListener("renderer-request-newwindow", l, true);
    r.Show();

    ...